comparing eedb95afb989c2fd2c8526d2a6c89be8eaa9837b and old-main on anil.recoil.org/thicket

+205

.gitignore

···

       1
       1
       +
       # Byte-compiled / optimized / DLL files

     

       2
       2
       +
       __pycache__/

     

       3
       3
       +
       *.py[codz]

     

       4
       4
       +
       *$py.class

     

       5
       5
       +
       

     

       6
       6
       +
       # C extensions

     

       7
       7
       +
       *.so

     

       8
       8
       +
       

     

       9
       9
       +
       # Distribution / packaging

     

       10
       10
       +
       .Python

     

       11
       11
       +
       build/

     

       12
       12
       +
       develop-eggs/

     

       13
       13
       +
       dist/

     

       14
       14
       +
       downloads/

     

       15
       15
       +
       eggs/

     

       16
       16
       +
       .eggs/

     

       17
       17
       +
       lib/

     

       18
       18
       +
       lib64/

     

       19
       19
       +
       parts/

     

       20
       20
       +
       sdist/

     

       21
       21
       +
       var/

     

       22
       22
       +
       wheels/

     

       23
       23
       +
       share/python-wheels/

     

       24
       24
       +
       *.egg-info/

     

       25
       25
       +
       .installed.cfg

     

       26
       26
       +
       *.egg

     

       27
       27
       +
       MANIFEST

     

       28
       28
       +
       

     

       29
       29
       +
       # PyInstaller

     

       30
       30
       +
       #  Usually these files are written by a python script from a template

     

       31
       31
       +
       #  before PyInstaller builds the exe, so as to inject date/other infos into it.

     

       32
       32
       +
       *.manifest

     

       33
       33
       +
       *.spec

     

       34
       34
       +
       

     

       35
       35
       +
       # Installer logs

     

       36
       36
       +
       pip-log.txt

     

       37
       37
       +
       pip-delete-this-directory.txt

     

       38
       38
       +
       

     

       39
       39
       +
       # Unit test / coverage reports

     

       40
       40
       +
       htmlcov/

     

       41
       41
       +
       .tox/

     

       42
       42
       +
       .nox/

     

       43
       43
       +
       .coverage

     

       44
       44
       +
       .coverage.*

     

       45
       45
       +
       .cache

     

       46
       46
       +
       nosetests.xml

     

       47
       47
       +
       coverage.xml

     

       48
       48
       +
       *.cover

     

       49
       49
       +
       *.py.cover

     

       50
       50
       +
       .hypothesis/

     

       51
       51
       +
       .pytest_cache/

     

       52
       52
       +
       cover/

     

       53
       53
       +
       

     

       54
       54
       +
       # Translations

     

       55
       55
       +
       *.mo

     

       56
       56
       +
       *.pot

     

       57
       57
       +
       

     

       58
       58
       +
       # Django stuff:

     

       59
       59
       +
       *.log

     

       60
       60
       +
       local_settings.py

     

       61
       61
       +
       db.sqlite3

     

       62
       62
       +
       db.sqlite3-journal

     

       63
       63
       +
       

     

       64
       64
       +
       # Flask stuff:

     

       65
       65
       +
       instance/

     

       66
       66
       +
       .webassets-cache

     

       67
       67
       +
       

     

       68
       68
       +
       # Scrapy stuff:

     

       69
       69
       +
       .scrapy

     

       70
       70
       +
       

     

       71
       71
       +
       # Sphinx documentation

     

       72
       72
       +
       docs/_build/

     

       73
       73
       +
       

     

       74
       74
       +
       # PyBuilder

     

       75
       75
       +
       .pybuilder/

     

       76
       76
       +
       target/

     

       77
       77
       +
       

     

       78
       78
       +
       # Jupyter Notebook

     

       79
       79
       +
       .ipynb_checkpoints

     

       80
       80
       +
       

     

       81
       81
       +
       # IPython

     

       82
       82
       +
       profile_default/

     

       83
       83
       +
       ipython_config.py

     

       84
       84
       +
       

     

       85
       85
       +
       # pyenv

     

       86
       86
       +
       #   For a library or package, you might want to ignore these files since the code is

     

       87
       87
       +
       #   intended to run in multiple environments; otherwise, check them in:

     

       88
       88
       +
       # .python-version

     

       89
       89
       +
       

     

       90
       90
       +
       # pipenv

     

       91
       91
       +
       #   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.

     

       92
       92
       +
       #   However, in case of collaboration, if having platform-specific dependencies or dependencies

     

       93
       93
       +
       #   having no cross-platform support, pipenv may install dependencies that don't work, or not

     

       94
       94
       +
       #   install all needed dependencies.

     

       95
       95
       +
       #Pipfile.lock

     

       96
       96
       +
       

     

       97
       97
       +
       # UV

     

       98
       98
       +
       #   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.

     

       99
       99
       +
       #   This is especially recommended for binary packages to ensure reproducibility, and is more

     

       100
       100
       +
       #   commonly ignored for libraries.

     

       101
       101
       +
       #uv.lock

     

       102
       102
       +
       

     

       103
       103
       +
       # poetry

     

       104
       104
       +
       #   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.

     

       105
       105
       +
       #   This is especially recommended for binary packages to ensure reproducibility, and is more

     

       106
       106
       +
       #   commonly ignored for libraries.

     

       107
       107
       +
       #   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control

     

       108
       108
       +
       #poetry.lock

     

       109
       109
       +
       #poetry.toml

     

       110
       110
       +
       

     

       111
       111
       +
       # pdm

     

       112
       112
       +
       #   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.

     

       113
       113
       +
       #   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.

     

       114
       114
       +
       #   https://pdm-project.org/en/latest/usage/project/#working-with-version-control

     

       115
       115
       +
       #pdm.lock

     

       116
       116
       +
       #pdm.toml

     

       117
       117
       +
       .pdm-python

     

       118
       118
       +
       .pdm-build/

     

       119
       119
       +
       

     

       120
       120
       +
       # pixi

     

       121
       121
       +
       #   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.

     

       122
       122
       +
       #pixi.lock

     

       123
       123
       +
       #   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one

     

       124
       124
       +
       #   in the .venv directory. It is recommended not to include this directory in version control.

     

       125
       125
       +
       .pixi

     

       126
       126
       +
       

     

       127
       127
       +
       # PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm

     

       128
       128
       +
       __pypackages__/

     

       129
       129
       +
       

     

       130
       130
       +
       # Celery stuff

     

       131
       131
       +
       celerybeat-schedule

     

       132
       132
       +
       celerybeat.pid

     

       133
       133
       +
       

     

       134
       134
       +
       # SageMath parsed files

     

       135
       135
       +
       *.sage.py

     

       136
       136
       +
       

     

       137
       137
       +
       # Environments

     

       138
       138
       +
       .env

     

       139
       139
       +
       .envrc

     

       140
       140
       +
       .venv

     

       141
       141
       +
       env/

     

       142
       142
       +
       venv/

     

       143
       143
       +
       ENV/

     

       144
       144
       +
       env.bak/

     

       145
       145
       +
       venv.bak/

     

       146
       146
       +
       

     

       147
       147
       +
       # Spyder project settings

     

       148
       148
       +
       .spyderproject

     

       149
       149
       +
       .spyproject

     

       150
       150
       +
       

     

       151
       151
       +
       # Rope project settings

     

       152
       152
       +
       .ropeproject

     

       153
       153
       +
       

     

       154
       154
       +
       # mkdocs documentation

     

       155
       155
       +
       /site

     

       156
       156
       +
       

     

       157
       157
       +
       # mypy

     

       158
       158
       +
       .mypy_cache/

     

       159
       159
       +
       .dmypy.json

     

       160
       160
       +
       dmypy.json

     

       161
       161
       +
       

     

       162
       162
       +
       # Pyre type checker

     

       163
       163
       +
       .pyre/

     

       164
       164
       +
       

     

       165
       165
       +
       # pytype static type analyzer

     

       166
       166
       +
       .pytype/

     

       167
       167
       +
       

     

       168
       168
       +
       # Cython debug symbols

     

       169
       169
       +
       cython_debug/

     

       170
       170
       +
       

     

       171
       171
       +
       # PyCharm

     

       172
       172
       +
       #  JetBrains specific template is maintained in a separate JetBrains.gitignore that can

     

       173
       173
       +
       #  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore

     

       174
       174
       +
       #  and can be added to the global gitignore or merged into this file.  For a more nuclear

     

       175
       175
       +
       #  option (not recommended) you can uncomment the following to ignore the entire idea folder.

     

       176
       176
       +
       #.idea/

     

       177
       177
       +
       

     

       178
       178
       +
       # Abstra

     

       179
       179
       +
       # Abstra is an AI-powered process automation framework.

     

       180
       180
       +
       # Ignore directories containing user credentials, local state, and settings.

     

       181
       181
       +
       # Learn more at https://abstra.io/docs

     

       182
       182
       +
       .abstra/

     

       183
       183
       +
       

     

       184
       184
       +
       # Visual Studio Code

     

       185
       185
       +
       #  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 

     

       186
       186
       +
       #  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore

     

       187
       187
       +
       #  and can be added to the global gitignore or merged into this file. However, if you prefer, 

     

       188
       188
       +
       #  you could uncomment the following to ignore the entire vscode folder

     

       189
       189
       +
       # .vscode/

     

       190
       190
       +
       

     

       191
       191
       +
       # Ruff stuff:

     

       192
       192
       +
       .ruff_cache/

     

       193
       193
       +
       

     

       194
       194
       +
       # PyPI configuration file

     

       195
       195
       +
       .pypirc

     

       196
       196
       +
       

     

       197
       197
       +
       # Marimo

     

       198
       198
       +
       marimo/_static/

     

       199
       199
       +
       marimo/_lsp/

     

       200
       200
       +
       __marimo__/

     

       201
       201
       +
       

     

       202
       202
       +
       # Streamlit

     

       203
       203
       +
       .streamlit/secrets.toml

     

       204
       204
       +
       

     

       205
       205
       +
       thicket.yaml

+219 -13

ARCH.md

···

       53
       53
        
       │       │   ├── commands/   # Subcommands

     

       54
       54
        
       │       │   │   ├── __init__.py

     

       55
       55
        
       │       │   │   ├── init.py      # Initialize git store

     

       56
       56
       -
       │       │   │   ├── add.py       # Add feed to config

     

       56
       56
       +
       │       │   │   ├── add.py       # Add users and feeds

     

       57
       57
        
       │       │   │   ├── sync.py      # Sync feeds

     

       58
       58
       -
       │       │   │   ├── list.py      # List users/feeds

     

       59
       59
       -
       │       │   │   └── search.py    # Search entries

     

       58
       58
       +
       │       │   │   ├── list_cmd.py  # List users/feeds

     

       59
       59
       +
       │       │   │   ├── duplicates.py # Manage duplicate entries

     

       60
       60
       +
       │       │   │   ├── links_cmd.py  # Extract and categorize links

     

       61
       61
       +
       │       │   │   └── index_cmd.py  # Build reference index and show threads

     

       60
       62
        
       │       │   └── utils.py    # CLI utilities (progress, formatting)

     

       61
       63
        
       │       ├── core/           # Core business logic

     

       62
       64
        
       │       │   ├── __init__.py

     

       63
       65
        
       │       │   ├── feed_parser.py   # Feed parsing and normalization

     

       64
       66
        
       │       │   ├── git_store.py     # Git repository operations

     

       65
       65
       -
       │       │   ├── cache.py         # Cache management

     

       66
       66
       -
       │       │   └── sanitizer.py     # Filename and HTML sanitization

     

       67
       67
       +
       │       │   └── reference_parser.py # Link extraction and threading

     

       67
       68
        
       │       ├── models/         # Pydantic data models

     

       68
       69
        
       │       │   ├── __init__.py

     

       69
       70
        
       │       │   ├── config.py        # Configuration models

     

       70
       71
        
       │       │   ├── feed.py          # Feed/Entry models

     

       71
       72
        
       │       │   └── user.py          # User metadata models

     

       72
       73
        
       │       └── utils/          # Shared utilities

     

       73
       73
       -
       │           ├── __init__.py

     

       74
       74
       -
       │           ├── paths.py         # Path handling

     

       75
       75
       -
       │           └── network.py       # HTTP client wrapper

     

       74
       74
       +
       │           └── __init__.py

     

       76
       75
        
       ├── tests/

     

       77
       76
        
       │   ├── __init__.py

     

       78
       77
        
       │   ├── conftest.py         # pytest configuration

     
···

       158
       157
        
       git-store/

     

       159
       158
        
       ├── index.json              # User directory index

     

       160
       159
        
       ├── duplicates.json         # Manual curation of duplicate entries

     

       160
       160
       +
       ├── links.json              # Unified links, references, and mapping data

     

       161
       161
        
       ├── user1/

     

       162
       162
       -
       │   ├── metadata.json       # User metadata

     

       163
       162
        
       │   ├── entry_id_1.json     # Sanitized entry files

     

       164
       163
        
       │   ├── entry_id_2.json

     

       165
       164
        
       │   └── ...

     
···

       230
       229
        
       thicket list users

     

       231
       230
        
       thicket list feeds --user alyssa

     

       232
       231
        
       

     

       233
       233
       -
       # Search entries

     

       234
       234
       -
       thicket search "keyword" --user alyssa --since 2025-01-01

     

       235
       235
       -
       

     

       236
       232
        
       # Manage duplicate entries

     

       237
       233
        
       thicket duplicates list

     

       238
       234
        
       thicket duplicates add <entry_id_1> <entry_id_2>  # Mark as duplicates

     

       239
       235
        
       thicket duplicates remove <entry_id_1> <entry_id_2>  # Unmark duplicates

     

       236
       236
       +
       

     

       237
       237
       +
       # Link processing and threading

     

       238
       238
       +
       thicket links --verbose                 # Extract and categorize all links

     

       239
       239
       +
       thicket index --verbose                 # Build reference index for threading

     

       240
       240
       +
       thicket threads                         # Show conversation threads

     

       241
       241
       +
       thicket threads --username user1        # Show threads for specific user

     

       242
       242
       +
       thicket threads --min-size 3           # Show threads with minimum size

     

       240
       243
        
       ```

     

       241
       244
        
       

     

       242
       245
        
       ## Performance Considerations

     
···

       329
       332
        
                   homepage=self.author_uri or self.link,

     

       330
       333
        
                   icon=self.logo or self.icon or self.image_url

     

       331
       334
        
               )

     

       332
       332
       -
       ```
     

       335
       335
       +
       ```

     

       336
       336
       +
       

     

       337
       337
       +
       ## Link Processing and Threading Architecture

     

       338
       338
       +
       

     

       339
       339
       +
       ### Overview

     

       340
       340
       +
       The thicket system implements a sophisticated link processing and threading system to create email-style threaded views of blog entries by tracking cross-references between different blogs.

     

       341
       341
       +
       

     

       342
       342
       +
       ### Link Processing Pipeline

     

       343
       343
       +
       

     

       344
       344
       +
       #### 1. Link Extraction (`thicket links`)

     

       345
       345
       +
       The `links` command systematically extracts all outbound links from blog entries and categorizes them:

     

       346
       346
       +
       

     

       347
       347
       +
       ```python

     

       348
       348
       +
       class LinkData(BaseModel):

     

       349
       349
       +
           url: str                    # Fully resolved URL

     

       350
       350
       +
           entry_id: str              # Source entry ID

     

       351
       351
       +
           username: str              # Source username

     

       352
       352
       +
           context: str               # Surrounding text context

     

       353
       353
       +
           category: str              # "internal", "user", or "unknown"

     

       354
       354
       +
           target_username: Optional[str]  # Target user if applicable

     

       355
       355
       +
       ```

     

       356
       356
       +
       

     

       357
       357
       +
       **Link Categories:**

     

       358
       358
       +
       - **Internal**: Links to the same user's domain (self-references)

     

       359
       359
       +
       - **User**: Links to other tracked users' domains

     

       360
       360
       +
       - **Unknown**: Links to external sites not tracked by thicket

     

       361
       361
       +
       

     

       362
       362
       +
       #### 2. URL Resolution

     

       363
       363
       +
       All links are properly resolved using the Atom feed's base URL to handle:

     

       364
       364
       +
       - Relative URLs (converted to absolute)

     

       365
       365
       +
       - Protocol-relative URLs

     

       366
       366
       +
       - Fragment identifiers

     

       367
       367
       +
       - Redirects and canonical URLs

     

       368
       368
       +
       

     

       369
       369
       +
       #### 3. Domain Mapping

     

       370
       370
       +
       The system builds a comprehensive domain mapping from user configuration:

     

       371
       371
       +
       - Feed URLs → domain extraction

     

       372
       372
       +
       - Homepage URLs → domain extraction

     

       373
       373
       +
       - Reverse mapping: domain → username

     

       374
       374
       +
       

     

       375
       375
       +
       ### Threading System

     

       376
       376
       +
       

     

       377
       377
       +
       #### 1. Reference Index Generation (`thicket index`)

     

       378
       378
       +
       Creates a bidirectional reference index from the categorized links:

     

       379
       379
       +
       

     

       380
       380
       +
       ```python

     

       381
       381
       +
       class BlogReference(BaseModel):

     

       382
       382
       +
           source_entry_id: str

     

       383
       383
       +
           source_username: str

     

       384
       384
       +
           target_url: str

     

       385
       385
       +
           target_username: Optional[str]

     

       386
       386
       +
           target_entry_id: Optional[str]

     

       387
       387
       +
           context: str

     

       388
       388
       +
       ```

     

       389
       389
       +
       

     

       390
       390
       +
       #### 2. Thread Detection Algorithm

     

       391
       391
       +
       Uses graph traversal to find connected blog entries:

     

       392
       392
       +
       - **Outbound references**: Links from an entry to other entries

     

       393
       393
       +
       - **Inbound references**: Links to an entry from other entries

     

       394
       394
       +
       - **Thread members**: All entries connected through references

     

       395
       395
       +
       

     

       396
       396
       +
       #### 3. Threading Display (`thicket threads`)

     

       397
       397
       +
       Creates email-style threaded views:

     

       398
       398
       +
       - Chronological ordering within threads

     

       399
       399
       +
       - Reference counts (outbound/inbound)

     

       400
       400
       +
       - Context preservation

     

       401
       401
       +
       - Filtering options (user, entry, minimum size)

     

       402
       402
       +
       

     

       403
       403
       +
       ### Data Structures

     

       404
       404
       +
       

     

       405
       405
       +
       #### links.json Format (Unified Structure)

     

       406
       406
       +
       ```json

     

       407
       407
       +
       {

     

       408
       408
       +
         "links": {

     

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

     

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

     

       411
       411
       +
             "target_username": "user2"

     

       412
       412
       +
           },

     

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

     

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

     

       415
       415
       +
           }

     

       416
       416
       +
         },

     

       417
       417
       +
         "reverse_mapping": {

     

       418
       418
       +
           "https://blog.user.com/entry/456": ["https://example.com/post/123"],

     

       419
       419
       +
           "https://blog.user.com/entry/789": ["https://external-site.com/article"]

     

       420
       420
       +
         },

     

       421
       421
       +
         "references": [

     

       422
       422
       +
           {

     

       423
       423
       +
             "source_entry_id": "https://blog.user.com/entry/456",

     

       424
       424
       +
             "source_username": "user1",

     

       425
       425
       +
             "target_url": "https://example.com/post/123",

     

       426
       426
       +
             "target_username": "user2",

     

       427
       427
       +
             "target_entry_id": "https://example.com/post/123",

     

       428
       428
       +
             "context": "As mentioned in this post..."

     

       429
       429
       +
           }

     

       430
       430
       +
         ],

     

       431
       431
       +
         "user_domains": {

     

       432
       432
       +
           "user1": ["blog.user.com"],

     

       433
       433
       +
           "user2": ["example.com"]

     

       434
       434
       +
         }

     

       435
       435
       +
       }

     

       436
       436
       +
       ```

     

       437
       437
       +
       

     

       438
       438
       +
       This unified structure eliminates duplication by:

     

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

     

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

     

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

     

       442
       442
       +
       - Providing bidirectional mappings for efficient queries

     

       443
       443
       +
       

     

       444
       444
       +
       ### Unified Structure Benefits

     

       445
       445
       +
       

     

       446
       446
       +
       - **Eliminates Duplication**: Each URL appears only once with metadata

     

       447
       447
       +
       - **Single Source of Truth**: All link-related data in one file

     

       448
       448
       +
       - **Efficient Queries**: Fast lookups for both directions (URL→entries, entry→URLs)

     

       449
       449
       +
       - **Atomic Updates**: All link data changes together

     

       450
       450
       +
       - **Reduced I/O**: Fewer file operations

     

       451
       451
       +
       

     

       452
       452
       +
       ### Implementation Benefits

     

       453
       453
       +
       

     

       454
       454
       +
       1. **Systematic Link Processing**: All links are extracted and categorized consistently

     

       455
       455
       +
       2. **Proper URL Resolution**: Handles relative URLs and base URL resolution correctly

     

       456
       456
       +
       3. **Domain-based Categorization**: Automatically identifies user-to-user references

     

       457
       457
       +
       4. **Bidirectional Indexing**: Supports both "who links to whom" and "who is linked by whom"

     

       458
       458
       +
       5. **Thread Discovery**: Finds conversation threads automatically

     

       459
       459
       +
       6. **Rich Context**: Preserves surrounding text for each link

     

       460
       460
       +
       7. **Performance**: Pre-computed indexes for fast threading queries

     

       461
       461
       +
       

     

       462
       462
       +
       ### CLI Commands

     

       463
       463
       +
       

     

       464
       464
       +
       ```bash

     

       465
       465
       +
       # Extract and categorize all links

     

       466
       466
       +
       thicket links --verbose

     

       467
       467
       +
       

     

       468
       468
       +
       # Build reference index for threading

     

       469
       469
       +
       thicket index --verbose

     

       470
       470
       +
       

     

       471
       471
       +
       # Show all conversation threads

     

       472
       472
       +
       thicket threads

     

       473
       473
       +
       

     

       474
       474
       +
       # Show threads for specific user

     

       475
       475
       +
       thicket threads --username user1

     

       476
       476
       +
       

     

       477
       477
       +
       # Show threads with minimum size

     

       478
       478
       +
       thicket threads --min-size 3

     

       479
       479
       +
       ```

     

       480
       480
       +
       

     

       481
       481
       +
       ### Integration with Existing Commands

     

       482
       482
       +
       

     

       483
       483
       +
       The link processing system integrates seamlessly with existing thicket commands:

     

       484
       484
       +
       - `thicket sync` updates entries, requiring `thicket links` to be run afterward

     

       485
       485
       +
       - `thicket index` uses the output from `thicket links` for improved accuracy

     

       486
       486
       +
       - `thicket threads` provides the user-facing threading interface

     

       487
       487
       +
       

     

       488
       488
       +
       ## Current Implementation Status

     

       489
       489
       +
       

     

       490
       490
       +
       ### ✅ Completed Features

     

       491
       491
       +
       1. **Core Infrastructure**

     

       492
       492
       +
          - Modern CLI with Typer and Rich

     

       493
       493
       +
          - Pydantic data models for type safety

     

       494
       494
       +
          - Git repository operations with GitPython

     

       495
       495
       +
          - Feed parsing and normalization with feedparser

     

       496
       496
       +
       

     

       497
       497
       +
       2. **User and Feed Management**

     

       498
       498
       +
          - `thicket init` - Initialize git store

     

       499
       499
       +
          - `thicket add` - Add users and feeds with auto-discovery

     

       500
       500
       +
          - `thicket sync` - Sync feeds with progress tracking

     

       501
       501
       +
          - `thicket list` - List users, feeds, and entries

     

       502
       502
       +
          - `thicket duplicates` - Manage duplicate entries

     

       503
       503
       +
       

     

       504
       504
       +
       3. **Link Processing and Threading**

     

       505
       505
       +
          - `thicket links` - Extract and categorize all outbound links

     

       506
       506
       +
          - `thicket index` - Build reference index from links

     

       507
       507
       +
          - `thicket threads` - Display threaded conversation views

     

       508
       508
       +
          - Proper URL resolution with base URL handling

     

       509
       509
       +
          - Domain-based link categorization

     

       510
       510
       +
          - Context preservation for links

     

       511
       511
       +
       

     

       512
       512
       +
       ### 📊 System Performance

     

       513
       513
       +
       - **Link Extraction**: Successfully processes thousands of blog entries

     

       514
       514
       +
       - **Categorization**: Identifies internal, user, and unknown links

     

       515
       515
       +
       - **Threading**: Creates email-style threaded views of conversations

     

       516
       516
       +
       - **Storage**: Efficient JSON-based data structures for links and references

     

       517
       517
       +
       

     

       518
       518
       +
       ### 🔧 Current Architecture Highlights

     

       519
       519
       +
       - **Modular Design**: Clear separation between CLI, core logic, and models

     

       520
       520
       +
       - **Type Safety**: Comprehensive Pydantic models for data validation

     

       521
       521
       +
       - **Rich CLI**: Beautiful progress bars, tables, and error handling

     

       522
       522
       +
       - **Extensible**: Easy to add new commands and features

     

       523
       523
       +
       - **Git Integration**: All data stored in version-controlled JSON files

     

       524
       524
       +
       

     

       525
       525
       +
       ### 🎯 Proven Functionality

     

       526
       526
       +
       The system has been tested with real blog data and successfully:

     

       527
       527
       +
       - Extracted 14,396 total links from blog entries

     

       528
       528
       +
       - Categorized 3,994 internal links, 363 user-to-user links, and 10,039 unknown links

     

       529
       529
       +
       - Built comprehensive domain mappings for 16 users across 20 domains

     

       530
       530
       +
       - Generated threaded views showing blog conversation patterns

     

       531
       531
       +
       

     

       532
       532
       +
       ### 🚀 Ready for Use

     

       533
       533
       +
       The thicket system is now fully functional for:

     

       534
       534
       +
       - Maintaining Git repositories of blog feeds

     

       535
       535
       +
       - Tracking cross-references between blogs

     

       536
       536
       +
       - Creating threaded views of blog conversations

     

       537
       537
       +
       - Discovering blog interaction patterns

     

       538
       538
       +
       - Building distributed comment systems

+24

CLAUDE.md

···

       1
       1
        
       My goal is to build a CLI tool called thicket in Python that maintains a Git repository within which Atom feeds can be persisted, including their contents.

     

       2
       2
        
       

     

       3
       3
       +
       # Python Environment and Package Management

     

       4
       4
       +
       

     

       5
       5
       +
       This project uses `uv` for Python package management and virtual environment handling.

     

       6
       6
       +
       

     

       7
       7
       +
       ## Running Commands

     

       8
       8
       +
       

     

       9
       9
       +
       ALWAYS use `uv run` to execute Python commands:

     

       10
       10
       +
       

     

       11
       11
       +
       - Run the CLI: `uv run -m thicket`

     

       12
       12
       +
       - Run tests: `uv run pytest`

     

       13
       13
       +
       - Type checking: `uv run mypy src/`

     

       14
       14
       +
       - Linting: `uv run ruff check src/`

     

       15
       15
       +
       - Format code: `uv run ruff format src/`

     

       16
       16
       +
       - Compile check: `uv run python -m py_compile <file>`

     

       17
       17
       +
       

     

       18
       18
       +
       ## Package Management

     

       19
       19
       +
       

     

       20
       20
       +
       - Add dependencies: `uv add <package>`

     

       21
       21
       +
       - Add dev dependencies: `uv add --dev <package>`

     

       22
       22
       +
       - Install dependencies: `uv sync`

     

       23
       23
       +
       - Update dependencies: `uv lock --upgrade`

     

       24
       24
       +
       

     

       25
       25
       +
       # Project Structure

     

       26
       26
       +
       

     

       3
       27
        
       The configuration file specifies:

     

       4
       28
        
       - the location of a git store

     

       5
       29
        
       - a list of usernames and target Atom/RSS feed(s) and optional metadata about the username such as their email, homepage, icon and display name

+260

code_duplication_analysis.md

···

       1
       1
       +
       # Code Duplication Analysis for Thicket

     

       2
       2
       +
       

     

       3
       3
       +
       ## 1. Duplicate JSON Handling Code

     

       4
       4
       +
       

     

       5
       5
       +
       ### Pattern: JSON file reading/writing

     

       6
       6
       +
       **Locations:**

     

       7
       7
       +
       - `src/thicket/cli/commands/generate.py:230` - Reading JSON with `json.load(f)`

     

       8
       8
       +
       - `src/thicket/cli/commands/generate.py:249` - Reading links.json

     

       9
       9
       +
       - `src/thicket/cli/commands/index.py:2305` - Reading JSON

     

       10
       10
       +
       - `src/thicket/cli/commands/index.py:2320` - Writing JSON with `json.dump()`

     

       11
       11
       +
       - `src/thicket/cli/commands/threads.py:2456` - Reading JSON

     

       12
       12
       +
       - `src/thicket/cli/commands/info.py:2683` - Reading JSON

     

       13
       13
       +
       - `src/thicket/core/git_store.py:5546` - Writing JSON with custom serializer

     

       14
       14
       +
       - `src/thicket/core/git_store.py:5556` - Reading JSON

     

       15
       15
       +
       - `src/thicket/core/git_store.py:5566` - Writing JSON

     

       16
       16
       +
       - `src/thicket/core/git_store.py:5656` - Writing JSON with model dump

     

       17
       17
       +
       

     

       18
       18
       +
       **Recommendation:** Create a shared `json_utils.py` module:

     

       19
       19
       +
       ```python

     

       20
       20
       +
       def read_json_file(path: Path) -> dict:

     

       21
       21
       +
           """Read JSON file with error handling."""

     

       22
       22
       +
           with open(path) as f:

     

       23
       23
       +
               return json.load(f)

     

       24
       24
       +
       

     

       25
       25
       +
       def write_json_file(path: Path, data: dict, indent: int = 2) -> None:

     

       26
       26
       +
           """Write JSON file with consistent formatting."""

     

       27
       27
       +
           with open(path, "w") as f:

     

       28
       28
       +
               json.dump(data, f, indent=indent, default=str)

     

       29
       29
       +
       

     

       30
       30
       +
       def write_model_json(path: Path, model: BaseModel, indent: int = 2) -> None:

     

       31
       31
       +
           """Write Pydantic model as JSON."""

     

       32
       32
       +
           with open(path, "w") as f:

     

       33
       33
       +
               json.dump(model.model_dump(mode="json", exclude_none=True), f, indent=indent, default=str)

     

       34
       34
       +
       ```

     

       35
       35
       +
       

     

       36
       36
       +
       ## 2. Repeated Datetime Handling

     

       37
       37
       +
       

     

       38
       38
       +
       ### Pattern: datetime formatting and fallback handling

     

       39
       39
       +
       **Locations:**

     

       40
       40
       +
       - `src/thicket/cli/commands/generate.py:241` - `key=lambda x: x[1].updated or x[1].published or datetime.min`

     

       41
       41
       +
       - `src/thicket/cli/commands/generate.py:353` - Same pattern in thread sorting

     

       42
       42
       +
       - `src/thicket/cli/commands/generate.py:359` - Same pattern for max date

     

       43
       43
       +
       - `src/thicket/cli/commands/generate.py:625` - Same pattern

     

       44
       44
       +
       - `src/thicket/cli/commands/generate.py:655` - `entry.updated or entry.published or datetime.min`

     

       45
       45
       +
       - `src/thicket/cli/commands/generate.py:689` - Same pattern

     

       46
       46
       +
       - `src/thicket/cli/commands/generate.py:702` - Same pattern

     

       47
       47
       +
       - Multiple `.strftime('%Y-%m-%d')` calls throughout

     

       48
       48
       +
       

     

       49
       49
       +
       **Recommendation:** Create a shared `datetime_utils.py` module:

     

       50
       50
       +
       ```python

     

       51
       51
       +
       def get_entry_date(entry: AtomEntry) -> datetime:

     

       52
       52
       +
           """Get the most relevant date for an entry with fallback."""

     

       53
       53
       +
           return entry.updated or entry.published or datetime.min

     

       54
       54
       +
       

     

       55
       55
       +
       def format_date_short(dt: datetime) -> str:

     

       56
       56
       +
           """Format datetime as YYYY-MM-DD."""

     

       57
       57
       +
           return dt.strftime('%Y-%m-%d')

     

       58
       58
       +
       

     

       59
       59
       +
       def format_date_full(dt: datetime) -> str:

     

       60
       60
       +
           """Format datetime as YYYY-MM-DD HH:MM."""

     

       61
       61
       +
           return dt.strftime('%Y-%m-%d %H:%M')

     

       62
       62
       +
       

     

       63
       63
       +
       def format_date_iso(dt: datetime) -> str:

     

       64
       64
       +
           """Format datetime as ISO string."""

     

       65
       65
       +
           return dt.isoformat()

     

       66
       66
       +
       ```

     

       67
       67
       +
       

     

       68
       68
       +
       ## 3. Path Handling Patterns

     

       69
       69
       +
       

     

       70
       70
       +
       ### Pattern: Directory creation and existence checks

     

       71
       71
       +
       **Locations:**

     

       72
       72
       +
       - `src/thicket/cli/commands/generate.py:225` - `if user_dir.exists()`

     

       73
       73
       +
       - `src/thicket/cli/commands/generate.py:247` - `if links_file.exists()`

     

       74
       74
       +
       - `src/thicket/cli/commands/generate.py:582` - `self.output_dir.mkdir(parents=True, exist_ok=True)`

     

       75
       75
       +
       - `src/thicket/cli/commands/generate.py:585-586` - Multiple mkdir calls

     

       76
       76
       +
       - `src/thicket/cli/commands/threads.py:2449` - `if not index_path.exists()`

     

       77
       77
       +
       - `src/thicket/cli/commands/info.py:2681` - `if links_path.exists()`

     

       78
       78
       +
       - `src/thicket/core/git_store.py:5515` - `if not self.repo_path.exists()`

     

       79
       79
       +
       - `src/thicket/core/git_store.py:5586` - `user_dir.mkdir(exist_ok=True)`

     

       80
       80
       +
       - Many more similar patterns

     

       81
       81
       +
       

     

       82
       82
       +
       **Recommendation:** Create a shared `path_utils.py` module:

     

       83
       83
       +
       ```python

     

       84
       84
       +
       def ensure_directory(path: Path) -> Path:

     

       85
       85
       +
           """Ensure directory exists, creating if necessary."""

     

       86
       86
       +
           path.mkdir(parents=True, exist_ok=True)

     

       87
       87
       +
           return path

     

       88
       88
       +
       

     

       89
       89
       +
       def read_json_if_exists(path: Path, default: Any = None) -> Any:

     

       90
       90
       +
           """Read JSON file if it exists, otherwise return default."""

     

       91
       91
       +
           if path.exists():

     

       92
       92
       +
               with open(path) as f:

     

       93
       93
       +
                   return json.load(f)

     

       94
       94
       +
           return default

     

       95
       95
       +
       

     

       96
       96
       +
       def safe_path_join(*parts: Union[str, Path]) -> Path:

     

       97
       97
       +
           """Safely join path components."""

     

       98
       98
       +
           return Path(*parts)

     

       99
       99
       +
       ```

     

       100
       100
       +
       

     

       101
       101
       +
       ## 4. Progress Bar and Console Output

     

       102
       102
       +
       

     

       103
       103
       +
       ### Pattern: Progress bar creation and updates

     

       104
       104
       +
       **Locations:**

     

       105
       105
       +
       - `src/thicket/cli/commands/generate.py:209` - Progress with SpinnerColumn

     

       106
       106
       +
       - `src/thicket/cli/commands/index.py:2230` - Same Progress pattern

     

       107
       107
       +
       - Multiple `console.print()` calls with similar formatting patterns

     

       108
       108
       +
       - Progress update patterns repeated

     

       109
       109
       +
       

     

       110
       110
       +
       **Recommendation:** Create a shared `ui_utils.py` module:

     

       111
       111
       +
       ```python

     

       112
       112
       +
       def create_progress_spinner(description: str) -> tuple[Progress, TaskID]:

     

       113
       113
       +
           """Create a standard progress spinner."""

     

       114
       114
       +
           progress = Progress(

     

       115
       115
       +
               SpinnerColumn(),

     

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

     

       117
       117
       +
               transient=True,

     

       118
       118
       +
           )

     

       119
       119
       +
           task = progress.add_task(description)

     

       120
       120
       +
           return progress, task

     

       121
       121
       +
       

     

       122
       122
       +
       def print_success(message: str) -> None:

     

       123
       123
       +
           """Print success message with consistent formatting."""

     

       124
       124
       +
           console.print(f"[green]✓[/green] {message}")

     

       125
       125
       +
       

     

       126
       126
       +
       def print_error(message: str) -> None:

     

       127
       127
       +
           """Print error message with consistent formatting."""

     

       128
       128
       +
           console.print(f"[red]Error: {message}[/red]")

     

       129
       129
       +
       

     

       130
       130
       +
       def print_warning(message: str) -> None:

     

       131
       131
       +
           """Print warning message with consistent formatting."""

     

       132
       132
       +
           console.print(f"[yellow]Warning: {message}[/yellow]")

     

       133
       133
       +
       ```

     

       134
       134
       +
       

     

       135
       135
       +
       ## 5. Git Store Operations

     

       136
       136
       +
       

     

       137
       137
       +
       ### Pattern: Entry file operations

     

       138
       138
       +
       **Locations:**

     

       139
       139
       +
       - Multiple patterns of loading entries from user directories

     

       140
       140
       +
       - Repeated safe_id generation

     

       141
       141
       +
       - Repeated user directory path construction

     

       142
       142
       +
       

     

       143
       143
       +
       **Recommendation:** Enhance GitStore with helper methods:

     

       144
       144
       +
       ```python

     

       145
       145
       +
       def get_user_dir(self, username: str) -> Path:

     

       146
       146
       +
           """Get user directory path."""

     

       147
       147
       +
           return self.repo_path / username

     

       148
       148
       +
       

     

       149
       149
       +
       def iter_user_entries(self, username: str) -> Iterator[tuple[Path, AtomEntry]]:

     

       150
       150
       +
           """Iterate over all entries for a user."""

     

       151
       151
       +
           user_dir = self.get_user_dir(username)

     

       152
       152
       +
           if user_dir.exists():

     

       153
       153
       +
               for entry_file in user_dir.glob("*.json"):

     

       154
       154
       +
                   if entry_file.name not in ["index.json", "duplicates.json"]:

     

       155
       155
       +
                       try:

     

       156
       156
       +
                           entry = self.read_entry_file(entry_file)

     

       157
       157
       +
                           yield entry_file, entry

     

       158
       158
       +
                       except Exception:

     

       159
       159
       +
                           continue

     

       160
       160
       +
       ```

     

       161
       161
       +
       

     

       162
       162
       +
       ## 6. Error Handling Patterns

     

       163
       163
       +
       

     

       164
       164
       +
       ### Pattern: Try-except with console error printing

     

       165
       165
       +
       **Locations:**

     

       166
       166
       +
       - Similar error handling patterns throughout CLI commands

     

       167
       167
       +
       - Repeated `raise typer.Exit(1)` patterns

     

       168
       168
       +
       - Similar exception message formatting

     

       169
       169
       +
       

     

       170
       170
       +
       **Recommendation:** Create error handling decorators:

     

       171
       171
       +
       ```python

     

       172
       172
       +
       def handle_cli_errors(func):

     

       173
       173
       +
           """Decorator to handle CLI command errors consistently."""

     

       174
       174
       +
           @functools.wraps(func)

     

       175
       175
       +
           def wrapper(*args, **kwargs):

     

       176
       176
       +
               try:

     

       177
       177
       +
                   return func(*args, **kwargs)

     

       178
       178
       +
               except ValidationError as e:

     

       179
       179
       +
                   console.print(f"[red]Validation error: {e}[/red]")

     

       180
       180
       +
                   raise typer.Exit(1)

     

       181
       181
       +
               except Exception as e:

     

       182
       182
       +
                   console.print(f"[red]Error: {e}[/red]")

     

       183
       183
       +
                   if kwargs.get('verbose'):

     

       184
       184
       +
                       console.print_exception()

     

       185
       185
       +
                   raise typer.Exit(1)

     

       186
       186
       +
           return wrapper

     

       187
       187
       +
       ```

     

       188
       188
       +
       

     

       189
       189
       +
       ## 7. Configuration and Validation

     

       190
       190
       +
       

     

       191
       191
       +
       ### Pattern: Config file loading and validation

     

       192
       192
       +
       **Locations:**

     

       193
       193
       +
       - Repeated config loading pattern in every CLI command

     

       194
       194
       +
       - Similar validation patterns for URLs and paths

     

       195
       195
       +
       

     

       196
       196
       +
       **Recommendation:** Create a `config_utils.py` module:

     

       197
       197
       +
       ```python

     

       198
       198
       +
       def load_config_with_defaults(config_path: Optional[Path] = None) -> ThicketConfig:

     

       199
       199
       +
           """Load config with standard defaults and error handling."""

     

       200
       200
       +
           if config_path is None:

     

       201
       201
       +
               config_path = Path("thicket.yaml")

     

       202
       202
       +
           

     

       203
       203
       +
           if not config_path.exists():

     

       204
       204
       +
               raise ConfigError(f"Configuration file not found: {config_path}")

     

       205
       205
       +
           

     

       206
       206
       +
           return load_config(config_path)

     

       207
       207
       +
       

     

       208
       208
       +
       def validate_url(url: str) -> HttpUrl:

     

       209
       209
       +
           """Validate and return URL with consistent error handling."""

     

       210
       210
       +
           try:

     

       211
       211
       +
               return HttpUrl(url)

     

       212
       212
       +
           except ValidationError:

     

       213
       213
       +
               raise ConfigError(f"Invalid URL: {url}")

     

       214
       214
       +
       ```

     

       215
       215
       +
       

     

       216
       216
       +
       ## 8. Model Serialization

     

       217
       217
       +
       

     

       218
       218
       +
       ### Pattern: Pydantic model JSON encoding

     

       219
       219
       +
       **Locations:**

     

       220
       220
       +
       - Repeated `json_encoders={datetime: lambda v: v.isoformat()}` in model configs

     

       221
       221
       +
       - Similar model_dump patterns

     

       222
       222
       +
       

     

       223
       223
       +
       **Recommendation:** Create base model class:

     

       224
       224
       +
       ```python

     

       225
       225
       +
       class ThicketBaseModel(BaseModel):

     

       226
       226
       +
           """Base model with common configuration."""

     

       227
       227
       +
           model_config = ConfigDict(

     

       228
       228
       +
               json_encoders={datetime: lambda v: v.isoformat()},

     

       229
       229
       +
               str_strip_whitespace=True,

     

       230
       230
       +
           )

     

       231
       231
       +
           

     

       232
       232
       +
           def to_json_dict(self) -> dict:

     

       233
       233
       +
               """Convert to JSON-serializable dict."""

     

       234
       234
       +
               return self.model_dump(mode="json", exclude_none=True)

     

       235
       235
       +
       ```

     

       236
       236
       +
       

     

       237
       237
       +
       ## Summary of Refactoring Benefits

     

       238
       238
       +
       

     

       239
       239
       +
       1. **Reduced Code Duplication**: Eliminate 30-40% of duplicate code

     

       240
       240
       +
       2. **Consistent Error Handling**: Standardize error messages and handling

     

       241
       241
       +
       3. **Easier Maintenance**: Central location for common patterns

     

       242
       242
       +
       4. **Better Testing**: Easier to unit test shared utilities

     

       243
       243
       +
       5. **Type Safety**: Shared type hints and validation

     

       244
       244
       +
       6. **Performance**: Potential to optimize common operations in one place

     

       245
       245
       +
       

     

       246
       246
       +
       ## Implementation Priority

     

       247
       247
       +
       

     

       248
       248
       +
       1. **High Priority**: 

     

       249
       249
       +
          - JSON utilities (used everywhere)

     

       250
       250
       +
          - Datetime utilities (critical for sorting and display)

     

       251
       251
       +
          - Error handling decorators (improves UX consistency)

     

       252
       252
       +
       

     

       253
       253
       +
       2. **Medium Priority**:

     

       254
       254
       +
          - Path utilities

     

       255
       255
       +
          - UI/Console utilities

     

       256
       256
       +
          - Config utilities

     

       257
       257
       +
       

     

       258
       258
       +
       3. **Low Priority**:

     

       259
       259
       +
          - Base model classes (requires more refactoring)

     

       260
       260
       +
          - Git store enhancements (already well-structured)

+6 -2

pyproject.toml

···

       39
       39
        
           "bleach>=6.0.0",

     

       40
       40
        
           "platformdirs>=4.0.0",

     

       41
       41
        
           "pyyaml>=6.0.0",

     

       42
       42
       +
           "email_validator",

     

       43
       43
       +
           "jinja2>=3.1.6",

     

       42
       44
        
       ]

     

       43
       45
        
       

     

       44
       46
        
       [project.optional-dependencies]

     
···

       88
       90
        
       [tool.ruff]

     

       89
       91
        
       target-version = "py39"

     

       90
       92
        
       line-length = 88

     

       93
       93
       +
       

     

       94
       94
       +
       [tool.ruff.lint]

     

       91
       95
        
       select = [

     

       92
       96
        
           "E",  # pycodestyle errors

     

       93
       97
        
           "W",  # pycodestyle warnings

     
···

       103
       107
        
           "C901",  # too complex

     

       104
       108
        
       ]

     

       105
       109
        
       

     

       106
       106
       -
       [tool.ruff.per-file-ignores]

     

       110
       110
       +
       [tool.ruff.lint.per-file-ignores]

     

       107
       111
        
       "__init__.py" = ["F401"]

     

       108
       112
        
       

     

       109
       113
        
       [tool.mypy]

     
···

       166
       170
        
           "if __name__ == .__main__.:",

     

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

     

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

     

       169
       169
       -
       ]
     

       173
       173
       +
       ]

+6617

repomix-output.xml

···

       1
       1
       +
       This file is a merged representation of the entire codebase, combined into a single document by Repomix.

     

       2
       2
       +
       

     

       3
       3
       +
       <file_summary>

     

       4
       4
       +
       This section contains a summary of this file.

     

       5
       5
       +
       

     

       6
       6
       +
       <purpose>

     

       7
       7
       +
       This file contains a packed representation of the entire repository's contents.

     

       8
       8
       +
       It is designed to be easily consumable by AI systems for analysis, code review,

     

       9
       9
       +
       or other automated processes.

     

       10
       10
       +
       </purpose>

     

       11
       11
       +
       

     

       12
       12
       +
       <file_format>

     

       13
       13
       +
       The content is organized as follows:

     

       14
       14
       +
       1. This summary section

     

       15
       15
       +
       2. Repository information

     

       16
       16
       +
       3. Directory structure

     

       17
       17
       +
       4. Repository files (if enabled)

     

       18
       18
       +
       5. Multiple file entries, each consisting of:

     

       19
       19
       +
         - File path as an attribute

     

       20
       20
       +
         - Full contents of the file

     

       21
       21
       +
       </file_format>

     

       22
       22
       +
       

     

       23
       23
       +
       <usage_guidelines>

     

       24
       24
       +
       - This file should be treated as read-only. Any changes should be made to the

     

       25
       25
       +
         original repository files, not this packed version.

     

       26
       26
       +
       - When processing this file, use the file path to distinguish

     

       27
       27
       +
         between different files in the repository.

     

       28
       28
       +
       - Be aware that this file may contain sensitive information. Handle it with

     

       29
       29
       +
         the same level of security as you would the original repository.

     

       30
       30
       +
       </usage_guidelines>

     

       31
       31
       +
       

     

       32
       32
       +
       <notes>

     

       33
       33
       +
       - Some files may have been excluded based on .gitignore rules and Repomix's configuration

     

       34
       34
       +
       - Binary files are not included in this packed representation. Please refer to the Repository Structure section for a complete list of file paths, including binary files

     

       35
       35
       +
       - Files matching patterns in .gitignore are excluded

     

       36
       36
       +
       - Files matching default ignore patterns are excluded

     

       37
       37
       +
       - Files are sorted by Git change count (files with more changes are at the bottom)

     

       38
       38
       +
       </notes>

     

       39
       39
       +
       

     

       40
       40
       +
       </file_summary>

     

       41
       41
       +
       

     

       42
       42
       +
       <directory_structure>

     

       43
       43
       +
       .claude/

     

       44
       44
       +
         settings.local.json

     

       45
       45
       +
       src/

     

       46
       46
       +
         thicket/

     

       47
       47
       +
           cli/

     

       48
       48
       +
             commands/

     

       49
       49
       +
               __init__.py

     

       50
       50
       +
               add.py

     

       51
       51
       +
               duplicates.py

     

       52
       52
       +
               generate.py

     

       53
       53
       +
               index_cmd.py

     

       54
       54
       +
               info_cmd.py

     

       55
       55
       +
               init.py

     

       56
       56
       +
               links_cmd.py

     

       57
       57
       +
               list_cmd.py

     

       58
       58
       +
               sync.py

     

       59
       59
       +
             __init__.py

     

       60
       60
       +
             main.py

     

       61
       61
       +
             utils.py

     

       62
       62
       +
           core/

     

       63
       63
       +
             __init__.py

     

       64
       64
       +
             feed_parser.py

     

       65
       65
       +
             git_store.py

     

       66
       66
       +
             reference_parser.py

     

       67
       67
       +
           models/

     

       68
       68
       +
             __init__.py

     

       69
       69
       +
             config.py

     

       70
       70
       +
             feed.py

     

       71
       71
       +
             user.py

     

       72
       72
       +
           templates/

     

       73
       73
       +
             base.html

     

       74
       74
       +
             index.html

     

       75
       75
       +
             links.html

     

       76
       76
       +
             script.js

     

       77
       77
       +
             style.css

     

       78
       78
       +
             timeline.html

     

       79
       79
       +
             users.html

     

       80
       80
       +
           utils/

     

       81
       81
       +
             __init__.py

     

       82
       82
       +
           __init__.py

     

       83
       83
       +
           __main__.py

     

       84
       84
       +
       .gitignore

     

       85
       85
       +
       ARCH.md

     

       86
       86
       +
       CLAUDE.md

     

       87
       87
       +
       pyproject.toml

     

       88
       88
       +
       README.md

     

       89
       89
       +
       </directory_structure>

     

       90
       90
       +
       

     

       91
       91
       +
       <files>

     

       92
       92
       +
       This section contains the contents of the repository's files.

     

       93
       93
       +
       

     

       94
       94
       +
       <file path=".claude/settings.local.json">

     

       95
       95
       +
       {

     

       96
       96
       +
         "permissions": {

     

       97
       97
       +
           "allow": [

     

       98
       98
       +
             "Bash(find:*)",

     

       99
       99
       +
             "Bash(uv run:*)",

     

       100
       100
       +
             "Bash(grep:*)",

     

       101
       101
       +
             "Bash(jq:*)",

     

       102
       102
       +
             "Bash(git add:*)",

     

       103
       103
       +
             "Bash(ls:*)"

     

       104
       104
       +
           ]

     

       105
       105
       +
         },

     

       106
       106
       +
         "enableAllProjectMcpServers": false

     

       107
       107
       +
       }

     

       108
       108
       +
       </file>

     

       109
       109
       +
       

     

       110
       110
       +
       <file path="src/thicket/cli/commands/generate.py">

     

       111
       111
       +
       """Generate static HTML website from thicket data."""

     

       112
       112
       +
       

     

       113
       113
       +
       import base64

     

       114
       114
       +
       import json

     

       115
       115
       +
       import re

     

       116
       116
       +
       import shutil

     

       117
       117
       +
       from datetime import datetime

     

       118
       118
       +
       from pathlib import Path

     

       119
       119
       +
       from typing import Any, Optional, TypedDict, Union

     

       120
       120
       +
       

     

       121
       121
       +
       import typer

     

       122
       122
       +
       from jinja2 import Environment, FileSystemLoader, select_autoescape

     

       123
       123
       +
       from rich.progress import Progress, SpinnerColumn, TextColumn

     

       124
       124
       +
       

     

       125
       125
       +
       from ...core.git_store import GitStore

     

       126
       126
       +
       from ...models.feed import AtomEntry

     

       127
       127
       +
       from ...models.user import GitStoreIndex, UserMetadata

     

       128
       128
       +
       from ..main import app

     

       129
       129
       +
       from ..utils import console, load_config

     

       130
       130
       +
       

     

       131
       131
       +
       

     

       132
       132
       +
       class UserData(TypedDict):

     

       133
       133
       +
           """Type definition for user data structure."""

     

       134
       134
       +
       

     

       135
       135
       +
           metadata: UserMetadata

     

       136
       136
       +
           recent_entries: list[tuple[str, AtomEntry]]

     

       137
       137
       +
       

     

       138
       138
       +
       

     

       139
       139
       +
       def safe_anchor_id(atom_id: str) -> str:

     

       140
       140
       +
           """Convert an Atom ID to a safe HTML anchor ID."""

     

       141
       141
       +
           # Use base64 URL-safe encoding without padding

     

       142
       142
       +
           encoded = base64.urlsafe_b64encode(atom_id.encode('utf-8')).decode('ascii').rstrip('=')

     

       143
       143
       +
           # Prefix with 'id' to ensure it starts with a letter (HTML requirement)

     

       144
       144
       +
           return f"id{encoded}"

     

       145
       145
       +
       

     

       146
       146
       +
       

     

       147
       147
       +
       class WebsiteGenerator:

     

       148
       148
       +
           """Generate static HTML website from thicket data."""

     

       149
       149
       +
       

     

       150
       150
       +
           def __init__(self, git_store: GitStore, output_dir: Path):

     

       151
       151
       +
               self.git_store = git_store

     

       152
       152
       +
               self.output_dir = output_dir

     

       153
       153
       +
               self.template_dir = Path(__file__).parent.parent.parent / "templates"

     

       154
       154
       +
       

     

       155
       155
       +
               # Initialize Jinja2 environment

     

       156
       156
       +
               self.env = Environment(

     

       157
       157
       +
                   loader=FileSystemLoader(self.template_dir),

     

       158
       158
       +
                   autoescape=select_autoescape(["html", "xml"]),

     

       159
       159
       +
               )

     

       160
       160
       +
       

     

       161
       161
       +
               # Data containers

     

       162
       162
       +
               self.index: Optional[GitStoreIndex] = None

     

       163
       163
       +
               self.entries: list[tuple[str, AtomEntry]] = []  # (username, entry)

     

       164
       164
       +
               self.links_data: Optional[dict[str, Any]] = None

     

       165
       165
       +
               self.threads: list[list[dict[str, Any]]] = []  # List of threads with metadata

     

       166
       166
       +
       

     

       167
       167
       +
           def get_display_name(self, username: str) -> str:

     

       168
       168
       +
               """Get display name for a user, falling back to username."""

     

       169
       169
       +
               if self.index and username in self.index.users:

     

       170
       170
       +
                   user = self.index.users[username]

     

       171
       171
       +
                   return user.display_name or username

     

       172
       172
       +
               return username

     

       173
       173
       +
       

     

       174
       174
       +
           def get_user_homepage(self, username: str) -> Optional[str]:

     

       175
       175
       +
               """Get homepage URL for a user."""

     

       176
       176
       +
               if self.index and username in self.index.users:

     

       177
       177
       +
                   user = self.index.users[username]

     

       178
       178
       +
                   return str(user.homepage) if user.homepage else None

     

       179
       179
       +
               return None

     

       180
       180
       +
       

     

       181
       181
       +
           def clean_html_summary(self, content: Optional[str], max_length: int = 200) -> str:

     

       182
       182
       +
               """Clean HTML content and truncate for display in timeline."""

     

       183
       183
       +
               if not content:

     

       184
       184
       +
                   return ""

     

       185
       185
       +
       

     

       186
       186
       +
               # Remove HTML tags

     

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

     

       188
       188
       +
               # Replace multiple whitespace with single space

     

       189
       189
       +
               clean_text = re.sub(r"\s+", " ", clean_text)

     

       190
       190
       +
               # Strip leading/trailing whitespace

     

       191
       191
       +
               clean_text = clean_text.strip()

     

       192
       192
       +
       

     

       193
       193
       +
               # Truncate with ellipsis if needed

     

       194
       194
       +
               if len(clean_text) > max_length:

     

       195
       195
       +
                   # Try to break at word boundary

     

       196
       196
       +
                   truncated = clean_text[:max_length]

     

       197
       197
       +
                   last_space = truncated.rfind(" ")

     

       198
       198
       +
                   if (

     

       199
       199
       +
                       last_space > max_length * 0.8

     

       200
       200
       +
                   ):  # If we can break reasonably close to the limit

     

       201
       201
       +
                       clean_text = truncated[:last_space] + "..."

     

       202
       202
       +
                   else:

     

       203
       203
       +
                       clean_text = truncated + "..."

     

       204
       204
       +
       

     

       205
       205
       +
               return clean_text

     

       206
       206
       +
       

     

       207
       207
       +
           def load_data(self) -> None:

     

       208
       208
       +
               """Load all data from the git repository."""

     

       209
       209
       +
               with Progress(

     

       210
       210
       +
                   SpinnerColumn(),

     

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

     

       212
       212
       +
                   console=console,

     

       213
       213
       +
               ) as progress:

     

       214
       214
       +
                   # Load index

     

       215
       215
       +
                   task = progress.add_task("Loading repository index...", total=None)

     

       216
       216
       +
                   self.index = self.git_store._load_index()

     

       217
       217
       +
                   if not self.index:

     

       218
       218
       +
                       raise ValueError("No index found in repository")

     

       219
       219
       +
                   progress.update(task, completed=True)

     

       220
       220
       +
       

     

       221
       221
       +
                   # Load all entries

     

       222
       222
       +
                   task = progress.add_task("Loading entries...", total=None)

     

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

     

       224
       224
       +
                       user_dir = self.git_store.repo_path / user_metadata.directory

     

       225
       225
       +
                       if user_dir.exists():

     

       226
       226
       +
                           for entry_file in user_dir.glob("*.json"):

     

       227
       227
       +
                               if entry_file.name not in ["index.json", "duplicates.json"]:

     

       228
       228
       +
                                   try:

     

       229
       229
       +
                                       with open(entry_file) as f:

     

       230
       230
       +
                                           entry_data = json.load(f)

     

       231
       231
       +
                                           entry = AtomEntry(**entry_data)

     

       232
       232
       +
                                           self.entries.append((username, entry))

     

       233
       233
       +
                                   except Exception as e:

     

       234
       234
       +
                                       console.print(

     

       235
       235
       +
                                           f"[yellow]Warning: Failed to load {entry_file}: {e}[/yellow]"

     

       236
       236
       +
                                       )

     

       237
       237
       +
                   progress.update(task, completed=True)

     

       238
       238
       +
       

     

       239
       239
       +
                   # Sort entries by date (newest first) - prioritize updated over published

     

       240
       240
       +
                   self.entries.sort(

     

       241
       241
       +
                       key=lambda x: x[1].updated or x[1].published or datetime.min, reverse=True

     

       242
       242
       +
                   )

     

       243
       243
       +
       

     

       244
       244
       +
                   # Load links data

     

       245
       245
       +
                   task = progress.add_task("Loading links and references...", total=None)

     

       246
       246
       +
                   links_file = self.git_store.repo_path / "links.json"

     

       247
       247
       +
                   if links_file.exists():

     

       248
       248
       +
                       with open(links_file) as f:

     

       249
       249
       +
                           self.links_data = json.load(f)

     

       250
       250
       +
                   progress.update(task, completed=True)

     

       251
       251
       +
       

     

       252
       252
       +
           def build_threads(self) -> None:

     

       253
       253
       +
               """Build threaded conversations from references."""

     

       254
       254
       +
               if not self.links_data or "references" not in self.links_data:

     

       255
       255
       +
                   return

     

       256
       256
       +
       

     

       257
       257
       +
               # Map entry IDs to (username, entry) tuples

     

       258
       258
       +
               entry_map: dict[str, tuple[str, AtomEntry]] = {}

     

       259
       259
       +
               for username, entry in self.entries:

     

       260
       260
       +
                   entry_map[entry.id] = (username, entry)

     

       261
       261
       +
       

     

       262
       262
       +
               # Build adjacency lists for references

     

       263
       263
       +
               self.outbound_refs: dict[str, set[str]] = {}

     

       264
       264
       +
               self.inbound_refs: dict[str, set[str]] = {}

     

       265
       265
       +
               self.reference_details: dict[

     

       266
       266
       +
                   str, list[dict[str, Any]]

     

       267
       267
       +
               ] = {}  # Store full reference info

     

       268
       268
       +
       

     

       269
       269
       +
               for ref in self.links_data["references"]:

     

       270
       270
       +
                   source_id = ref["source_entry_id"]

     

       271
       271
       +
                   target_id = ref.get("target_entry_id")

     

       272
       272
       +
       

     

       273
       273
       +
                   if target_id and source_id in entry_map and target_id in entry_map:

     

       274
       274
       +
                       self.outbound_refs.setdefault(source_id, set()).add(target_id)

     

       275
       275
       +
                       self.inbound_refs.setdefault(target_id, set()).add(source_id)

     

       276
       276
       +
       

     

       277
       277
       +
                       # Store reference details for UI

     

       278
       278
       +
                       self.reference_details.setdefault(source_id, []).append(

     

       279
       279
       +
                           {

     

       280
       280
       +
                               "target_id": target_id,

     

       281
       281
       +
                               "target_username": ref.get("target_username"),

     

       282
       282
       +
                               "type": "outbound",

     

       283
       283
       +
                           }

     

       284
       284
       +
                       )

     

       285
       285
       +
                       self.reference_details.setdefault(target_id, []).append(

     

       286
       286
       +
                           {

     

       287
       287
       +
                               "source_id": source_id,

     

       288
       288
       +
                               "source_username": ref.get("source_username"),

     

       289
       289
       +
                               "type": "inbound",

     

       290
       290
       +
                           }

     

       291
       291
       +
                       )

     

       292
       292
       +
       

     

       293
       293
       +
               # Find conversation threads (multi-post discussions)

     

       294
       294
       +
               processed = set()

     

       295
       295
       +
       

     

       296
       296
       +
               for entry_id, (_username, _entry) in entry_map.items():

     

       297
       297
       +
                   if entry_id in processed:

     

       298
       298
       +
                       continue

     

       299
       299
       +
       

     

       300
       300
       +
                   # Build thread starting from this entry

     

       301
       301
       +
                   thread = []

     

       302
       302
       +
                   to_visit = [entry_id]

     

       303
       303
       +
                   thread_ids = set()

     

       304
       304
       +
                   level_map: dict[str, int] = {}  # Track levels for this thread

     

       305
       305
       +
       

     

       306
       306
       +
                   # First, traverse up to find the root

     

       307
       307
       +
                   current = entry_id

     

       308
       308
       +
                   while current in self.inbound_refs:

     

       309
       309
       +
                       parents = self.inbound_refs[current] - {

     

       310
       310
       +
                           current

     

       311
       311
       +
                       }  # Exclude self-references

     

       312
       312
       +
                       if not parents:

     

       313
       313
       +
                           break

     

       314
       314
       +
                       # Take the first parent

     

       315
       315
       +
                       parent = next(iter(parents))

     

       316
       316
       +
                       if parent in thread_ids:  # Avoid cycles

     

       317
       317
       +
                           break

     

       318
       318
       +
                       current = parent

     

       319
       319
       +
                       to_visit.insert(0, current)

     

       320
       320
       +
       

     

       321
       321
       +
                   # Now traverse down from the root

     

       322
       322
       +
                   while to_visit:

     

       323
       323
       +
                       current = to_visit.pop(0)

     

       324
       324
       +
                       if current in thread_ids or current not in entry_map:

     

       325
       325
       +
                           continue

     

       326
       326
       +
       

     

       327
       327
       +
                       thread_ids.add(current)

     

       328
       328
       +
                       username, entry = entry_map[current]

     

       329
       329
       +
       

     

       330
       330
       +
                       # Calculate thread level

     

       331
       331
       +
                       thread_level = self._calculate_thread_level(current, level_map)

     

       332
       332
       +
       

     

       333
       333
       +
                       # Add threading metadata

     

       334
       334
       +
                       thread_entry = {

     

       335
       335
       +
                           "username": username,

     

       336
       336
       +
                           "display_name": self.get_display_name(username),

     

       337
       337
       +
                           "entry": entry,

     

       338
       338
       +
                           "entry_id": current,

     

       339
       339
       +
                           "references_to": list(self.outbound_refs.get(current, [])),

     

       340
       340
       +
                           "referenced_by": list(self.inbound_refs.get(current, [])),

     

       341
       341
       +
                           "thread_level": thread_level,

     

       342
       342
       +
                       }

     

       343
       343
       +
                       thread.append(thread_entry)

     

       344
       344
       +
                       processed.add(current)

     

       345
       345
       +
       

     

       346
       346
       +
                       # Add children

     

       347
       347
       +
                       if current in self.outbound_refs:

     

       348
       348
       +
                           children = self.outbound_refs[current] - thread_ids  # Avoid cycles

     

       349
       349
       +
                           to_visit.extend(sorted(children))

     

       350
       350
       +
       

     

       351
       351
       +
                   if len(thread) > 1:  # Only keep actual threads

     

       352
       352
       +
                       # Sort thread by date (newest first) - prioritize updated over published

     

       353
       353
       +
                       thread.sort(key=lambda x: x["entry"].updated or x["entry"].published or datetime.min, reverse=True)  # type: ignore

     

       354
       354
       +
                       self.threads.append(thread)

     

       355
       355
       +
       

     

       356
       356
       +
               # Sort threads by the date of their most recent entry - prioritize updated over published

     

       357
       357
       +
               self.threads.sort(

     

       358
       358
       +
                   key=lambda t: max(

     

       359
       359
       +
                       item["entry"].updated or item["entry"].published or datetime.min for item in t

     

       360
       360
       +
                   ),

     

       361
       361
       +
                   reverse=True,

     

       362
       362
       +
               )

     

       363
       363
       +
       

     

       364
       364
       +
           def _calculate_thread_level(

     

       365
       365
       +
               self, entry_id: str, processed_entries: dict[str, int]

     

       366
       366
       +
           ) -> int:

     

       367
       367
       +
               """Calculate indentation level for threaded display."""

     

       368
       368
       +
               if entry_id in processed_entries:

     

       369
       369
       +
                   return processed_entries[entry_id]

     

       370
       370
       +
       

     

       371
       371
       +
               if entry_id not in self.inbound_refs:

     

       372
       372
       +
                   processed_entries[entry_id] = 0

     

       373
       373
       +
                   return 0

     

       374
       374
       +
       

     

       375
       375
       +
               parents_in_thread = self.inbound_refs[entry_id] & set(processed_entries.keys())

     

       376
       376
       +
               if not parents_in_thread:

     

       377
       377
       +
                   processed_entries[entry_id] = 0

     

       378
       378
       +
                   return 0

     

       379
       379
       +
       

     

       380
       380
       +
               # Find the deepest parent level + 1

     

       381
       381
       +
               max_parent_level = 0

     

       382
       382
       +
               for parent_id in parents_in_thread:

     

       383
       383
       +
                   parent_level = self._calculate_thread_level(parent_id, processed_entries)

     

       384
       384
       +
                   max_parent_level = max(max_parent_level, parent_level)

     

       385
       385
       +
       

     

       386
       386
       +
               level = min(max_parent_level + 1, 4)  # Cap at level 4

     

       387
       387
       +
               processed_entries[entry_id] = level

     

       388
       388
       +
               return level

     

       389
       389
       +
       

     

       390
       390
       +
           def get_standalone_references(self) -> list[dict[str, Any]]:

     

       391
       391
       +
               """Get posts that have references but aren't part of multi-post threads."""

     

       392
       392
       +
               if not hasattr(self, "reference_details"):

     

       393
       393
       +
                   return []

     

       394
       394
       +
       

     

       395
       395
       +
               threaded_entry_ids = set()

     

       396
       396
       +
               for thread in self.threads:

     

       397
       397
       +
                   for item in thread:

     

       398
       398
       +
                       threaded_entry_ids.add(item["entry_id"])

     

       399
       399
       +
       

     

       400
       400
       +
               standalone_refs = []

     

       401
       401
       +
               for username, entry in self.entries:

     

       402
       402
       +
                   if (

     

       403
       403
       +
                       entry.id in self.reference_details

     

       404
       404
       +
                       and entry.id not in threaded_entry_ids

     

       405
       405
       +
                   ):

     

       406
       406
       +
                       refs = self.reference_details[entry.id]

     

       407
       407
       +
                       # Only include if it has meaningful references (not just self-references)

     

       408
       408
       +
                       meaningful_refs = [

     

       409
       409
       +
                           r

     

       410
       410
       +
                           for r in refs

     

       411
       411
       +
                           if r.get("target_id") != entry.id and r.get("source_id") != entry.id

     

       412
       412
       +
                       ]

     

       413
       413
       +
                       if meaningful_refs:

     

       414
       414
       +
                           standalone_refs.append(

     

       415
       415
       +
                               {

     

       416
       416
       +
                                   "username": username,

     

       417
       417
       +
                                   "display_name": self.get_display_name(username),

     

       418
       418
       +
                                   "entry": entry,

     

       419
       419
       +
                                   "references": meaningful_refs,

     

       420
       420
       +
                               }

     

       421
       421
       +
                           )

     

       422
       422
       +
       

     

       423
       423
       +
               return standalone_refs

     

       424
       424
       +
       

     

       425
       425
       +
           def _add_cross_thread_links(self, timeline_items: list[dict[str, Any]]) -> None:

     

       426
       426
       +
               """Add cross-thread linking for entries that appear in multiple threads."""

     

       427
       427
       +
               # Map entry IDs to their positions in the timeline

     

       428
       428
       +
               entry_positions: dict[str, list[int]] = {}

     

       429
       429
       +
               # Map URLs referenced by entries to the entries that reference them

     

       430
       430
       +
               url_references: dict[str, list[tuple[str, int]]] = {}  # url -> [(entry_id, position)]

     

       431
       431
       +
       

     

       432
       432
       +
               # First pass: collect all entry IDs, their positions, and referenced URLs

     

       433
       433
       +
               for i, item in enumerate(timeline_items):

     

       434
       434
       +
                   if item["type"] == "post":

     

       435
       435
       +
                       entry_id = item["content"]["entry"].id

     

       436
       436
       +
                       entry_positions.setdefault(entry_id, []).append(i)

     

       437
       437
       +
                       # Track URLs this entry references

     

       438
       438
       +
                       if entry_id in self.reference_details:

     

       439
       439
       +
                           for ref in self.reference_details[entry_id]:

     

       440
       440
       +
                               if ref["type"] == "outbound" and "target_id" in ref:

     

       441
       441
       +
                                   # Find the target entry's URL if available

     

       442
       442
       +
                                   target_entry = self._find_entry_by_id(ref["target_id"])

     

       443
       443
       +
                                   if target_entry and target_entry.link:

     

       444
       444
       +
                                       url = str(target_entry.link)

     

       445
       445
       +
                                       url_references.setdefault(url, []).append((entry_id, i))

     

       446
       446
       +
                   elif item["type"] == "thread":

     

       447
       447
       +
                       for thread_item in item["content"]:

     

       448
       448
       +
                           entry_id = thread_item["entry"].id

     

       449
       449
       +
                           entry_positions.setdefault(entry_id, []).append(i)

     

       450
       450
       +
                           # Track URLs this entry references

     

       451
       451
       +
                           if entry_id in self.reference_details:

     

       452
       452
       +
                               for ref in self.reference_details[entry_id]:

     

       453
       453
       +
                                   if ref["type"] == "outbound" and "target_id" in ref:

     

       454
       454
       +
                                       target_entry = self._find_entry_by_id(ref["target_id"])

     

       455
       455
       +
                                       if target_entry and target_entry.link:

     

       456
       456
       +
                                           url = str(target_entry.link)

     

       457
       457
       +
                                           url_references.setdefault(url, []).append((entry_id, i))

     

       458
       458
       +
       

     

       459
       459
       +
               # Build cross-thread connections - only for entries that actually appear multiple times

     

       460
       460
       +
               cross_thread_connections: dict[str, set[int]] = {}  # entry_id -> set of timeline positions

     

       461
       461
       +
       

     

       462
       462
       +
               # Add connections ONLY for entries that appear multiple times in the timeline

     

       463
       463
       +
               for entry_id, positions in entry_positions.items():

     

       464
       464
       +
                   if len(positions) > 1:

     

       465
       465
       +
                       cross_thread_connections[entry_id] = set(positions)

     

       466
       466
       +
                       # Debug: uncomment to see which entries have multiple appearances

     

       467
       467
       +
                       # print(f"Entry {entry_id[:50]}... appears at positions: {positions}")

     

       468
       468
       +
       

     

       469
       469
       +
               # Apply cross-thread links to timeline items

     

       470
       470
       +
               for entry_id, positions_set in cross_thread_connections.items():

     

       471
       471
       +
                   positions_list = list(positions_set)

     

       472
       472
       +
                   for pos in positions_list:

     

       473
       473
       +
                       item = timeline_items[pos]

     

       474
       474
       +
                       other_positions = sorted([p for p in positions_list if p != pos])

     

       475
       475
       +
       

     

       476
       476
       +
                       if item["type"] == "post":

     

       477
       477
       +
                           # Add cross-thread info to individual posts

     

       478
       478
       +
                           item["content"]["cross_thread_links"] = self._build_cross_thread_link_data(entry_id, other_positions, timeline_items)

     

       479
       479
       +
                           # Add info about shared references

     

       480
       480
       +
                           item["content"]["shared_references"] = self._get_shared_references(entry_id, positions_set, timeline_items)

     

       481
       481
       +
                       elif item["type"] == "thread":

     

       482
       482
       +
                           # Add cross-thread info to thread items

     

       483
       483
       +
                           for thread_item in item["content"]:

     

       484
       484
       +
                               if thread_item["entry"].id == entry_id:

     

       485
       485
       +
                                   thread_item["cross_thread_links"] = self._build_cross_thread_link_data(entry_id, other_positions, timeline_items)

     

       486
       486
       +
                                   thread_item["shared_references"] = self._get_shared_references(entry_id, positions_set, timeline_items)

     

       487
       487
       +
                                   break

     

       488
       488
       +
       

     

       489
       489
       +
           def _build_cross_thread_link_data(self, entry_id: str, other_positions: list[int], timeline_items: list[dict[str, Any]]) -> list[dict[str, Any]]:

     

       490
       490
       +
               """Build detailed cross-thread link data with anchor information."""

     

       491
       491
       +
               cross_thread_links = []

     

       492
       492
       +
       

     

       493
       493
       +
               for pos in other_positions:

     

       494
       494
       +
                   item = timeline_items[pos]

     

       495
       495
       +
                   if item["type"] == "post":

     

       496
       496
       +
                       # For individual posts

     

       497
       497
       +
                       safe_id = safe_anchor_id(entry_id)

     

       498
       498
       +
                       cross_thread_links.append({

     

       499
       499
       +
                           "position": pos,

     

       500
       500
       +
                           "anchor_id": f"post-{pos}-{safe_id}",

     

       501
       501
       +
                           "context": "individual post",

     

       502
       502
       +
                           "title": item["content"]["entry"].title

     

       503
       503
       +
                       })

     

       504
       504
       +
                   elif item["type"] == "thread":

     

       505
       505
       +
                       # For thread items, find the specific thread item

     

       506
       506
       +
                       for thread_idx, thread_item in enumerate(item["content"]):

     

       507
       507
       +
                           if thread_item["entry"].id == entry_id:

     

       508
       508
       +
                               safe_id = safe_anchor_id(entry_id)

     

       509
       509
       +
                               cross_thread_links.append({

     

       510
       510
       +
                                   "position": pos,

     

       511
       511
       +
                                   "anchor_id": f"post-{pos}-{thread_idx}-{safe_id}",

     

       512
       512
       +
                                   "context": f"thread (level {thread_item.get('thread_level', 0)})",

     

       513
       513
       +
                                   "title": thread_item["entry"].title

     

       514
       514
       +
                               })

     

       515
       515
       +
                               break

     

       516
       516
       +
       

     

       517
       517
       +
               return cross_thread_links

     

       518
       518
       +
       

     

       519
       519
       +
           def _find_entry_by_id(self, entry_id: str) -> Optional[AtomEntry]:

     

       520
       520
       +
               """Find an entry by its ID."""

     

       521
       521
       +
               for _username, entry in self.entries:

     

       522
       522
       +
                   if entry.id == entry_id:

     

       523
       523
       +
                       return entry

     

       524
       524
       +
               return None

     

       525
       525
       +
       

     

       526
       526
       +
           def _get_shared_references(self, entry_id: str, positions: Union[set[int], list[int]], timeline_items: list[dict[str, Any]]) -> list[dict[str, Any]]:

     

       527
       527
       +
               """Get information about shared references between cross-thread entries."""

     

       528
       528
       +
               shared_refs = []

     

       529
       529
       +
       

     

       530
       530
       +
               # Collect all referenced URLs from entries at these positions

     

       531
       531
       +
               url_counts: dict[str, int] = {}

     

       532
       532
       +
               referencing_entries: dict[str, list[str]] = {}  # url -> [entry_ids]

     

       533
       533
       +
       

     

       534
       534
       +
               for pos in positions:

     

       535
       535
       +
                   item = timeline_items[pos]

     

       536
       536
       +
                   entries_to_check = []

     

       537
       537
       +
       

     

       538
       538
       +
                   if item["type"] == "post":

     

       539
       539
       +
                       entries_to_check.append(item["content"]["entry"])

     

       540
       540
       +
                   elif item["type"] == "thread":

     

       541
       541
       +
                       entries_to_check.extend([ti["entry"] for ti in item["content"]])

     

       542
       542
       +
       

     

       543
       543
       +
                   for entry in entries_to_check:

     

       544
       544
       +
                       if entry.id in self.reference_details:

     

       545
       545
       +
                           for ref in self.reference_details[entry.id]:

     

       546
       546
       +
                               if ref["type"] == "outbound" and "target_id" in ref:

     

       547
       547
       +
                                   target_entry = self._find_entry_by_id(ref["target_id"])

     

       548
       548
       +
                                   if target_entry and target_entry.link:

     

       549
       549
       +
                                       url = str(target_entry.link)

     

       550
       550
       +
                                       url_counts[url] = url_counts.get(url, 0) + 1

     

       551
       551
       +
                                       if url not in referencing_entries:

     

       552
       552
       +
                                           referencing_entries[url] = []

     

       553
       553
       +
                                       if entry.id not in referencing_entries[url]:

     

       554
       554
       +
                                           referencing_entries[url].append(entry.id)

     

       555
       555
       +
       

     

       556
       556
       +
               # Find URLs referenced by multiple entries

     

       557
       557
       +
               for url, count in url_counts.items():

     

       558
       558
       +
                   if count > 1 and len(referencing_entries[url]) > 1:

     

       559
       559
       +
                       # Get the target entry info

     

       560
       560
       +
                       target_entry = None

     

       561
       561
       +
                       target_username = None

     

       562
       562
       +
                       for ref in (self.links_data or {}).get("references", []):

     

       563
       563
       +
                           if ref.get("target_url") == url:

     

       564
       564
       +
                               target_username = ref.get("target_username")

     

       565
       565
       +
                               if ref.get("target_entry_id"):

     

       566
       566
       +
                                   target_entry = self._find_entry_by_id(ref["target_entry_id"])

     

       567
       567
       +
                               break

     

       568
       568
       +
       

     

       569
       569
       +
                       shared_refs.append({

     

       570
       570
       +
                           "url": url,

     

       571
       571
       +
                           "count": count,

     

       572
       572
       +
                           "referencing_entries": referencing_entries[url],

     

       573
       573
       +
                           "target_username": target_username,

     

       574
       574
       +
                           "target_title": target_entry.title if target_entry else None

     

       575
       575
       +
                       })

     

       576
       576
       +
       

     

       577
       577
       +
               return sorted(shared_refs, key=lambda x: x["count"], reverse=True)

     

       578
       578
       +
       

     

       579
       579
       +
           def generate_site(self) -> None:

     

       580
       580
       +
               """Generate the static website."""

     

       581
       581
       +
               # Create output directory

     

       582
       582
       +
               self.output_dir.mkdir(parents=True, exist_ok=True)

     

       583
       583
       +
       

     

       584
       584
       +
               # Create static directories

     

       585
       585
       +
               (self.output_dir / "css").mkdir(exist_ok=True)

     

       586
       586
       +
               (self.output_dir / "js").mkdir(exist_ok=True)

     

       587
       587
       +
       

     

       588
       588
       +
               # Generate CSS

     

       589
       589
       +
               css_template = self.env.get_template("style.css")

     

       590
       590
       +
               css_content = css_template.render()

     

       591
       591
       +
               with open(self.output_dir / "css" / "style.css", "w") as f:

     

       592
       592
       +
                   f.write(css_content)

     

       593
       593
       +
       

     

       594
       594
       +
               # Generate JavaScript

     

       595
       595
       +
               js_template = self.env.get_template("script.js")

     

       596
       596
       +
               js_content = js_template.render()

     

       597
       597
       +
               with open(self.output_dir / "js" / "script.js", "w") as f:

     

       598
       598
       +
                   f.write(js_content)

     

       599
       599
       +
       

     

       600
       600
       +
               # Prepare common template data

     

       601
       601
       +
               base_data = {

     

       602
       602
       +
                   "title": "Energy & Environment Group",

     

       603
       603
       +
                   "generated_at": datetime.now().isoformat(),

     

       604
       604
       +
                   "get_display_name": self.get_display_name,

     

       605
       605
       +
                   "get_user_homepage": self.get_user_homepage,

     

       606
       606
       +
                   "clean_html_summary": self.clean_html_summary,

     

       607
       607
       +
                   "safe_anchor_id": safe_anchor_id,

     

       608
       608
       +
               }

     

       609
       609
       +
       

     

       610
       610
       +
               # Build unified timeline

     

       611
       611
       +
               timeline_items = []

     

       612
       612
       +
       

     

       613
       613
       +
               # Only consider the threads that will actually be displayed

     

       614
       614
       +
               displayed_threads = self.threads[:20]  # Limit to 20 threads

     

       615
       615
       +
       

     

       616
       616
       +
               # Track which entries are part of displayed threads

     

       617
       617
       +
               threaded_entry_ids = set()

     

       618
       618
       +
               for thread in displayed_threads:

     

       619
       619
       +
                   for item in thread:

     

       620
       620
       +
                       threaded_entry_ids.add(item["entry_id"])

     

       621
       621
       +
       

     

       622
       622
       +
               # Add threads to timeline (using the date of the most recent post)

     

       623
       623
       +
               for thread in displayed_threads:

     

       624
       624
       +
                   most_recent_date = max(

     

       625
       625
       +
                       item["entry"].updated or item["entry"].published or datetime.min

     

       626
       626
       +
                       for item in thread

     

       627
       627
       +
                   )

     

       628
       628
       +
                   timeline_items.append({

     

       629
       629
       +
                       "type": "thread",

     

       630
       630
       +
                       "date": most_recent_date,

     

       631
       631
       +
                       "content": thread

     

       632
       632
       +
                   })

     

       633
       633
       +
       

     

       634
       634
       +
               # Add individual posts (not in threads)

     

       635
       635
       +
               for username, entry in self.entries[:50]:

     

       636
       636
       +
                   if entry.id not in threaded_entry_ids:

     

       637
       637
       +
                       # Check if this entry has references

     

       638
       638
       +
                       has_refs = (

     

       639
       639
       +
                           entry.id in self.reference_details

     

       640
       640
       +
                           if hasattr(self, "reference_details")

     

       641
       641
       +
                           else False

     

       642
       642
       +
                       )

     

       643
       643
       +
       

     

       644
       644
       +
                       refs = []

     

       645
       645
       +
                       if has_refs:

     

       646
       646
       +
                           refs = self.reference_details.get(entry.id, [])

     

       647
       647
       +
                           refs = [

     

       648
       648
       +
                               r for r in refs

     

       649
       649
       +
                               if r.get("target_id") != entry.id

     

       650
       650
       +
                               and r.get("source_id") != entry.id

     

       651
       651
       +
                           ]

     

       652
       652
       +
       

     

       653
       653
       +
                       timeline_items.append({

     

       654
       654
       +
                           "type": "post",

     

       655
       655
       +
                           "date": entry.updated or entry.published or datetime.min,

     

       656
       656
       +
                           "content": {

     

       657
       657
       +
                               "username": username,

     

       658
       658
       +
                               "display_name": self.get_display_name(username),

     

       659
       659
       +
                               "entry": entry,

     

       660
       660
       +
                               "references": refs if refs else None

     

       661
       661
       +
                           }

     

       662
       662
       +
                       })

     

       663
       663
       +
       

     

       664
       664
       +
               # Sort unified timeline by date (newest first)

     

       665
       665
       +
               timeline_items.sort(key=lambda x: x["date"], reverse=True)

     

       666
       666
       +
       

     

       667
       667
       +
               # Limit timeline to what will actually be rendered

     

       668
       668
       +
               timeline_items = timeline_items[:50]  # Limit to 50 items total

     

       669
       669
       +
       

     

       670
       670
       +
               # Add cross-thread linking for repeat blog references

     

       671
       671
       +
               self._add_cross_thread_links(timeline_items)

     

       672
       672
       +
       

     

       673
       673
       +
               # Prepare outgoing links data

     

       674
       674
       +
               outgoing_links = []

     

       675
       675
       +
               if self.links_data and "links" in self.links_data:

     

       676
       676
       +
                   for url, link_info in self.links_data["links"].items():

     

       677
       677
       +
                       referencing_entries = []

     

       678
       678
       +
                       for entry_id in link_info.get("referencing_entries", []):

     

       679
       679
       +
                           for username, entry in self.entries:

     

       680
       680
       +
                               if entry.id == entry_id:

     

       681
       681
       +
                                   referencing_entries.append(

     

       682
       682
       +
                                       (self.get_display_name(username), entry)

     

       683
       683
       +
                                   )

     

       684
       684
       +
                                   break

     

       685
       685
       +
       

     

       686
       686
       +
                       if referencing_entries:

     

       687
       687
       +
                           # Sort by date - prioritize updated over published

     

       688
       688
       +
                           referencing_entries.sort(

     

       689
       689
       +
                               key=lambda x: x[1].updated or x[1].published or datetime.min, reverse=True

     

       690
       690
       +
                           )

     

       691
       691
       +
                           outgoing_links.append(

     

       692
       692
       +
                               {

     

       693
       693
       +
                                   "url": url,

     

       694
       694
       +
                                   "target_username": link_info.get("target_username"),

     

       695
       695
       +
                                   "entries": referencing_entries,

     

       696
       696
       +
                               }

     

       697
       697
       +
                           )

     

       698
       698
       +
       

     

       699
       699
       +
                   # Sort links by most recent reference - prioritize updated over published

     

       700
       700
       +
                   outgoing_links.sort(

     

       701
       701
       +
                       key=lambda x: x["entries"][0][1].updated

     

       702
       702
       +
                       or x["entries"][0][1].published or datetime.min,

     

       703
       703
       +
                       reverse=True,

     

       704
       704
       +
                   )

     

       705
       705
       +
       

     

       706
       706
       +
               # Prepare users data

     

       707
       707
       +
               users: list[UserData] = []

     

       708
       708
       +
               if self.index:

     

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

     

       710
       710
       +
                       # Get recent entries for this user with display names

     

       711
       711
       +
                       user_entries = [

     

       712
       712
       +
                           (self.get_display_name(u), e)

     

       713
       713
       +
                           for u, e in self.entries

     

       714
       714
       +
                           if u == username

     

       715
       715
       +
                       ][:5]

     

       716
       716
       +
                       users.append(

     

       717
       717
       +
                           {"metadata": user_metadata, "recent_entries": user_entries}

     

       718
       718
       +
                       )

     

       719
       719
       +
                   # Sort by entry count

     

       720
       720
       +
                   users.sort(key=lambda x: x["metadata"].entry_count, reverse=True)

     

       721
       721
       +
       

     

       722
       722
       +
               # Generate timeline page

     

       723
       723
       +
               timeline_template = self.env.get_template("timeline.html")

     

       724
       724
       +
               timeline_content = timeline_template.render(

     

       725
       725
       +
                   **base_data,

     

       726
       726
       +
                   page="timeline",

     

       727
       727
       +
                   timeline_items=timeline_items,  # Already limited above

     

       728
       728
       +
               )

     

       729
       729
       +
               with open(self.output_dir / "timeline.html", "w") as f:

     

       730
       730
       +
                   f.write(timeline_content)

     

       731
       731
       +
       

     

       732
       732
       +
               # Generate links page

     

       733
       733
       +
               links_template = self.env.get_template("links.html")

     

       734
       734
       +
               links_content = links_template.render(

     

       735
       735
       +
                   **base_data,

     

       736
       736
       +
                   page="links",

     

       737
       737
       +
                   outgoing_links=outgoing_links[:100],

     

       738
       738
       +
               )

     

       739
       739
       +
               with open(self.output_dir / "links.html", "w") as f:

     

       740
       740
       +
                   f.write(links_content)

     

       741
       741
       +
       

     

       742
       742
       +
               # Generate users page

     

       743
       743
       +
               users_template = self.env.get_template("users.html")

     

       744
       744
       +
               users_content = users_template.render(

     

       745
       745
       +
                   **base_data,

     

       746
       746
       +
                   page="users",

     

       747
       747
       +
                   users=users,

     

       748
       748
       +
               )

     

       749
       749
       +
               with open(self.output_dir / "users.html", "w") as f:

     

       750
       750
       +
                   f.write(users_content)

     

       751
       751
       +
       

     

       752
       752
       +
               # Generate main index page (redirect to timeline)

     

       753
       753
       +
               index_template = self.env.get_template("index.html")

     

       754
       754
       +
               index_content = index_template.render(**base_data)

     

       755
       755
       +
               with open(self.output_dir / "index.html", "w") as f:

     

       756
       756
       +
                   f.write(index_content)

     

       757
       757
       +
       

     

       758
       758
       +
               console.print(f"[green]✓[/green] Generated website at {self.output_dir}")

     

       759
       759
       +
               console.print(f"  - {len(self.entries)} entries")

     

       760
       760
       +
               console.print(f"  - {len(self.threads)} conversation threads")

     

       761
       761
       +
               console.print(f"  - {len(outgoing_links)} outgoing links")

     

       762
       762
       +
               console.print(f"  - {len(users)} users")

     

       763
       763
       +
               console.print(

     

       764
       764
       +
                   "  - Generated pages: index.html, timeline.html, links.html, users.html"

     

       765
       765
       +
               )

     

       766
       766
       +
       

     

       767
       767
       +
       

     

       768
       768
       +
       @app.command()

     

       769
       769
       +
       def generate(

     

       770
       770
       +
           output: Path = typer.Option(

     

       771
       771
       +
               Path("./thicket-site"),

     

       772
       772
       +
               "--output",

     

       773
       773
       +
               "-o",

     

       774
       774
       +
               help="Output directory for the generated website",

     

       775
       775
       +
           ),

     

       776
       776
       +
           force: bool = typer.Option(

     

       777
       777
       +
               False, "--force", "-f", help="Overwrite existing output directory"

     

       778
       778
       +
           ),

     

       779
       779
       +
           config_file: Path = typer.Option(

     

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

     

       781
       781
       +
           ),

     

       782
       782
       +
       ) -> None:

     

       783
       783
       +
           """Generate a static HTML website from thicket data."""

     

       784
       784
       +
           config = load_config(config_file)

     

       785
       785
       +
       

     

       786
       786
       +
           if not config.git_store:

     

       787
       787
       +
               console.print("[red]No git store path configured[/red]")

     

       788
       788
       +
               raise typer.Exit(1)

     

       789
       789
       +
       

     

       790
       790
       +
           git_store = GitStore(config.git_store)

     

       791
       791
       +
       

     

       792
       792
       +
           # Check if output directory exists

     

       793
       793
       +
           if output.exists() and not force:

     

       794
       794
       +
               console.print(

     

       795
       795
       +
                   f"[red]Output directory {output} already exists. Use --force to overwrite.[/red]"

     

       796
       796
       +
               )

     

       797
       797
       +
               raise typer.Exit(1)

     

       798
       798
       +
       

     

       799
       799
       +
           # Clean output directory if forcing

     

       800
       800
       +
           if output.exists() and force:

     

       801
       801
       +
               shutil.rmtree(output)

     

       802
       802
       +
       

     

       803
       803
       +
           try:

     

       804
       804
       +
               generator = WebsiteGenerator(git_store, output)

     

       805
       805
       +
       

     

       806
       806
       +
               console.print("[bold]Generating static website...[/bold]")

     

       807
       807
       +
               generator.load_data()

     

       808
       808
       +
               generator.build_threads()

     

       809
       809
       +
               generator.generate_site()

     

       810
       810
       +
       

     

       811
       811
       +
           except Exception as e:

     

       812
       812
       +
               console.print(f"[red]Error generating website: {e}[/red]")

     

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

     

       814
       814
       +
       </file>

     

       815
       815
       +
       

     

       816
       816
       +
       <file path="src/thicket/templates/base.html">

     

       817
       817
       +
       <!DOCTYPE html>

     

       818
       818
       +
       <html lang="en">

     

       819
       819
       +
       <head>

     

       820
       820
       +
           <meta charset="UTF-8">

     

       821
       821
       +
           <meta name="viewport" content="width=device-width, initial-scale=1.0">

     

       822
       822
       +
           <title>{% block page_title %}{{ title }}{% endblock %}</title>

     

       823
       823
       +
           <link rel="stylesheet" href="css/style.css">

     

       824
       824
       +
       </head>

     

       825
       825
       +
       <body>

     

       826
       826
       +
           <header class="site-header">

     

       827
       827
       +
               <div class="header-content">

     

       828
       828
       +
                   <h1 class="site-title">{{ title }}</h1>

     

       829
       829
       +
                   <nav class="site-nav">

     

       830
       830
       +
                       <a href="timeline.html" class="nav-link {% if page == 'timeline' %}active{% endif %}">Timeline</a>

     

       831
       831
       +
                       <a href="links.html" class="nav-link {% if page == 'links' %}active{% endif %}">Links</a>

     

       832
       832
       +
                       <a href="users.html" class="nav-link {% if page == 'users' %}active{% endif %}">Users</a>

     

       833
       833
       +
                   </nav>

     

       834
       834
       +
               </div>

     

       835
       835
       +
           </header>

     

       836
       836
       +
       

     

       837
       837
       +
           <main class="main-content">

     

       838
       838
       +
               {% block content %}{% endblock %}

     

       839
       839
       +
           </main>

     

       840
       840
       +
       

     

       841
       841
       +
           <footer class="site-footer">

     

       842
       842
       +
               <p>Generated on {{ generated_at }} by <a href="https://github.com/avsm/thicket">Thicket</a></p>

     

       843
       843
       +
           </footer>

     

       844
       844
       +
       

     

       845
       845
       +
           <script src="js/script.js"></script>

     

       846
       846
       +
       </body>

     

       847
       847
       +
       </html>

     

       848
       848
       +
       </file>

     

       849
       849
       +
       

     

       850
       850
       +
       <file path="src/thicket/templates/index.html">

     

       851
       851
       +
       <!DOCTYPE html>

     

       852
       852
       +
       <html lang="en">

     

       853
       853
       +
       <head>

     

       854
       854
       +
           <meta charset="UTF-8">

     

       855
       855
       +
           <meta name="viewport" content="width=device-width, initial-scale=1.0">

     

       856
       856
       +
           <title>{{ title }}</title>

     

       857
       857
       +
           <meta http-equiv="refresh" content="0; url=timeline.html">

     

       858
       858
       +
           <link rel="canonical" href="timeline.html">

     

       859
       859
       +
       </head>

     

       860
       860
       +
       <body>

     

       861
       861
       +
           <p>Redirecting to <a href="timeline.html">Timeline</a>...</p>

     

       862
       862
       +
       </body>

     

       863
       863
       +
       </html>

     

       864
       864
       +
       </file>

     

       865
       865
       +
       

     

       866
       866
       +
       <file path="src/thicket/templates/links.html">

     

       867
       867
       +
       {% extends "base.html" %}

     

       868
       868
       +
       

     

       869
       869
       +
       {% block page_title %}Outgoing Links - {{ title }}{% endblock %}

     

       870
       870
       +
       

     

       871
       871
       +
       {% block content %}

     

       872
       872
       +
       <div class="page-content">

     

       873
       873
       +
           <h2>Outgoing Links</h2>

     

       874
       874
       +
           <p class="page-description">External links referenced in blog posts, ordered by most recent reference.</p>

     

       875
       875
       +
           

     

       876
       876
       +
           {% for link in outgoing_links %}

     

       877
       877
       +
           <article class="link-group">

     

       878
       878
       +
               <h3 class="link-url">

     

       879
       879
       +
                   <a href="{{ link.url }}" target="_blank">{{ link.url|truncate(80) }}</a>

     

       880
       880
       +
                   {% if link.target_username %}

     

       881
       881
       +
                   <span class="target-user">({{ link.target_username }})</span>

     

       882
       882
       +
                   {% endif %}

     

       883
       883
       +
               </h3>

     

       884
       884
       +
               <div class="referencing-entries">

     

       885
       885
       +
                   <span class="ref-count">Referenced in {{ link.entries|length }} post(s):</span>

     

       886
       886
       +
                   <ul>

     

       887
       887
       +
                       {% for display_name, entry in link.entries[:5] %}

     

       888
       888
       +
                       <li>

     

       889
       889
       +
                           <span class="author">{{ display_name }}</span> - 

     

       890
       890
       +
                           <a href="{{ entry.link }}" target="_blank">{{ entry.title }}</a>

     

       891
       891
       +
                           <time datetime="{{ entry.updated or entry.published }}">

     

       892
       892
       +
                               ({{ (entry.updated or entry.published).strftime('%Y-%m-%d') }})

     

       893
       893
       +
                           </time>

     

       894
       894
       +
                       </li>

     

       895
       895
       +
                       {% endfor %}

     

       896
       896
       +
                       {% if link.entries|length > 5 %}

     

       897
       897
       +
                       <li class="more">... and {{ link.entries|length - 5 }} more</li>

     

       898
       898
       +
                       {% endif %}

     

       899
       899
       +
                   </ul>

     

       900
       900
       +
               </div>

     

       901
       901
       +
           </article>

     

       902
       902
       +
           {% endfor %}

     

       903
       903
       +
       </div>

     

       904
       904
       +
       {% endblock %}

     

       905
       905
       +
       </file>

     

       906
       906
       +
       

     

       907
       907
       +
       <file path="src/thicket/templates/script.js">

     

       908
       908
       +
       // Enhanced functionality for thicket website

     

       909
       909
       +
       document.addEventListener('DOMContentLoaded', function() {

     

       910
       910
       +
           

     

       911
       911
       +
           // Enhance thread collapsing (optional feature)

     

       912
       912
       +
           const threadHeaders = document.querySelectorAll('.thread-header');

     

       913
       913
       +
           threadHeaders.forEach(header => {

     

       914
       914
       +
               header.style.cursor = 'pointer';

     

       915
       915
       +
               header.addEventListener('click', function() {

     

       916
       916
       +
                   const thread = this.parentElement;

     

       917
       917
       +
                   const entries = thread.querySelectorAll('.thread-entry');

     

       918
       918
       +
                   

     

       919
       919
       +
                   // Toggle visibility of all but the first entry

     

       920
       920
       +
                   for (let i = 1; i < entries.length; i++) {

     

       921
       921
       +
                       entries[i].style.display = entries[i].style.display === 'none' ? 'block' : 'none';

     

       922
       922
       +
                   }

     

       923
       923
       +
                   

     

       924
       924
       +
                   // Update thread count text

     

       925
       925
       +
                   const count = this.querySelector('.thread-count');

     

       926
       926
       +
                   if (entries[1] && entries[1].style.display === 'none') {

     

       927
       927
       +
                       count.textContent = count.textContent.replace('posts', 'posts (collapsed)');

     

       928
       928
       +
                   } else {

     

       929
       929
       +
                       count.textContent = count.textContent.replace(' (collapsed)', '');

     

       930
       930
       +
                   }

     

       931
       931
       +
               });

     

       932
       932
       +
           });

     

       933
       933
       +
           

     

       934
       934
       +
           // Add relative time display

     

       935
       935
       +
           const timeElements = document.querySelectorAll('time');

     

       936
       936
       +
           timeElements.forEach(timeEl => {

     

       937
       937
       +
               const datetime = new Date(timeEl.getAttribute('datetime'));

     

       938
       938
       +
               const now = new Date();

     

       939
       939
       +
               const diffMs = now - datetime;

     

       940
       940
       +
               const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));

     

       941
       941
       +
               

     

       942
       942
       +
               let relativeTime;

     

       943
       943
       +
               if (diffDays === 0) {

     

       944
       944
       +
                   const diffHours = Math.floor(diffMs / (1000 * 60 * 60));

     

       945
       945
       +
                   if (diffHours === 0) {

     

       946
       946
       +
                       const diffMinutes = Math.floor(diffMs / (1000 * 60));

     

       947
       947
       +
                       relativeTime = diffMinutes === 0 ? 'just now' : `${diffMinutes}m ago`;

     

       948
       948
       +
                   } else {

     

       949
       949
       +
                       relativeTime = `${diffHours}h ago`;

     

       950
       950
       +
                   }

     

       951
       951
       +
               } else if (diffDays === 1) {

     

       952
       952
       +
                   relativeTime = 'yesterday';

     

       953
       953
       +
               } else if (diffDays < 7) {

     

       954
       954
       +
                   relativeTime = `${diffDays}d ago`;

     

       955
       955
       +
               } else if (diffDays < 30) {

     

       956
       956
       +
                   const weeks = Math.floor(diffDays / 7);

     

       957
       957
       +
                   relativeTime = weeks === 1 ? '1w ago' : `${weeks}w ago`;

     

       958
       958
       +
               } else if (diffDays < 365) {

     

       959
       959
       +
                   const months = Math.floor(diffDays / 30);

     

       960
       960
       +
                   relativeTime = months === 1 ? '1mo ago' : `${months}mo ago`;

     

       961
       961
       +
               } else {

     

       962
       962
       +
                   const years = Math.floor(diffDays / 365);

     

       963
       963
       +
                   relativeTime = years === 1 ? '1y ago' : `${years}y ago`;

     

       964
       964
       +
               }

     

       965
       965
       +
               

     

       966
       966
       +
               // Add relative time as title attribute

     

       967
       967
       +
               timeEl.setAttribute('title', timeEl.textContent);

     

       968
       968
       +
               timeEl.textContent = relativeTime;

     

       969
       969
       +
           });

     

       970
       970
       +
           

     

       971
       971
       +
           // Enhanced anchor link scrolling for shared references

     

       972
       972
       +
           document.querySelectorAll('a[href^="#"]').forEach(anchor => {

     

       973
       973
       +
               anchor.addEventListener('click', function (e) {

     

       974
       974
       +
                   e.preventDefault();

     

       975
       975
       +
                   const target = document.querySelector(this.getAttribute('href'));

     

       976
       976
       +
                   if (target) {

     

       977
       977
       +
                       target.scrollIntoView({

     

       978
       978
       +
                           behavior: 'smooth',

     

       979
       979
       +
                           block: 'center'

     

       980
       980
       +
                       });

     

       981
       981
       +
                       

     

       982
       982
       +
                       // Highlight the target briefly

     

       983
       983
       +
                       const timelineEntry = target.closest('.timeline-entry');

     

       984
       984
       +
                       if (timelineEntry) {

     

       985
       985
       +
                           timelineEntry.style.outline = '2px solid var(--primary-color)';

     

       986
       986
       +
                           timelineEntry.style.borderRadius = '8px';

     

       987
       987
       +
                           setTimeout(() => {

     

       988
       988
       +
                               timelineEntry.style.outline = '';

     

       989
       989
       +
                               timelineEntry.style.borderRadius = '';

     

       990
       990
       +
                           }, 2000);

     

       991
       991
       +
                       }

     

       992
       992
       +
                   }

     

       993
       993
       +
               });

     

       994
       994
       +
           });

     

       995
       995
       +
       });

     

       996
       996
       +
       </file>

     

       997
       997
       +
       

     

       998
       998
       +
       <file path="src/thicket/templates/style.css">

     

       999
       999
       +
       /* Modern, clean design with high-density text and readable theme */

     

       1000
       1000
       +
       

     

       1001
       1001
       +
       :root {

     

       1002
       1002
       +
           --primary-color: #2c3e50;

     

       1003
       1003
       +
           --secondary-color: #3498db;

     

       1004
       1004
       +
           --accent-color: #e74c3c;

     

       1005
       1005
       +
           --background: #ffffff;

     

       1006
       1006
       +
           --surface: #f8f9fa;

     

       1007
       1007
       +
           --text-primary: #2c3e50;

     

       1008
       1008
       +
           --text-secondary: #7f8c8d;

     

       1009
       1009
       +
           --border-color: #e0e0e0;

     

       1010
       1010
       +
           --thread-indent: 20px;

     

       1011
       1011
       +
           --max-width: 1200px;

     

       1012
       1012
       +
       }

     

       1013
       1013
       +
       

     

       1014
       1014
       +
       * {

     

       1015
       1015
       +
           margin: 0;

     

       1016
       1016
       +
           padding: 0;

     

       1017
       1017
       +
           box-sizing: border-box;

     

       1018
       1018
       +
       }

     

       1019
       1019
       +
       

     

       1020
       1020
       +
       body {

     

       1021
       1021
       +
           font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Helvetica Neue', Arial, sans-serif;

     

       1022
       1022
       +
           font-size: 14px;

     

       1023
       1023
       +
           line-height: 1.6;

     

       1024
       1024
       +
           color: var(--text-primary);

     

       1025
       1025
       +
           background-color: var(--background);

     

       1026
       1026
       +
       }

     

       1027
       1027
       +
       

     

       1028
       1028
       +
       /* Header */

     

       1029
       1029
       +
       .site-header {

     

       1030
       1030
       +
           background-color: var(--surface);

     

       1031
       1031
       +
           border-bottom: 1px solid var(--border-color);

     

       1032
       1032
       +
           padding: 0.75rem 0;

     

       1033
       1033
       +
           position: sticky;

     

       1034
       1034
       +
           top: 0;

     

       1035
       1035
       +
           z-index: 100;

     

       1036
       1036
       +
       }

     

       1037
       1037
       +
       

     

       1038
       1038
       +
       .header-content {

     

       1039
       1039
       +
           max-width: var(--max-width);

     

       1040
       1040
       +
           margin: 0 auto;

     

       1041
       1041
       +
           padding: 0 2rem;

     

       1042
       1042
       +
           display: flex;

     

       1043
       1043
       +
           justify-content: space-between;

     

       1044
       1044
       +
           align-items: center;

     

       1045
       1045
       +
       }

     

       1046
       1046
       +
       

     

       1047
       1047
       +
       .site-title {

     

       1048
       1048
       +
           font-size: 1.5rem;

     

       1049
       1049
       +
           font-weight: 600;

     

       1050
       1050
       +
           color: var(--primary-color);

     

       1051
       1051
       +
           margin: 0;

     

       1052
       1052
       +
       }

     

       1053
       1053
       +
       

     

       1054
       1054
       +
       /* Navigation */

     

       1055
       1055
       +
       .site-nav {

     

       1056
       1056
       +
           display: flex;

     

       1057
       1057
       +
           gap: 1.5rem;

     

       1058
       1058
       +
       }

     

       1059
       1059
       +
       

     

       1060
       1060
       +
       .nav-link {

     

       1061
       1061
       +
           text-decoration: none;

     

       1062
       1062
       +
           color: var(--text-secondary);

     

       1063
       1063
       +
           font-weight: 500;

     

       1064
       1064
       +
           font-size: 0.95rem;

     

       1065
       1065
       +
           padding: 0.5rem 0.75rem;

     

       1066
       1066
       +
           border-radius: 4px;

     

       1067
       1067
       +
           transition: all 0.2s ease;

     

       1068
       1068
       +
       }

     

       1069
       1069
       +
       

     

       1070
       1070
       +
       .nav-link:hover {

     

       1071
       1071
       +
           color: var(--primary-color);

     

       1072
       1072
       +
           background-color: var(--background);

     

       1073
       1073
       +
       }

     

       1074
       1074
       +
       

     

       1075
       1075
       +
       .nav-link.active {

     

       1076
       1076
       +
           color: var(--secondary-color);

     

       1077
       1077
       +
           background-color: var(--background);

     

       1078
       1078
       +
           font-weight: 600;

     

       1079
       1079
       +
       }

     

       1080
       1080
       +
       

     

       1081
       1081
       +
       /* Main Content */

     

       1082
       1082
       +
       .main-content {

     

       1083
       1083
       +
           max-width: var(--max-width);

     

       1084
       1084
       +
           margin: 2rem auto;

     

       1085
       1085
       +
           padding: 0 2rem;

     

       1086
       1086
       +
       }

     

       1087
       1087
       +
       

     

       1088
       1088
       +
       .page-content {

     

       1089
       1089
       +
           margin: 0;

     

       1090
       1090
       +
       }

     

       1091
       1091
       +
       

     

       1092
       1092
       +
       .page-description {

     

       1093
       1093
       +
           color: var(--text-secondary);

     

       1094
       1094
       +
           margin-bottom: 1.5rem;

     

       1095
       1095
       +
           font-style: italic;

     

       1096
       1096
       +
       }

     

       1097
       1097
       +
       

     

       1098
       1098
       +
       /* Sections */

     

       1099
       1099
       +
       section {

     

       1100
       1100
       +
           margin-bottom: 2rem;

     

       1101
       1101
       +
       }

     

       1102
       1102
       +
       

     

       1103
       1103
       +
       h2 {

     

       1104
       1104
       +
           font-size: 1.3rem;

     

       1105
       1105
       +
           font-weight: 600;

     

       1106
       1106
       +
           margin-bottom: 0.75rem;

     

       1107
       1107
       +
           color: var(--primary-color);

     

       1108
       1108
       +
       }

     

       1109
       1109
       +
       

     

       1110
       1110
       +
       h3 {

     

       1111
       1111
       +
           font-size: 1.1rem;

     

       1112
       1112
       +
           font-weight: 600;

     

       1113
       1113
       +
           margin-bottom: 0.75rem;

     

       1114
       1114
       +
           color: var(--primary-color);

     

       1115
       1115
       +
       }

     

       1116
       1116
       +
       

     

       1117
       1117
       +
       /* Entries and Threads */

     

       1118
       1118
       +
       article {

     

       1119
       1119
       +
           margin-bottom: 1.5rem;

     

       1120
       1120
       +
           padding: 1rem;

     

       1121
       1121
       +
           background-color: var(--surface);

     

       1122
       1122
       +
           border-radius: 4px;

     

       1123
       1123
       +
           border: 1px solid var(--border-color);

     

       1124
       1124
       +
       }

     

       1125
       1125
       +
       

     

       1126
       1126
       +
       /* Timeline-style entries */

     

       1127
       1127
       +
       .timeline-entry {

     

       1128
       1128
       +
           margin-bottom: 0.5rem;

     

       1129
       1129
       +
           padding: 0.5rem 0.75rem;

     

       1130
       1130
       +
           border: none;

     

       1131
       1131
       +
           background: transparent;

     

       1132
       1132
       +
           transition: background-color 0.2s ease;

     

       1133
       1133
       +
       }

     

       1134
       1134
       +
       

     

       1135
       1135
       +
       .timeline-entry:hover {

     

       1136
       1136
       +
           background-color: var(--surface);

     

       1137
       1137
       +
       }

     

       1138
       1138
       +
       

     

       1139
       1139
       +
       .timeline-meta {

     

       1140
       1140
       +
           display: inline-flex;

     

       1141
       1141
       +
           gap: 0.5rem;

     

       1142
       1142
       +
           align-items: center;

     

       1143
       1143
       +
           font-size: 0.75rem;

     

       1144
       1144
       +
           color: var(--text-secondary);

     

       1145
       1145
       +
           margin-bottom: 0.25rem;

     

       1146
       1146
       +
       }

     

       1147
       1147
       +
       

     

       1148
       1148
       +
       .timeline-time {

     

       1149
       1149
       +
           font-family: 'SF Mono', Monaco, Consolas, 'Courier New', monospace;

     

       1150
       1150
       +
           font-size: 0.75rem;

     

       1151
       1151
       +
           color: var(--text-secondary);

     

       1152
       1152
       +
       }

     

       1153
       1153
       +
       

     

       1154
       1154
       +
       .timeline-author {

     

       1155
       1155
       +
           font-weight: 600;

     

       1156
       1156
       +
           color: var(--primary-color);

     

       1157
       1157
       +
           font-size: 0.8rem;

     

       1158
       1158
       +
           text-decoration: none;

     

       1159
       1159
       +
       }

     

       1160
       1160
       +
       

     

       1161
       1161
       +
       .timeline-author:hover {

     

       1162
       1162
       +
           color: var(--secondary-color);

     

       1163
       1163
       +
           text-decoration: underline;

     

       1164
       1164
       +
       }

     

       1165
       1165
       +
       

     

       1166
       1166
       +
       .timeline-content {

     

       1167
       1167
       +
           line-height: 1.4;

     

       1168
       1168
       +
       }

     

       1169
       1169
       +
       

     

       1170
       1170
       +
       .timeline-title {

     

       1171
       1171
       +
           font-size: 0.95rem;

     

       1172
       1172
       +
           font-weight: 600;

     

       1173
       1173
       +
       }

     

       1174
       1174
       +
       

     

       1175
       1175
       +
       .timeline-title a {

     

       1176
       1176
       +
           color: var(--primary-color);

     

       1177
       1177
       +
           text-decoration: none;

     

       1178
       1178
       +
       }

     

       1179
       1179
       +
       

     

       1180
       1180
       +
       .timeline-title a:hover {

     

       1181
       1181
       +
           color: var(--secondary-color);

     

       1182
       1182
       +
           text-decoration: underline;

     

       1183
       1183
       +
       }

     

       1184
       1184
       +
       

     

       1185
       1185
       +
       .timeline-summary {

     

       1186
       1186
       +
           color: var(--text-secondary);

     

       1187
       1187
       +
           font-size: 0.9rem;

     

       1188
       1188
       +
           line-height: 1.4;

     

       1189
       1189
       +
       }

     

       1190
       1190
       +
       

     

       1191
       1191
       +
       /* Legacy styles for other sections */

     

       1192
       1192
       +
       .entry-meta, .thread-header {

     

       1193
       1193
       +
           display: flex;

     

       1194
       1194
       +
           gap: 1rem;

     

       1195
       1195
       +
           align-items: center;

     

       1196
       1196
       +
           margin-bottom: 0.5rem;

     

       1197
       1197
       +
           font-size: 0.85rem;

     

       1198
       1198
       +
           color: var(--text-secondary);

     

       1199
       1199
       +
       }

     

       1200
       1200
       +
       

     

       1201
       1201
       +
       .author {

     

       1202
       1202
       +
           font-weight: 600;

     

       1203
       1203
       +
           color: var(--primary-color);

     

       1204
       1204
       +
       }

     

       1205
       1205
       +
       

     

       1206
       1206
       +
       time {

     

       1207
       1207
       +
           font-size: 0.85rem;

     

       1208
       1208
       +
       }

     

       1209
       1209
       +
       

     

       1210
       1210
       +
       h4 {

     

       1211
       1211
       +
           font-size: 1.1rem;

     

       1212
       1212
       +
           font-weight: 600;

     

       1213
       1213
       +
           margin-bottom: 0.5rem;

     

       1214
       1214
       +
       }

     

       1215
       1215
       +
       

     

       1216
       1216
       +
       h4 a {

     

       1217
       1217
       +
           color: var(--primary-color);

     

       1218
       1218
       +
           text-decoration: none;

     

       1219
       1219
       +
       }

     

       1220
       1220
       +
       

     

       1221
       1221
       +
       h4 a:hover {

     

       1222
       1222
       +
           color: var(--secondary-color);

     

       1223
       1223
       +
           text-decoration: underline;

     

       1224
       1224
       +
       }

     

       1225
       1225
       +
       

     

       1226
       1226
       +
       .entry-summary {

     

       1227
       1227
       +
           color: var(--text-primary);

     

       1228
       1228
       +
           line-height: 1.5;

     

       1229
       1229
       +
           margin-top: 0.5rem;

     

       1230
       1230
       +
       }

     

       1231
       1231
       +
       

     

       1232
       1232
       +
       /* Enhanced Threading Styles */

     

       1233
       1233
       +
       

     

       1234
       1234
       +
       /* Conversation Clusters */

     

       1235
       1235
       +
       .conversation-cluster {

     

       1236
       1236
       +
           background-color: var(--background);

     

       1237
       1237
       +
           border: 2px solid var(--border-color);

     

       1238
       1238
       +
           border-radius: 8px;

     

       1239
       1239
       +
           margin-bottom: 2rem;

     

       1240
       1240
       +
           overflow: hidden;

     

       1241
       1241
       +
           box-shadow: 0 2px 4px rgba(0, 0, 0, 0.05);

     

       1242
       1242
       +
       }

     

       1243
       1243
       +
       

     

       1244
       1244
       +
       .conversation-header {

     

       1245
       1245
       +
           background: linear-gradient(135deg, var(--surface) 0%, #f1f3f4 100%);

     

       1246
       1246
       +
           padding: 0.75rem 1rem;

     

       1247
       1247
       +
           border-bottom: 1px solid var(--border-color);

     

       1248
       1248
       +
       }

     

       1249
       1249
       +
       

     

       1250
       1250
       +
       .conversation-meta {

     

       1251
       1251
       +
           display: flex;

     

       1252
       1252
       +
           justify-content: space-between;

     

       1253
       1253
       +
           align-items: center;

     

       1254
       1254
       +
           flex-wrap: wrap;

     

       1255
       1255
       +
           gap: 0.5rem;

     

       1256
       1256
       +
       }

     

       1257
       1257
       +
       

     

       1258
       1258
       +
       .conversation-count {

     

       1259
       1259
       +
           font-weight: 600;

     

       1260
       1260
       +
           color: var(--secondary-color);

     

       1261
       1261
       +
           font-size: 0.9rem;

     

       1262
       1262
       +
       }

     

       1263
       1263
       +
       

     

       1264
       1264
       +
       .conversation-participants {

     

       1265
       1265
       +
           font-size: 0.8rem;

     

       1266
       1266
       +
           color: var(--text-secondary);

     

       1267
       1267
       +
           flex: 1;

     

       1268
       1268
       +
           text-align: right;

     

       1269
       1269
       +
       }

     

       1270
       1270
       +
       

     

       1271
       1271
       +
       .conversation-flow {

     

       1272
       1272
       +
           padding: 0.5rem;

     

       1273
       1273
       +
       }

     

       1274
       1274
       +
       

     

       1275
       1275
       +
       /* Threaded Conversation Entries */

     

       1276
       1276
       +
       .conversation-entry {

     

       1277
       1277
       +
           position: relative;

     

       1278
       1278
       +
           margin-bottom: 0.75rem;

     

       1279
       1279
       +
           display: flex;

     

       1280
       1280
       +
           align-items: flex-start;

     

       1281
       1281
       +
       }

     

       1282
       1282
       +
       

     

       1283
       1283
       +
       .conversation-entry.level-0 {

     

       1284
       1284
       +
           margin-left: 0;

     

       1285
       1285
       +
       }

     

       1286
       1286
       +
       

     

       1287
       1287
       +
       .conversation-entry.level-1 {

     

       1288
       1288
       +
           margin-left: 1.5rem;

     

       1289
       1289
       +
       }

     

       1290
       1290
       +
       

     

       1291
       1291
       +
       .conversation-entry.level-2 {

     

       1292
       1292
       +
           margin-left: 3rem;

     

       1293
       1293
       +
       }

     

       1294
       1294
       +
       

     

       1295
       1295
       +
       .conversation-entry.level-3 {

     

       1296
       1296
       +
           margin-left: 4.5rem;

     

       1297
       1297
       +
       }

     

       1298
       1298
       +
       

     

       1299
       1299
       +
       .conversation-entry.level-4 {

     

       1300
       1300
       +
           margin-left: 6rem;

     

       1301
       1301
       +
       }

     

       1302
       1302
       +
       

     

       1303
       1303
       +
       .entry-connector {

     

       1304
       1304
       +
           width: 3px;

     

       1305
       1305
       +
           background-color: var(--secondary-color);

     

       1306
       1306
       +
           margin-right: 0.75rem;

     

       1307
       1307
       +
           margin-top: 0.25rem;

     

       1308
       1308
       +
           min-height: 2rem;

     

       1309
       1309
       +
           border-radius: 2px;

     

       1310
       1310
       +
           opacity: 0.6;

     

       1311
       1311
       +
       }

     

       1312
       1312
       +
       

     

       1313
       1313
       +
       .conversation-entry.level-0 .entry-connector {

     

       1314
       1314
       +
           background-color: var(--accent-color);

     

       1315
       1315
       +
           opacity: 0.8;

     

       1316
       1316
       +
       }

     

       1317
       1317
       +
       

     

       1318
       1318
       +
       .entry-content {

     

       1319
       1319
       +
           flex: 1;

     

       1320
       1320
       +
           background-color: var(--surface);

     

       1321
       1321
       +
           padding: 0.75rem;

     

       1322
       1322
       +
           border-radius: 6px;

     

       1323
       1323
       +
           border: 1px solid var(--border-color);

     

       1324
       1324
       +
           transition: all 0.2s ease;

     

       1325
       1325
       +
       }

     

       1326
       1326
       +
       

     

       1327
       1327
       +
       .entry-content:hover {

     

       1328
       1328
       +
           border-color: var(--secondary-color);

     

       1329
       1329
       +
           box-shadow: 0 2px 8px rgba(52, 152, 219, 0.1);

     

       1330
       1330
       +
       }

     

       1331
       1331
       +
       

     

       1332
       1332
       +
       /* Reference Indicators */

     

       1333
       1333
       +
       .reference-indicators {

     

       1334
       1334
       +
           display: inline-flex;

     

       1335
       1335
       +
           gap: 0.25rem;

     

       1336
       1336
       +
           margin-left: 0.5rem;

     

       1337
       1337
       +
       }

     

       1338
       1338
       +
       

     

       1339
       1339
       +
       .ref-out, .ref-in {

     

       1340
       1340
       +
           display: inline-block;

     

       1341
       1341
       +
           width: 1rem;

     

       1342
       1342
       +
           height: 1rem;

     

       1343
       1343
       +
           border-radius: 50%;

     

       1344
       1344
       +
           text-align: center;

     

       1345
       1345
       +
           line-height: 1rem;

     

       1346
       1346
       +
           font-size: 0.7rem;

     

       1347
       1347
       +
           font-weight: bold;

     

       1348
       1348
       +
       }

     

       1349
       1349
       +
       

     

       1350
       1350
       +
       .ref-out {

     

       1351
       1351
       +
           background-color: #e8f5e8;

     

       1352
       1352
       +
           color: #2d8f2d;

     

       1353
       1353
       +
       }

     

       1354
       1354
       +
       

     

       1355
       1355
       +
       .ref-in {

     

       1356
       1356
       +
           background-color: #e8f0ff;

     

       1357
       1357
       +
           color: #1f5fbf;

     

       1358
       1358
       +
       }

     

       1359
       1359
       +
       

     

       1360
       1360
       +
       /* Reference Badges for Individual Posts */

     

       1361
       1361
       +
       .timeline-entry.with-references {

     

       1362
       1362
       +
           background-color: var(--surface);

     

       1363
       1363
       +
       }

     

       1364
       1364
       +
       

     

       1365
       1365
       +
       /* Conversation posts in unified timeline */

     

       1366
       1366
       +
       .timeline-entry.conversation-post {

     

       1367
       1367
       +
           background: transparent;

     

       1368
       1368
       +
           border: none;

     

       1369
       1369
       +
           margin-bottom: 0.5rem;

     

       1370
       1370
       +
           padding: 0.5rem 0.75rem;

     

       1371
       1371
       +
       }

     

       1372
       1372
       +
       

     

       1373
       1373
       +
       .timeline-entry.conversation-post.level-0 {

     

       1374
       1374
       +
           margin-left: 0;

     

       1375
       1375
       +
           border-left: 2px solid var(--accent-color);

     

       1376
       1376
       +
           padding-left: 0.75rem;

     

       1377
       1377
       +
       }

     

       1378
       1378
       +
       

     

       1379
       1379
       +
       .timeline-entry.conversation-post.level-1 {

     

       1380
       1380
       +
           margin-left: 1.5rem;

     

       1381
       1381
       +
           border-left: 2px solid var(--secondary-color);

     

       1382
       1382
       +
           padding-left: 0.75rem;

     

       1383
       1383
       +
       }

     

       1384
       1384
       +
       

     

       1385
       1385
       +
       .timeline-entry.conversation-post.level-2 {

     

       1386
       1386
       +
           margin-left: 3rem;

     

       1387
       1387
       +
           border-left: 2px solid var(--text-secondary);

     

       1388
       1388
       +
           padding-left: 0.75rem;

     

       1389
       1389
       +
       }

     

       1390
       1390
       +
       

     

       1391
       1391
       +
       .timeline-entry.conversation-post.level-3 {

     

       1392
       1392
       +
           margin-left: 4.5rem;

     

       1393
       1393
       +
           border-left: 2px solid var(--text-secondary);

     

       1394
       1394
       +
           padding-left: 0.75rem;

     

       1395
       1395
       +
       }

     

       1396
       1396
       +
       

     

       1397
       1397
       +
       .timeline-entry.conversation-post.level-4 {

     

       1398
       1398
       +
           margin-left: 6rem;

     

       1399
       1399
       +
           border-left: 2px solid var(--text-secondary);

     

       1400
       1400
       +
           padding-left: 0.75rem;

     

       1401
       1401
       +
       }

     

       1402
       1402
       +
       

     

       1403
       1403
       +
       /* Cross-thread linking */

     

       1404
       1404
       +
       .cross-thread-links {

     

       1405
       1405
       +
           margin-top: 0.5rem;

     

       1406
       1406
       +
           padding-top: 0.5rem;

     

       1407
       1407
       +
           border-top: 1px solid var(--border-color);

     

       1408
       1408
       +
       }

     

       1409
       1409
       +
       

     

       1410
       1410
       +
       .cross-thread-indicator {

     

       1411
       1411
       +
           font-size: 0.75rem;

     

       1412
       1412
       +
           color: var(--text-secondary);

     

       1413
       1413
       +
           background-color: var(--surface);

     

       1414
       1414
       +
           padding: 0.25rem 0.5rem;

     

       1415
       1415
       +
           border-radius: 12px;

     

       1416
       1416
       +
           border: 1px solid var(--border-color);

     

       1417
       1417
       +
           display: inline-block;

     

       1418
       1418
       +
       }

     

       1419
       1419
       +
       

     

       1420
       1420
       +
       /* Inline shared references styling */

     

       1421
       1421
       +
       .inline-shared-refs {

     

       1422
       1422
       +
           margin-left: 0.5rem;

     

       1423
       1423
       +
           font-size: 0.85rem;

     

       1424
       1424
       +
           color: var(--text-secondary);

     

       1425
       1425
       +
       }

     

       1426
       1426
       +
       

     

       1427
       1427
       +
       .shared-ref-link {

     

       1428
       1428
       +
           color: var(--primary-color);

     

       1429
       1429
       +
           text-decoration: none;

     

       1430
       1430
       +
           font-weight: 500;

     

       1431
       1431
       +
           transition: color 0.2s ease;

     

       1432
       1432
       +
       }

     

       1433
       1433
       +
       

     

       1434
       1434
       +
       .shared-ref-link:hover {

     

       1435
       1435
       +
           color: var(--secondary-color);

     

       1436
       1436
       +
           text-decoration: underline;

     

       1437
       1437
       +
       }

     

       1438
       1438
       +
       

     

       1439
       1439
       +
       .shared-ref-more {

     

       1440
       1440
       +
           font-style: italic;

     

       1441
       1441
       +
           color: var(--text-secondary);

     

       1442
       1442
       +
           font-size: 0.8rem;

     

       1443
       1443
       +
           margin-left: 0.25rem;

     

       1444
       1444
       +
       }

     

       1445
       1445
       +
       

     

       1446
       1446
       +
       .user-anchor, .post-anchor {

     

       1447
       1447
       +
           position: absolute;

     

       1448
       1448
       +
           margin-top: -60px; /* Offset for fixed header */

     

       1449
       1449
       +
           pointer-events: none;

     

       1450
       1450
       +
       }

     

       1451
       1451
       +
       

     

       1452
       1452
       +
       .cross-thread-link {

     

       1453
       1453
       +
           color: var(--primary-color);

     

       1454
       1454
       +
           text-decoration: none;

     

       1455
       1455
       +
           font-weight: 500;

     

       1456
       1456
       +
           transition: color 0.2s ease;

     

       1457
       1457
       +
       }

     

       1458
       1458
       +
       

     

       1459
       1459
       +
       .cross-thread-link:hover {

     

       1460
       1460
       +
           color: var(--secondary-color);

     

       1461
       1461
       +
           text-decoration: underline;

     

       1462
       1462
       +
       }

     

       1463
       1463
       +
       

     

       1464
       1464
       +
       .reference-badges {

     

       1465
       1465
       +
           display: flex;

     

       1466
       1466
       +
           gap: 0.25rem;

     

       1467
       1467
       +
           margin-left: 0.5rem;

     

       1468
       1468
       +
           flex-wrap: wrap;

     

       1469
       1469
       +
       }

     

       1470
       1470
       +
       

     

       1471
       1471
       +
       .ref-badge {

     

       1472
       1472
       +
           display: inline-block;

     

       1473
       1473
       +
           padding: 0.1rem 0.4rem;

     

       1474
       1474
       +
           border-radius: 12px;

     

       1475
       1475
       +
           font-size: 0.7rem;

     

       1476
       1476
       +
           font-weight: 600;

     

       1477
       1477
       +
           text-transform: uppercase;

     

       1478
       1478
       +
           letter-spacing: 0.05em;

     

       1479
       1479
       +
       }

     

       1480
       1480
       +
       

     

       1481
       1481
       +
       .ref-badge.ref-outbound {

     

       1482
       1482
       +
           background-color: #e8f5e8;

     

       1483
       1483
       +
           color: #2d8f2d;

     

       1484
       1484
       +
           border: 1px solid #c3e6c3;

     

       1485
       1485
       +
       }

     

       1486
       1486
       +
       

     

       1487
       1487
       +
       .ref-badge.ref-inbound {

     

       1488
       1488
       +
           background-color: #e8f0ff;

     

       1489
       1489
       +
           color: #1f5fbf;

     

       1490
       1490
       +
           border: 1px solid #b3d9ff;

     

       1491
       1491
       +
       }

     

       1492
       1492
       +
       

     

       1493
       1493
       +
       /* Author Color Coding */

     

       1494
       1494
       +
       .timeline-author {

     

       1495
       1495
       +
           position: relative;

     

       1496
       1496
       +
       }

     

       1497
       1497
       +
       

     

       1498
       1498
       +
       .timeline-author::before {

     

       1499
       1499
       +
           content: '';

     

       1500
       1500
       +
           display: inline-block;

     

       1501
       1501
       +
           width: 8px;

     

       1502
       1502
       +
           height: 8px;

     

       1503
       1503
       +
           border-radius: 50%;

     

       1504
       1504
       +
           margin-right: 0.5rem;

     

       1505
       1505
       +
           background-color: var(--secondary-color);

     

       1506
       1506
       +
       }

     

       1507
       1507
       +
       

     

       1508
       1508
       +
       /* Generate consistent colors for authors */

     

       1509
       1509
       +
       .author-avsm::before { background-color: #e74c3c; }

     

       1510
       1510
       +
       .author-mort::before { background-color: #3498db; }

     

       1511
       1511
       +
       .author-mte::before { background-color: #2ecc71; }

     

       1512
       1512
       +
       .author-ryan::before { background-color: #f39c12; }

     

       1513
       1513
       +
       .author-mwd::before { background-color: #9b59b6; }

     

       1514
       1514
       +
       .author-dra::before { background-color: #1abc9c; }

     

       1515
       1515
       +
       .author-pf341::before { background-color: #34495e; }

     

       1516
       1516
       +
       .author-sadiqj::before { background-color: #e67e22; }

     

       1517
       1517
       +
       .author-martinkl::before { background-color: #8e44ad; }

     

       1518
       1518
       +
       .author-jonsterling::before { background-color: #27ae60; }

     

       1519
       1519
       +
       .author-jon::before { background-color: #f1c40f; }

     

       1520
       1520
       +
       .author-onkar::before { background-color: #e91e63; }

     

       1521
       1521
       +
       .author-gabriel::before { background-color: #00bcd4; }

     

       1522
       1522
       +
       .author-jess::before { background-color: #ff5722; }

     

       1523
       1523
       +
       .author-ibrahim::before { background-color: #607d8b; }

     

       1524
       1524
       +
       .author-andres::before { background-color: #795548; }

     

       1525
       1525
       +
       .author-eeg::before { background-color: #ff9800; }

     

       1526
       1526
       +
       

     

       1527
       1527
       +
       /* Section Headers */

     

       1528
       1528
       +
       .conversations-section h3,

     

       1529
       1529
       +
       .referenced-posts-section h3,

     

       1530
       1530
       +
       .individual-posts-section h3 {

     

       1531
       1531
       +
           border-bottom: 2px solid var(--border-color);

     

       1532
       1532
       +
           padding-bottom: 0.5rem;

     

       1533
       1533
       +
           margin-bottom: 1.5rem;

     

       1534
       1534
       +
           position: relative;

     

       1535
       1535
       +
       }

     

       1536
       1536
       +
       

     

       1537
       1537
       +
       .conversations-section h3::before {

     

       1538
       1538
       +
           content: "💬";

     

       1539
       1539
       +
           margin-right: 0.5rem;

     

       1540
       1540
       +
       }

     

       1541
       1541
       +
       

     

       1542
       1542
       +
       .referenced-posts-section h3::before {

     

       1543
       1543
       +
           content: "🔗";

     

       1544
       1544
       +
           margin-right: 0.5rem;

     

       1545
       1545
       +
       }

     

       1546
       1546
       +
       

     

       1547
       1547
       +
       .individual-posts-section h3::before {

     

       1548
       1548
       +
           content: "📝";

     

       1549
       1549
       +
           margin-right: 0.5rem;

     

       1550
       1550
       +
       }

     

       1551
       1551
       +
       

     

       1552
       1552
       +
       /* Legacy thread styles (for backward compatibility) */

     

       1553
       1553
       +
       .thread {

     

       1554
       1554
       +
           background-color: var(--background);

     

       1555
       1555
       +
           border: 1px solid var(--border-color);

     

       1556
       1556
       +
           padding: 0;

     

       1557
       1557
       +
           overflow: hidden;

     

       1558
       1558
       +
           margin-bottom: 1rem;

     

       1559
       1559
       +
       }

     

       1560
       1560
       +
       

     

       1561
       1561
       +
       .thread-header {

     

       1562
       1562
       +
           background-color: var(--surface);

     

       1563
       1563
       +
           padding: 0.5rem 0.75rem;

     

       1564
       1564
       +
           border-bottom: 1px solid var(--border-color);

     

       1565
       1565
       +
       }

     

       1566
       1566
       +
       

     

       1567
       1567
       +
       .thread-count {

     

       1568
       1568
       +
           font-weight: 600;

     

       1569
       1569
       +
           color: var(--secondary-color);

     

       1570
       1570
       +
       }

     

       1571
       1571
       +
       

     

       1572
       1572
       +
       .thread-entry {

     

       1573
       1573
       +
           padding: 0.5rem 0.75rem;

     

       1574
       1574
       +
           border-bottom: 1px solid var(--border-color);

     

       1575
       1575
       +
       }

     

       1576
       1576
       +
       

     

       1577
       1577
       +
       .thread-entry:last-child {

     

       1578
       1578
       +
           border-bottom: none;

     

       1579
       1579
       +
       }

     

       1580
       1580
       +
       

     

       1581
       1581
       +
       .thread-entry.reply {

     

       1582
       1582
       +
           margin-left: var(--thread-indent);

     

       1583
       1583
       +
           border-left: 3px solid var(--secondary-color);

     

       1584
       1584
       +
           background-color: var(--surface);

     

       1585
       1585
       +
       }

     

       1586
       1586
       +
       

     

       1587
       1587
       +
       /* Links Section */

     

       1588
       1588
       +
       .link-group {

     

       1589
       1589
       +
           background-color: var(--background);

     

       1590
       1590
       +
       }

     

       1591
       1591
       +
       

     

       1592
       1592
       +
       .link-url {

     

       1593
       1593
       +
           font-size: 1rem;

     

       1594
       1594
       +
           word-break: break-word;

     

       1595
       1595
       +
       }

     

       1596
       1596
       +
       

     

       1597
       1597
       +
       .link-url a {

     

       1598
       1598
       +
           color: var(--secondary-color);

     

       1599
       1599
       +
           text-decoration: none;

     

       1600
       1600
       +
       }

     

       1601
       1601
       +
       

     

       1602
       1602
       +
       .link-url a:hover {

     

       1603
       1603
       +
           text-decoration: underline;

     

       1604
       1604
       +
       }

     

       1605
       1605
       +
       

     

       1606
       1606
       +
       .target-user {

     

       1607
       1607
       +
           font-size: 0.9rem;

     

       1608
       1608
       +
           color: var(--text-secondary);

     

       1609
       1609
       +
           font-weight: normal;

     

       1610
       1610
       +
       }

     

       1611
       1611
       +
       

     

       1612
       1612
       +
       .referencing-entries {

     

       1613
       1613
       +
           margin-top: 0.75rem;

     

       1614
       1614
       +
       }

     

       1615
       1615
       +
       

     

       1616
       1616
       +
       .ref-count {

     

       1617
       1617
       +
           font-weight: 600;

     

       1618
       1618
       +
           color: var(--text-secondary);

     

       1619
       1619
       +
           font-size: 0.9rem;

     

       1620
       1620
       +
       }

     

       1621
       1621
       +
       

     

       1622
       1622
       +
       .referencing-entries ul {

     

       1623
       1623
       +
           list-style: none;

     

       1624
       1624
       +
           margin-top: 0.5rem;

     

       1625
       1625
       +
           padding-left: 1rem;

     

       1626
       1626
       +
       }

     

       1627
       1627
       +
       

     

       1628
       1628
       +
       .referencing-entries li {

     

       1629
       1629
       +
           margin-bottom: 0.25rem;

     

       1630
       1630
       +
           font-size: 0.9rem;

     

       1631
       1631
       +
       }

     

       1632
       1632
       +
       

     

       1633
       1633
       +
       .referencing-entries .more {

     

       1634
       1634
       +
           font-style: italic;

     

       1635
       1635
       +
           color: var(--text-secondary);

     

       1636
       1636
       +
       }

     

       1637
       1637
       +
       

     

       1638
       1638
       +
       /* Users Section */

     

       1639
       1639
       +
       .user-card {

     

       1640
       1640
       +
           background-color: var(--background);

     

       1641
       1641
       +
       }

     

       1642
       1642
       +
       

     

       1643
       1643
       +
       .user-header {

     

       1644
       1644
       +
           display: flex;

     

       1645
       1645
       +
           gap: 1rem;

     

       1646
       1646
       +
           align-items: start;

     

       1647
       1647
       +
           margin-bottom: 1rem;

     

       1648
       1648
       +
       }

     

       1649
       1649
       +
       

     

       1650
       1650
       +
       .user-icon {

     

       1651
       1651
       +
           width: 48px;

     

       1652
       1652
       +
           height: 48px;

     

       1653
       1653
       +
           border-radius: 50%;

     

       1654
       1654
       +
           object-fit: cover;

     

       1655
       1655
       +
       }

     

       1656
       1656
       +
       

     

       1657
       1657
       +
       .user-info h3 {

     

       1658
       1658
       +
           margin-bottom: 0.25rem;

     

       1659
       1659
       +
       }

     

       1660
       1660
       +
       

     

       1661
       1661
       +
       .username {

     

       1662
       1662
       +
           font-size: 0.9rem;

     

       1663
       1663
       +
           color: var(--text-secondary);

     

       1664
       1664
       +
           font-weight: normal;

     

       1665
       1665
       +
       }

     

       1666
       1666
       +
       

     

       1667
       1667
       +
       .user-meta {

     

       1668
       1668
       +
           font-size: 0.9rem;

     

       1669
       1669
       +
           color: var(--text-secondary);

     

       1670
       1670
       +
       }

     

       1671
       1671
       +
       

     

       1672
       1672
       +
       .user-meta a {

     

       1673
       1673
       +
           color: var(--secondary-color);

     

       1674
       1674
       +
           text-decoration: none;

     

       1675
       1675
       +
       }

     

       1676
       1676
       +
       

     

       1677
       1677
       +
       .user-meta a:hover {

     

       1678
       1678
       +
           text-decoration: underline;

     

       1679
       1679
       +
       }

     

       1680
       1680
       +
       

     

       1681
       1681
       +
       .separator {

     

       1682
       1682
       +
           margin: 0 0.5rem;

     

       1683
       1683
       +
       }

     

       1684
       1684
       +
       

     

       1685
       1685
       +
       .post-count {

     

       1686
       1686
       +
           font-weight: 600;

     

       1687
       1687
       +
       }

     

       1688
       1688
       +
       

     

       1689
       1689
       +
       .user-recent h4 {

     

       1690
       1690
       +
           font-size: 0.95rem;

     

       1691
       1691
       +
           margin-bottom: 0.5rem;

     

       1692
       1692
       +
           color: var(--text-secondary);

     

       1693
       1693
       +
       }

     

       1694
       1694
       +
       

     

       1695
       1695
       +
       .user-recent ul {

     

       1696
       1696
       +
           list-style: none;

     

       1697
       1697
       +
           padding-left: 0;

     

       1698
       1698
       +
       }

     

       1699
       1699
       +
       

     

       1700
       1700
       +
       .user-recent li {

     

       1701
       1701
       +
           margin-bottom: 0.25rem;

     

       1702
       1702
       +
           font-size: 0.9rem;

     

       1703
       1703
       +
       }

     

       1704
       1704
       +
       

     

       1705
       1705
       +
       /* Footer */

     

       1706
       1706
       +
       .site-footer {

     

       1707
       1707
       +
           max-width: var(--max-width);

     

       1708
       1708
       +
           margin: 3rem auto 2rem;

     

       1709
       1709
       +
           padding: 1rem 2rem;

     

       1710
       1710
       +
           text-align: center;

     

       1711
       1711
       +
           color: var(--text-secondary);

     

       1712
       1712
       +
           font-size: 0.85rem;

     

       1713
       1713
       +
           border-top: 1px solid var(--border-color);

     

       1714
       1714
       +
       }

     

       1715
       1715
       +
       

     

       1716
       1716
       +
       .site-footer a {

     

       1717
       1717
       +
           color: var(--secondary-color);

     

       1718
       1718
       +
           text-decoration: none;

     

       1719
       1719
       +
       }

     

       1720
       1720
       +
       

     

       1721
       1721
       +
       .site-footer a:hover {

     

       1722
       1722
       +
           text-decoration: underline;

     

       1723
       1723
       +
       }

     

       1724
       1724
       +
       

     

       1725
       1725
       +
       /* Responsive */

     

       1726
       1726
       +
       @media (max-width: 768px) {

     

       1727
       1727
       +
           .site-title {

     

       1728
       1728
       +
               font-size: 1.3rem;

     

       1729
       1729
       +
           }

     

       1730
       1730
       +
           

     

       1731
       1731
       +
           .header-content {

     

       1732
       1732
       +
               flex-direction: column;

     

       1733
       1733
       +
               gap: 0.75rem;

     

       1734
       1734
       +
               align-items: flex-start;

     

       1735
       1735
       +
           }

     

       1736
       1736
       +
           

     

       1737
       1737
       +
           .site-nav {

     

       1738
       1738
       +
               gap: 1rem;

     

       1739
       1739
       +
           }

     

       1740
       1740
       +
           

     

       1741
       1741
       +
           .main-content {

     

       1742
       1742
       +
               padding: 0 1rem;

     

       1743
       1743
       +
           }

     

       1744
       1744
       +
           

     

       1745
       1745
       +
           .thread-entry.reply {

     

       1746
       1746
       +
               margin-left: calc(var(--thread-indent) / 2);

     

       1747
       1747
       +
           }

     

       1748
       1748
       +
           

     

       1749
       1749
       +
           .user-header {

     

       1750
       1750
       +
               flex-direction: column;

     

       1751
       1751
       +
           }

     

       1752
       1752
       +
       }

     

       1753
       1753
       +
       </file>

     

       1754
       1754
       +
       

     

       1755
       1755
       +
       <file path="src/thicket/templates/timeline.html">

     

       1756
       1756
       +
       {% extends "base.html" %}

     

       1757
       1757
       +
       

     

       1758
       1758
       +
       {% block page_title %}Timeline - {{ title }}{% endblock %}

     

       1759
       1759
       +
       

     

       1760
       1760
       +
       {% block content %}

     

       1761
       1761
       +
       {% set seen_users = [] %}

     

       1762
       1762
       +
       <div class="page-content">

     

       1763
       1763
       +
           <h2>Recent Posts & Conversations</h2>

     

       1764
       1764
       +
           

     

       1765
       1765
       +
           <section class="unified-timeline">

     

       1766
       1766
       +
               {% for item in timeline_items %}

     

       1767
       1767
       +
                   {% if item.type == "post" %}

     

       1768
       1768
       +
                       <!-- Individual Post -->

     

       1769
       1769
       +
                       <article class="timeline-entry {% if item.content.references %}with-references{% endif %}">

     

       1770
       1770
       +
                           <div class="timeline-meta">

     

       1771
       1771
       +
                               <time datetime="{{ item.content.entry.updated or item.content.entry.published }}" class="timeline-time">

     

       1772
       1772
       +
                                   {{ (item.content.entry.updated or item.content.entry.published).strftime('%Y-%m-%d %H:%M') }}

     

       1773
       1773
       +
                               </time>

     

       1774
       1774
       +
                               {% set homepage = get_user_homepage(item.content.username) %}

     

       1775
       1775
       +
                               {% if item.content.username not in seen_users %}

     

       1776
       1776
       +
                               <a id="{{ item.content.username }}" class="user-anchor"></a>

     

       1777
       1777
       +
                               {% set _ = seen_users.append(item.content.username) %}

     

       1778
       1778
       +
                               {% endif %}

     

       1779
       1779
       +
                               <a id="post-{{ loop.index0 }}-{{ safe_anchor_id(item.content.entry.id) }}" class="post-anchor"></a>

     

       1780
       1780
       +
                               {% if homepage %}

     

       1781
       1781
       +
                               <a href="{{ homepage }}" target="_blank" class="timeline-author">{{ item.content.display_name }}</a>

     

       1782
       1782
       +
                               {% else %}

     

       1783
       1783
       +
                               <span class="timeline-author">{{ item.content.display_name }}</span>

     

       1784
       1784
       +
                               {% endif %}

     

       1785
       1785
       +
                               {% if item.content.references %}

     

       1786
       1786
       +
                               <div class="reference-badges">

     

       1787
       1787
       +
                                   {% for ref in item.content.references %}

     

       1788
       1788
       +
                                       {% if ref.type == 'outbound' %}

     

       1789
       1789
       +
                                       <span class="ref-badge ref-outbound" title="References {{ ref.target_username or 'external post' }}">

     

       1790
       1790
       +
                                           → {{ ref.target_username or 'ext' }}

     

       1791
       1791
       +
                                       </span>

     

       1792
       1792
       +
                                       {% elif ref.type == 'inbound' %}

     

       1793
       1793
       +
                                       <span class="ref-badge ref-inbound" title="Referenced by {{ ref.source_username or 'external post' }}">

     

       1794
       1794
       +
                                           ← {{ ref.source_username or 'ext' }}

     

       1795
       1795
       +
                                       </span>

     

       1796
       1796
       +
                                       {% endif %}

     

       1797
       1797
       +
                                   {% endfor %}

     

       1798
       1798
       +
                               </div>

     

       1799
       1799
       +
                               {% endif %}

     

       1800
       1800
       +
                           </div>

     

       1801
       1801
       +
                           <div class="timeline-content">

     

       1802
       1802
       +
                               <strong class="timeline-title">

     

       1803
       1803
       +
                                   <a href="{{ item.content.entry.link }}" target="_blank">{{ item.content.entry.title }}</a>

     

       1804
       1804
       +
                               </strong>

     

       1805
       1805
       +
                               {% if item.content.entry.summary %}

     

       1806
       1806
       +
                               <span class="timeline-summary">— {{ clean_html_summary(item.content.entry.summary, 250) }}</span>

     

       1807
       1807
       +
                               {% endif %}

     

       1808
       1808
       +
                               {% if item.content.shared_references %}

     

       1809
       1809
       +
                               <span class="inline-shared-refs">

     

       1810
       1810
       +
                                   {% for ref in item.content.shared_references[:3] %}

     

       1811
       1811
       +
                                   {% if ref.target_username %}

     

       1812
       1812
       +
                                   <a href="#{{ ref.target_username }}" class="shared-ref-link" title="Referenced by {{ ref.count }} entries">@{{ ref.target_username }}</a>{% if not loop.last %}, {% endif %}

     

       1813
       1813
       +
                                   {% endif %}

     

       1814
       1814
       +
                                   {% endfor %}

     

       1815
       1815
       +
                                   {% if item.content.shared_references|length > 3 %}

     

       1816
       1816
       +
                                   <span class="shared-ref-more">+{{ item.content.shared_references|length - 3 }} more</span>

     

       1817
       1817
       +
                                   {% endif %}

     

       1818
       1818
       +
                               </span>

     

       1819
       1819
       +
                               {% endif %}

     

       1820
       1820
       +
                               {% if item.content.cross_thread_links %}

     

       1821
       1821
       +
                               <div class="cross-thread-links">

     

       1822
       1822
       +
                                   <span class="cross-thread-indicator">🔗 Also appears: </span>

     

       1823
       1823
       +
                                   {% for link in item.content.cross_thread_links %}

     

       1824
       1824
       +
                                   <a href="#{{ link.anchor_id }}" class="cross-thread-link" title="{{ link.title }}">{{ link.context }}</a>{% if not loop.last %}, {% endif %}

     

       1825
       1825
       +
                                   {% endfor %}

     

       1826
       1826
       +
                               </div>

     

       1827
       1827
       +
                               {% endif %}

     

       1828
       1828
       +
                           </div>

     

       1829
       1829
       +
                       </article>

     

       1830
       1830
       +
                   

     

       1831
       1831
       +
                   {% elif item.type == "thread" %}

     

       1832
       1832
       +
                       <!-- Conversation Thread -->

     

       1833
       1833
       +
                       {% set outer_loop_index = loop.index0 %}

     

       1834
       1834
       +
                       {% for thread_item in item.content %}

     

       1835
       1835
       +
                       <article class="timeline-entry conversation-post level-{{ thread_item.thread_level }}">

     

       1836
       1836
       +
                           <div class="timeline-meta">

     

       1837
       1837
       +
                               <time datetime="{{ thread_item.entry.updated or thread_item.entry.published }}" class="timeline-time">

     

       1838
       1838
       +
                                   {{ (thread_item.entry.updated or thread_item.entry.published).strftime('%Y-%m-%d %H:%M') }}

     

       1839
       1839
       +
                               </time>

     

       1840
       1840
       +
                               {% set homepage = get_user_homepage(thread_item.username) %}

     

       1841
       1841
       +
                               {% if thread_item.username not in seen_users %}

     

       1842
       1842
       +
                               <a id="{{ thread_item.username }}" class="user-anchor"></a>

     

       1843
       1843
       +
                               {% set _ = seen_users.append(thread_item.username) %}

     

       1844
       1844
       +
                               {% endif %}

     

       1845
       1845
       +
                               <a id="post-{{ outer_loop_index }}-{{ loop.index0 }}-{{ safe_anchor_id(thread_item.entry.id) }}" class="post-anchor"></a>

     

       1846
       1846
       +
                               {% if homepage %}

     

       1847
       1847
       +
                               <a href="{{ homepage }}" target="_blank" class="timeline-author author-{{ thread_item.username }}">{{ thread_item.display_name }}</a>

     

       1848
       1848
       +
                               {% else %}

     

       1849
       1849
       +
                               <span class="timeline-author author-{{ thread_item.username }}">{{ thread_item.display_name }}</span>

     

       1850
       1850
       +
                               {% endif %}

     

       1851
       1851
       +
                               {% if thread_item.references_to or thread_item.referenced_by %}

     

       1852
       1852
       +
                               <span class="reference-indicators">

     

       1853
       1853
       +
                                   {% if thread_item.references_to %}

     

       1854
       1854
       +
                                   <span class="ref-out" title="References other posts">→</span>

     

       1855
       1855
       +
                                   {% endif %}

     

       1856
       1856
       +
                                   {% if thread_item.referenced_by %}

     

       1857
       1857
       +
                                   <span class="ref-in" title="Referenced by other posts">←</span>

     

       1858
       1858
       +
                                   {% endif %}

     

       1859
       1859
       +
                               </span>

     

       1860
       1860
       +
                               {% endif %}

     

       1861
       1861
       +
                           </div>

     

       1862
       1862
       +
                           <div class="timeline-content">

     

       1863
       1863
       +
                               <strong class="timeline-title">

     

       1864
       1864
       +
                                   <a href="{{ thread_item.entry.link }}" target="_blank">{{ thread_item.entry.title }}</a>

     

       1865
       1865
       +
                               </strong>

     

       1866
       1866
       +
                               {% if thread_item.entry.summary %}

     

       1867
       1867
       +
                               <span class="timeline-summary">— {{ clean_html_summary(thread_item.entry.summary, 300) }}</span>

     

       1868
       1868
       +
                               {% endif %}

     

       1869
       1869
       +
                               {% if thread_item.shared_references %}

     

       1870
       1870
       +
                               <span class="inline-shared-refs">

     

       1871
       1871
       +
                                   {% for ref in thread_item.shared_references[:3] %}

     

       1872
       1872
       +
                                   {% if ref.target_username %}

     

       1873
       1873
       +
                                   <a href="#{{ ref.target_username }}" class="shared-ref-link" title="Referenced by {{ ref.count }} entries">@{{ ref.target_username }}</a>{% if not loop.last %}, {% endif %}

     

       1874
       1874
       +
                                   {% endif %}

     

       1875
       1875
       +
                                   {% endfor %}

     

       1876
       1876
       +
                                   {% if thread_item.shared_references|length > 3 %}

     

       1877
       1877
       +
                                   <span class="shared-ref-more">+{{ thread_item.shared_references|length - 3 }} more</span>

     

       1878
       1878
       +
                                   {% endif %}

     

       1879
       1879
       +
                               </span>

     

       1880
       1880
       +
                               {% endif %}

     

       1881
       1881
       +
                               {% if thread_item.cross_thread_links %}

     

       1882
       1882
       +
                               <div class="cross-thread-links">

     

       1883
       1883
       +
                                   <span class="cross-thread-indicator">🔗 Also appears: </span>

     

       1884
       1884
       +
                                   {% for link in thread_item.cross_thread_links %}

     

       1885
       1885
       +
                                   <a href="#{{ link.anchor_id }}" class="cross-thread-link" title="{{ link.title }}">{{ link.context }}</a>{% if not loop.last %}, {% endif %}

     

       1886
       1886
       +
                                   {% endfor %}

     

       1887
       1887
       +
                               </div>

     

       1888
       1888
       +
                               {% endif %}

     

       1889
       1889
       +
                           </div>

     

       1890
       1890
       +
                       </article>

     

       1891
       1891
       +
                       {% endfor %}

     

       1892
       1892
       +
                   {% endif %}

     

       1893
       1893
       +
               {% endfor %}

     

       1894
       1894
       +
           </section>

     

       1895
       1895
       +
       </div>

     

       1896
       1896
       +
       {% endblock %}

     

       1897
       1897
       +
       </file>

     

       1898
       1898
       +
       

     

       1899
       1899
       +
       <file path="src/thicket/templates/users.html">

     

       1900
       1900
       +
       {% extends "base.html" %}

     

       1901
       1901
       +
       

     

       1902
       1902
       +
       {% block page_title %}Users - {{ title }}{% endblock %}

     

       1903
       1903
       +
       

     

       1904
       1904
       +
       {% block content %}

     

       1905
       1905
       +
       <div class="page-content">

     

       1906
       1906
       +
           <h2>Users</h2>

     

       1907
       1907
       +
           <p class="page-description">All users contributing to this thicket, ordered by post count.</p>

     

       1908
       1908
       +
           

     

       1909
       1909
       +
           {% for user_info in users %}

     

       1910
       1910
       +
           <article class="user-card">

     

       1911
       1911
       +
               <div class="user-header">

     

       1912
       1912
       +
                   {% if user_info.metadata.icon and user_info.metadata.icon != "None" %}

     

       1913
       1913
       +
                   <img src="{{ user_info.metadata.icon }}" alt="{{ user_info.metadata.username }}" class="user-icon">

     

       1914
       1914
       +
                   {% endif %}

     

       1915
       1915
       +
                   <div class="user-info">

     

       1916
       1916
       +
                       <h3>

     

       1917
       1917
       +
                           {% if user_info.metadata.display_name %}

     

       1918
       1918
       +
                               {{ user_info.metadata.display_name }}

     

       1919
       1919
       +
                               <span class="username">({{ user_info.metadata.username }})</span>

     

       1920
       1920
       +
                           {% else %}

     

       1921
       1921
       +
                               {{ user_info.metadata.username }}

     

       1922
       1922
       +
                           {% endif %}

     

       1923
       1923
       +
                       </h3>

     

       1924
       1924
       +
                       <div class="user-meta">

     

       1925
       1925
       +
                           {% if user_info.metadata.homepage %}

     

       1926
       1926
       +
                           <a href="{{ user_info.metadata.homepage }}" target="_blank">{{ user_info.metadata.homepage }}</a>

     

       1927
       1927
       +
                           {% endif %}

     

       1928
       1928
       +
                           {% if user_info.metadata.email %}

     

       1929
       1929
       +
                           <span class="separator">•</span>

     

       1930
       1930
       +
                           <a href="mailto:{{ user_info.metadata.email }}">{{ user_info.metadata.email }}</a>

     

       1931
       1931
       +
                           {% endif %}

     

       1932
       1932
       +
                           <span class="separator">•</span>

     

       1933
       1933
       +
                           <span class="post-count">{{ user_info.metadata.entry_count }} posts</span>

     

       1934
       1934
       +
                       </div>

     

       1935
       1935
       +
                   </div>

     

       1936
       1936
       +
               </div>

     

       1937
       1937
       +
               

     

       1938
       1938
       +
               {% if user_info.recent_entries %}

     

       1939
       1939
       +
               <div class="user-recent">

     

       1940
       1940
       +
                   <h4>Recent posts:</h4>

     

       1941
       1941
       +
                   <ul>

     

       1942
       1942
       +
                       {% for display_name, entry in user_info.recent_entries %}

     

       1943
       1943
       +
                       <li>

     

       1944
       1944
       +
                           <a href="{{ entry.link }}" target="_blank">{{ entry.title }}</a>

     

       1945
       1945
       +
                           <time datetime="{{ entry.updated or entry.published }}">

     

       1946
       1946
       +
                               ({{ (entry.updated or entry.published).strftime('%Y-%m-%d') }})

     

       1947
       1947
       +
                           </time>

     

       1948
       1948
       +
                       </li>

     

       1949
       1949
       +
                       {% endfor %}

     

       1950
       1950
       +
                   </ul>

     

       1951
       1951
       +
               </div>

     

       1952
       1952
       +
               {% endif %}

     

       1953
       1953
       +
           </article>

     

       1954
       1954
       +
           {% endfor %}

     

       1955
       1955
       +
       </div>

     

       1956
       1956
       +
       {% endblock %}

     

       1957
       1957
       +
       </file>

     

       1958
       1958
       +
       

     

       1959
       1959
       +
       <file path="README.md">

     

       1960
       1960
       +
       # Thicket

     

       1961
       1961
       +
       

     

       1962
       1962
       +
       A modern CLI tool for persisting Atom/RSS feeds in Git repositories, designed to enable distributed webblog comment structures.

     

       1963
       1963
       +
       

     

       1964
       1964
       +
       ## Features

     

       1965
       1965
       +
       

     

       1966
       1966
       +
       - **Feed Auto-Discovery**: Automatically extracts user metadata from Atom/RSS feeds

     

       1967
       1967
       +
       - **Git Storage**: Stores feed entries in a Git repository with full history

     

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

     

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

     

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

     

       1971
       1971
       +
       - **Cron-Friendly**: Designed for scheduled execution

     

       1972
       1972
       +
       

     

       1973
       1973
       +
       ## Installation

     

       1974
       1974
       +
       

     

       1975
       1975
       +
       ```bash

     

       1976
       1976
       +
       # Install from source

     

       1977
       1977
       +
       pip install -e .

     

       1978
       1978
       +
       

     

       1979
       1979
       +
       # Or install with dev dependencies

     

       1980
       1980
       +
       pip install -e .[dev]

     

       1981
       1981
       +
       ```

     

       1982
       1982
       +
       

     

       1983
       1983
       +
       ## Quick Start

     

       1984
       1984
       +
       

     

       1985
       1985
       +
       1. **Initialize a new thicket repository:**

     

       1986
       1986
       +
       ```bash

     

       1987
       1987
       +
       thicket init ./my-feeds

     

       1988
       1988
       +
       ```

     

       1989
       1989
       +
       

     

       1990
       1990
       +
       2. **Add a user with their feed:**

     

       1991
       1991
       +
       ```bash

     

       1992
       1992
       +
       thicket add user "alice" --feed "https://alice.example.com/feed.xml"

     

       1993
       1993
       +
       ```

     

       1994
       1994
       +
       

     

       1995
       1995
       +
       3. **Sync feeds to download entries:**

     

       1996
       1996
       +
       ```bash

     

       1997
       1997
       +
       thicket sync --all

     

       1998
       1998
       +
       ```

     

       1999
       1999
       +
       

     

       2000
       2000
       +
       4. **List users and feeds:**

     

       2001
       2001
       +
       ```bash

     

       2002
       2002
       +
       thicket list users

     

       2003
       2003
       +
       thicket list feeds

     

       2004
       2004
       +
       thicket list entries

     

       2005
       2005
       +
       ```

     

       2006
       2006
       +
       

     

       2007
       2007
       +
       ## Commands

     

       2008
       2008
       +
       

     

       2009
       2009
       +
       ### Initialize

     

       2010
       2010
       +
       ```bash

     

       2011
       2011
       +
       thicket init <git-store-path> [--cache-dir <path>] [--config <config-file>]

     

       2012
       2012
       +
       ```

     

       2013
       2013
       +
       

     

       2014
       2014
       +
       ### Add Users and Feeds

     

       2015
       2015
       +
       ```bash

     

       2016
       2016
       +
       # Add user with auto-discovery

     

       2017
       2017
       +
       thicket add user "username" --feed "https://example.com/feed.xml"

     

       2018
       2018
       +
       

     

       2019
       2019
       +
       # Add user with manual metadata

     

       2020
       2020
       +
       thicket add user "username" \

     

       2021
       2021
       +
         --feed "https://example.com/feed.xml" \

     

       2022
       2022
       +
         --email "user@example.com" \

     

       2023
       2023
       +
         --homepage "https://example.com" \

     

       2024
       2024
       +
         --display-name "User Name"

     

       2025
       2025
       +
       

     

       2026
       2026
       +
       # Add additional feed to existing user

     

       2027
       2027
       +
       thicket add feed "username" "https://example.com/other-feed.xml"

     

       2028
       2028
       +
       ```

     

       2029
       2029
       +
       

     

       2030
       2030
       +
       ### Sync Feeds

     

       2031
       2031
       +
       ```bash

     

       2032
       2032
       +
       # Sync all users

     

       2033
       2033
       +
       thicket sync --all

     

       2034
       2034
       +
       

     

       2035
       2035
       +
       # Sync specific user

     

       2036
       2036
       +
       thicket sync --user "username"

     

       2037
       2037
       +
       

     

       2038
       2038
       +
       # Dry run (preview changes)

     

       2039
       2039
       +
       thicket sync --all --dry-run

     

       2040
       2040
       +
       ```

     

       2041
       2041
       +
       

     

       2042
       2042
       +
       ### List Information

     

       2043
       2043
       +
       ```bash

     

       2044
       2044
       +
       # List all users

     

       2045
       2045
       +
       thicket list users

     

       2046
       2046
       +
       

     

       2047
       2047
       +
       # List all feeds

     

       2048
       2048
       +
       thicket list feeds

     

       2049
       2049
       +
       

     

       2050
       2050
       +
       # List feeds for specific user

     

       2051
       2051
       +
       thicket list feeds --user "username"

     

       2052
       2052
       +
       

     

       2053
       2053
       +
       # List recent entries

     

       2054
       2054
       +
       thicket list entries --limit 20

     

       2055
       2055
       +
       

     

       2056
       2056
       +
       # List entries for specific user

     

       2057
       2057
       +
       thicket list entries --user "username"

     

       2058
       2058
       +
       ```

     

       2059
       2059
       +
       

     

       2060
       2060
       +
       ### Manage Duplicates

     

       2061
       2061
       +
       ```bash

     

       2062
       2062
       +
       # List duplicate mappings

     

       2063
       2063
       +
       thicket duplicates list

     

       2064
       2064
       +
       

     

       2065
       2065
       +
       # Mark entries as duplicates

     

       2066
       2066
       +
       thicket duplicates add "https://example.com/dup" "https://example.com/canonical"

     

       2067
       2067
       +
       

     

       2068
       2068
       +
       # Remove duplicate mapping

     

       2069
       2069
       +
       thicket duplicates remove "https://example.com/dup"

     

       2070
       2070
       +
       ```

     

       2071
       2071
       +
       

     

       2072
       2072
       +
       ## Configuration

     

       2073
       2073
       +
       

     

       2074
       2074
       +
       Thicket uses a YAML configuration file (default: `thicket.yaml`):

     

       2075
       2075
       +
       

     

       2076
       2076
       +
       ```yaml

     

       2077
       2077
       +
       git_store: ./feeds-repo

     

       2078
       2078
       +
       cache_dir: ~/.cache/thicket

     

       2079
       2079
       +
       users:

     

       2080
       2080
       +
         - username: alice

     

       2081
       2081
       +
           feeds:

     

       2082
       2082
       +
             - https://alice.example.com/feed.xml

     

       2083
       2083
       +
           email: alice@example.com

     

       2084
       2084
       +
           homepage: https://alice.example.com

     

       2085
       2085
       +
           display_name: Alice

     

       2086
       2086
       +
       ```

     

       2087
       2087
       +
       

     

       2088
       2088
       +
       ## Git Repository Structure

     

       2089
       2089
       +
       

     

       2090
       2090
       +
       ```

     

       2091
       2091
       +
       feeds-repo/

     

       2092
       2092
       +
       ├── index.json              # User directory index

     

       2093
       2093
       +
       ├── duplicates.json         # Duplicate entry mappings

     

       2094
       2094
       +
       ├── alice/

     

       2095
       2095
       +
       │   ├── metadata.json       # User metadata

     

       2096
       2096
       +
       │   ├── entry_id_1.json     # Feed entries

     

       2097
       2097
       +
       │   └── entry_id_2.json

     

       2098
       2098
       +
       └── bob/

     

       2099
       2099
       +
           └── ...

     

       2100
       2100
       +
       ```

     

       2101
       2101
       +
       

     

       2102
       2102
       +
       ## Development

     

       2103
       2103
       +
       

     

       2104
       2104
       +
       ### Setup

     

       2105
       2105
       +
       ```bash

     

       2106
       2106
       +
       # Install in development mode

     

       2107
       2107
       +
       pip install -e .[dev]

     

       2108
       2108
       +
       

     

       2109
       2109
       +
       # Run tests

     

       2110
       2110
       +
       pytest

     

       2111
       2111
       +
       

     

       2112
       2112
       +
       # Run linting

     

       2113
       2113
       +
       ruff check src/

     

       2114
       2114
       +
       black --check src/

     

       2115
       2115
       +
       

     

       2116
       2116
       +
       # Run type checking

     

       2117
       2117
       +
       mypy src/

     

       2118
       2118
       +
       ```

     

       2119
       2119
       +
       

     

       2120
       2120
       +
       ### Architecture

     

       2121
       2121
       +
       

     

       2122
       2122
       +
       - **CLI**: Modern interface with Typer and Rich

     

       2123
       2123
       +
       - **Feed Processing**: Universal parsing with feedparser

     

       2124
       2124
       +
       - **Git Storage**: Structured storage with GitPython

     

       2125
       2125
       +
       - **Data Models**: Pydantic for validation and serialization

     

       2126
       2126
       +
       - **Async HTTP**: httpx for efficient feed fetching

     

       2127
       2127
       +
       

     

       2128
       2128
       +
       ## Use Cases

     

       2129
       2129
       +
       

     

       2130
       2130
       +
       - **Blog Aggregation**: Collect and archive blog posts from multiple sources

     

       2131
       2131
       +
       - **Comment Networks**: Enable distributed commenting systems

     

       2132
       2132
       +
       - **Feed Archival**: Preserve feed history beyond typical feed depth limits

     

       2133
       2133
       +
       - **Content Curation**: Manage and deduplicate content across feeds

     

       2134
       2134
       +
       

     

       2135
       2135
       +
       ## License

     

       2136
       2136
       +
       

     

       2137
       2137
       +
       MIT License - see LICENSE file for details.

     

       2138
       2138
       +
       </file>

     

       2139
       2139
       +
       

     

       2140
       2140
       +
       <file path="src/thicket/cli/commands/index_cmd.py">

     

       2141
       2141
       +
       """CLI command for building reference index from blog entries."""

     

       2142
       2142
       +
       

     

       2143
       2143
       +
       import json

     

       2144
       2144
       +
       from pathlib import Path

     

       2145
       2145
       +
       from typing import Optional

     

       2146
       2146
       +
       

     

       2147
       2147
       +
       import typer

     

       2148
       2148
       +
       from rich.console import Console

     

       2149
       2149
       +
       from rich.progress import (

     

       2150
       2150
       +
           BarColumn,

     

       2151
       2151
       +
           Progress,

     

       2152
       2152
       +
           SpinnerColumn,

     

       2153
       2153
       +
           TaskProgressColumn,

     

       2154
       2154
       +
           TextColumn,

     

       2155
       2155
       +
       )

     

       2156
       2156
       +
       from rich.table import Table

     

       2157
       2157
       +
       

     

       2158
       2158
       +
       from ...core.git_store import GitStore

     

       2159
       2159
       +
       from ...core.reference_parser import ReferenceIndex, ReferenceParser

     

       2160
       2160
       +
       from ..main import app

     

       2161
       2161
       +
       from ..utils import get_tsv_mode, load_config

     

       2162
       2162
       +
       

     

       2163
       2163
       +
       console = Console()

     

       2164
       2164
       +
       

     

       2165
       2165
       +
       

     

       2166
       2166
       +
       @app.command()

     

       2167
       2167
       +
       def index(

     

       2168
       2168
       +
           config_file: Optional[Path] = typer.Option(

     

       2169
       2169
       +
               None,

     

       2170
       2170
       +
               "--config",

     

       2171
       2171
       +
               "-c",

     

       2172
       2172
       +
               help="Path to configuration file",

     

       2173
       2173
       +
           ),

     

       2174
       2174
       +
           output_file: Optional[Path] = typer.Option(

     

       2175
       2175
       +
               None,

     

       2176
       2176
       +
               "--output",

     

       2177
       2177
       +
               "-o",

     

       2178
       2178
       +
               help="Path to output index file (default: updates links.json in git store)",

     

       2179
       2179
       +
           ),

     

       2180
       2180
       +
           verbose: bool = typer.Option(

     

       2181
       2181
       +
               False,

     

       2182
       2182
       +
               "--verbose",

     

       2183
       2183
       +
               "-v",

     

       2184
       2184
       +
               help="Show detailed progress information",

     

       2185
       2185
       +
           ),

     

       2186
       2186
       +
       ) -> None:

     

       2187
       2187
       +
           """Build a reference index showing which blog entries reference others.

     

       2188
       2188
       +
       

     

       2189
       2189
       +
           This command analyzes all blog entries to detect cross-references between

     

       2190
       2190
       +
           different blogs, creating an index that can be used to build threaded

     

       2191
       2191
       +
           views of related content.

     

       2192
       2192
       +
           

     

       2193
       2193
       +
           Updates the unified links.json file with reference data.

     

       2194
       2194
       +
           """

     

       2195
       2195
       +
           try:

     

       2196
       2196
       +
               # Load configuration

     

       2197
       2197
       +
               config = load_config(config_file)

     

       2198
       2198
       +
       

     

       2199
       2199
       +
               # Initialize Git store

     

       2200
       2200
       +
               git_store = GitStore(config.git_store)

     

       2201
       2201
       +
       

     

       2202
       2202
       +
               # Initialize reference parser

     

       2203
       2203
       +
               parser = ReferenceParser()

     

       2204
       2204
       +
       

     

       2205
       2205
       +
               # Build user domain mapping

     

       2206
       2206
       +
               if verbose:

     

       2207
       2207
       +
                   console.print("Building user domain mapping...")

     

       2208
       2208
       +
               user_domains = parser.build_user_domain_mapping(git_store)

     

       2209
       2209
       +
       

     

       2210
       2210
       +
               if verbose:

     

       2211
       2211
       +
                   console.print(f"Found {len(user_domains)} users with {sum(len(d) for d in user_domains.values())} total domains")

     

       2212
       2212
       +
       

     

       2213
       2213
       +
               # Initialize reference index

     

       2214
       2214
       +
               ref_index = ReferenceIndex()

     

       2215
       2215
       +
               ref_index.user_domains = user_domains

     

       2216
       2216
       +
       

     

       2217
       2217
       +
               # Get all users

     

       2218
       2218
       +
               index = git_store._load_index()

     

       2219
       2219
       +
               users = list(index.users.keys())

     

       2220
       2220
       +
       

     

       2221
       2221
       +
               if not users:

     

       2222
       2222
       +
                   console.print("[yellow]No users found in Git store[/yellow]")

     

       2223
       2223
       +
                   raise typer.Exit(0)

     

       2224
       2224
       +
       

     

       2225
       2225
       +
               # Process all entries

     

       2226
       2226
       +
               total_entries = 0

     

       2227
       2227
       +
               total_references = 0

     

       2228
       2228
       +
               all_references = []

     

       2229
       2229
       +
       

     

       2230
       2230
       +
               with Progress(

     

       2231
       2231
       +
                   SpinnerColumn(),

     

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

     

       2233
       2233
       +
                   BarColumn(),

     

       2234
       2234
       +
                   TaskProgressColumn(),

     

       2235
       2235
       +
                   console=console,

     

       2236
       2236
       +
               ) as progress:

     

       2237
       2237
       +
       

     

       2238
       2238
       +
                   # Count total entries first

     

       2239
       2239
       +
                   counting_task = progress.add_task("Counting entries...", total=len(users))

     

       2240
       2240
       +
                   entry_counts = {}

     

       2241
       2241
       +
                   for username in users:

     

       2242
       2242
       +
                       entries = git_store.list_entries(username)

     

       2243
       2243
       +
                       entry_counts[username] = len(entries)

     

       2244
       2244
       +
                       total_entries += len(entries)

     

       2245
       2245
       +
                       progress.advance(counting_task)

     

       2246
       2246
       +
       

     

       2247
       2247
       +
                   progress.remove_task(counting_task)

     

       2248
       2248
       +
       

     

       2249
       2249
       +
                   # Process entries - extract references

     

       2250
       2250
       +
                   processing_task = progress.add_task(

     

       2251
       2251
       +
                       f"Extracting references from {total_entries} entries...",

     

       2252
       2252
       +
                       total=total_entries

     

       2253
       2253
       +
                   )

     

       2254
       2254
       +
       

     

       2255
       2255
       +
                   for username in users:

     

       2256
       2256
       +
                       entries = git_store.list_entries(username)

     

       2257
       2257
       +
       

     

       2258
       2258
       +
                       for entry in entries:

     

       2259
       2259
       +
                           # Extract references from this entry

     

       2260
       2260
       +
                           references = parser.extract_references(entry, username, user_domains)

     

       2261
       2261
       +
                           all_references.extend(references)

     

       2262
       2262
       +
       

     

       2263
       2263
       +
                           progress.advance(processing_task)

     

       2264
       2264
       +
       

     

       2265
       2265
       +
                           if verbose and references:

     

       2266
       2266
       +
                               console.print(f"  Found {len(references)} references in {username}:{entry.title[:50]}...")

     

       2267
       2267
       +
       

     

       2268
       2268
       +
                   progress.remove_task(processing_task)

     

       2269
       2269
       +
       

     

       2270
       2270
       +
                   # Resolve target_entry_ids for references

     

       2271
       2271
       +
                   if all_references:

     

       2272
       2272
       +
                       resolve_task = progress.add_task(

     

       2273
       2273
       +
                           f"Resolving {len(all_references)} references...",

     

       2274
       2274
       +
                           total=len(all_references)

     

       2275
       2275
       +
                       )

     

       2276
       2276
       +
       

     

       2277
       2277
       +
                       if verbose:

     

       2278
       2278
       +
                           console.print(f"Resolving target entry IDs for {len(all_references)} references...")

     

       2279
       2279
       +
       

     

       2280
       2280
       +
                       resolved_references = parser.resolve_target_entry_ids(all_references, git_store)

     

       2281
       2281
       +
       

     

       2282
       2282
       +
                       # Count resolved references

     

       2283
       2283
       +
                       resolved_count = sum(1 for ref in resolved_references if ref.target_entry_id is not None)

     

       2284
       2284
       +
                       if verbose:

     

       2285
       2285
       +
                           console.print(f"Resolved {resolved_count} out of {len(all_references)} references")

     

       2286
       2286
       +
       

     

       2287
       2287
       +
                       # Add resolved references to index

     

       2288
       2288
       +
                       for ref in resolved_references:

     

       2289
       2289
       +
                           ref_index.add_reference(ref)

     

       2290
       2290
       +
                           total_references += 1

     

       2291
       2291
       +
                           progress.advance(resolve_task)

     

       2292
       2292
       +
       

     

       2293
       2293
       +
                       progress.remove_task(resolve_task)

     

       2294
       2294
       +
       

     

       2295
       2295
       +
               # Determine output path

     

       2296
       2296
       +
               if output_file:

     

       2297
       2297
       +
                   output_path = output_file

     

       2298
       2298
       +
               else:

     

       2299
       2299
       +
                   output_path = config.git_store / "links.json"

     

       2300
       2300
       +
       

     

       2301
       2301
       +
               # Load existing links data or create new structure

     

       2302
       2302
       +
               if output_path.exists() and not output_file:

     

       2303
       2303
       +
                   # Load existing unified structure

     

       2304
       2304
       +
                   with open(output_path) as f:

     

       2305
       2305
       +
                       existing_data = json.load(f)

     

       2306
       2306
       +
               else:

     

       2307
       2307
       +
                   # Create new structure

     

       2308
       2308
       +
                   existing_data = {

     

       2309
       2309
       +
                       "links": {},

     

       2310
       2310
       +
                       "reverse_mapping": {},

     

       2311
       2311
       +
                       "user_domains": {}

     

       2312
       2312
       +
                   }

     

       2313
       2313
       +
               

     

       2314
       2314
       +
               # Update with reference data

     

       2315
       2315
       +
               existing_data["references"] = ref_index.to_dict()["references"]

     

       2316
       2316
       +
               existing_data["user_domains"] = {k: list(v) for k, v in user_domains.items()}

     

       2317
       2317
       +
       

     

       2318
       2318
       +
               # Save updated structure

     

       2319
       2319
       +
               with open(output_path, "w") as f:

     

       2320
       2320
       +
                   json.dump(existing_data, f, indent=2, default=str)

     

       2321
       2321
       +
       

     

       2322
       2322
       +
               # Show summary

     

       2323
       2323
       +
               if not get_tsv_mode():

     

       2324
       2324
       +
                   console.print("\n[green]✓ Reference index built successfully[/green]")

     

       2325
       2325
       +
       

     

       2326
       2326
       +
               # Create summary table or TSV output

     

       2327
       2327
       +
               if get_tsv_mode():

     

       2328
       2328
       +
                   print("Metric\tCount")

     

       2329
       2329
       +
                   print(f"Total Users\t{len(users)}")

     

       2330
       2330
       +
                   print(f"Total Entries\t{total_entries}")

     

       2331
       2331
       +
                   print(f"Total References\t{total_references}")

     

       2332
       2332
       +
                   print(f"Outbound Refs\t{len(ref_index.outbound_refs)}")

     

       2333
       2333
       +
                   print(f"Inbound Refs\t{len(ref_index.inbound_refs)}")

     

       2334
       2334
       +
                   print(f"Output File\t{output_path}")

     

       2335
       2335
       +
               else:

     

       2336
       2336
       +
                   table = Table(title="Reference Index Summary")

     

       2337
       2337
       +
                   table.add_column("Metric", style="cyan")

     

       2338
       2338
       +
                   table.add_column("Count", style="green")

     

       2339
       2339
       +
       

     

       2340
       2340
       +
                   table.add_row("Total Users", str(len(users)))

     

       2341
       2341
       +
                   table.add_row("Total Entries", str(total_entries))

     

       2342
       2342
       +
                   table.add_row("Total References", str(total_references))

     

       2343
       2343
       +
                   table.add_row("Outbound Refs", str(len(ref_index.outbound_refs)))

     

       2344
       2344
       +
                   table.add_row("Inbound Refs", str(len(ref_index.inbound_refs)))

     

       2345
       2345
       +
                   table.add_row("Output File", str(output_path))

     

       2346
       2346
       +
       

     

       2347
       2347
       +
                   console.print(table)

     

       2348
       2348
       +
       

     

       2349
       2349
       +
               # Show some interesting statistics

     

       2350
       2350
       +
               if total_references > 0:

     

       2351
       2351
       +
                   if not get_tsv_mode():

     

       2352
       2352
       +
                       console.print("\n[bold]Reference Statistics:[/bold]")

     

       2353
       2353
       +
       

     

       2354
       2354
       +
                   # Most referenced users

     

       2355
       2355
       +
                   target_counts = {}

     

       2356
       2356
       +
                   unresolved_domains = set()

     

       2357
       2357
       +
       

     

       2358
       2358
       +
                   for ref in ref_index.references:

     

       2359
       2359
       +
                       if ref.target_username:

     

       2360
       2360
       +
                           target_counts[ref.target_username] = target_counts.get(ref.target_username, 0) + 1

     

       2361
       2361
       +
                       else:

     

       2362
       2362
       +
                           # Track unresolved domains

     

       2363
       2363
       +
                           from urllib.parse import urlparse

     

       2364
       2364
       +
                           domain = urlparse(ref.target_url).netloc.lower()

     

       2365
       2365
       +
                           unresolved_domains.add(domain)

     

       2366
       2366
       +
       

     

       2367
       2367
       +
                   if target_counts:

     

       2368
       2368
       +
                       if get_tsv_mode():

     

       2369
       2369
       +
                           print("Referenced User\tReference Count")

     

       2370
       2370
       +
                           for username, count in sorted(target_counts.items(), key=lambda x: x[1], reverse=True)[:5]:

     

       2371
       2371
       +
                               print(f"{username}\t{count}")

     

       2372
       2372
       +
                       else:

     

       2373
       2373
       +
                           console.print("\nMost referenced users:")

     

       2374
       2374
       +
                           for username, count in sorted(target_counts.items(), key=lambda x: x[1], reverse=True)[:5]:

     

       2375
       2375
       +
                               console.print(f"  {username}: {count} references")

     

       2376
       2376
       +
       

     

       2377
       2377
       +
                   if unresolved_domains and verbose:

     

       2378
       2378
       +
                       if get_tsv_mode():

     

       2379
       2379
       +
                           print("Unresolved Domain\tCount")

     

       2380
       2380
       +
                           for domain in sorted(list(unresolved_domains)[:10]):

     

       2381
       2381
       +
                               print(f"{domain}\t1")

     

       2382
       2382
       +
                           if len(unresolved_domains) > 10:

     

       2383
       2383
       +
                               print(f"... and {len(unresolved_domains) - 10} more\t...")

     

       2384
       2384
       +
                       else:

     

       2385
       2385
       +
                           console.print(f"\nUnresolved domains: {len(unresolved_domains)}")

     

       2386
       2386
       +
                           for domain in sorted(list(unresolved_domains)[:10]):

     

       2387
       2387
       +
                               console.print(f"  {domain}")

     

       2388
       2388
       +
                           if len(unresolved_domains) > 10:

     

       2389
       2389
       +
                               console.print(f"  ... and {len(unresolved_domains) - 10} more")

     

       2390
       2390
       +
       

     

       2391
       2391
       +
           except Exception as e:

     

       2392
       2392
       +
               console.print(f"[red]Error building reference index: {e}[/red]")

     

       2393
       2393
       +
               if verbose:

     

       2394
       2394
       +
                   console.print_exception()

     

       2395
       2395
       +
               raise typer.Exit(1)

     

       2396
       2396
       +
       

     

       2397
       2397
       +
       

     

       2398
       2398
       +
       @app.command()

     

       2399
       2399
       +
       def threads(

     

       2400
       2400
       +
           config_file: Optional[Path] = typer.Option(

     

       2401
       2401
       +
               None,

     

       2402
       2402
       +
               "--config",

     

       2403
       2403
       +
               "-c",

     

       2404
       2404
       +
               help="Path to configuration file",

     

       2405
       2405
       +
           ),

     

       2406
       2406
       +
           index_file: Optional[Path] = typer.Option(

     

       2407
       2407
       +
               None,

     

       2408
       2408
       +
               "--index",

     

       2409
       2409
       +
               "-i",

     

       2410
       2410
       +
               help="Path to reference index file (default: links.json in git store)",

     

       2411
       2411
       +
           ),

     

       2412
       2412
       +
           username: Optional[str] = typer.Option(

     

       2413
       2413
       +
               None,

     

       2414
       2414
       +
               "--username",

     

       2415
       2415
       +
               "-u",

     

       2416
       2416
       +
               help="Show threads for specific username only",

     

       2417
       2417
       +
           ),

     

       2418
       2418
       +
           entry_id: Optional[str] = typer.Option(

     

       2419
       2419
       +
               None,

     

       2420
       2420
       +
               "--entry",

     

       2421
       2421
       +
               "-e",

     

       2422
       2422
       +
               help="Show thread for specific entry ID",

     

       2423
       2423
       +
           ),

     

       2424
       2424
       +
           min_size: int = typer.Option(

     

       2425
       2425
       +
               2,

     

       2426
       2426
       +
               "--min-size",

     

       2427
       2427
       +
               "-m",

     

       2428
       2428
       +
               help="Minimum thread size to display",

     

       2429
       2429
       +
           ),

     

       2430
       2430
       +
       ) -> None:

     

       2431
       2431
       +
           """Show threaded view of related blog entries.

     

       2432
       2432
       +
       

     

       2433
       2433
       +
           This command uses the reference index to show which blog entries

     

       2434
       2434
       +
           are connected through cross-references, creating an email-style

     

       2435
       2435
       +
           threaded view of the conversation.

     

       2436
       2436
       +
           

     

       2437
       2437
       +
           Reads reference data from the unified links.json file.

     

       2438
       2438
       +
           """

     

       2439
       2439
       +
           try:

     

       2440
       2440
       +
               # Load configuration

     

       2441
       2441
       +
               config = load_config(config_file)

     

       2442
       2442
       +
       

     

       2443
       2443
       +
               # Determine index file path

     

       2444
       2444
       +
               if index_file:

     

       2445
       2445
       +
                   index_path = index_file

     

       2446
       2446
       +
               else:

     

       2447
       2447
       +
                   index_path = config.git_store / "links.json"

     

       2448
       2448
       +
       

     

       2449
       2449
       +
               if not index_path.exists():

     

       2450
       2450
       +
                   console.print(f"[red]Links file not found: {index_path}[/red]")

     

       2451
       2451
       +
                   console.print("Run 'thicket links' and 'thicket index' first to build the reference index")

     

       2452
       2452
       +
                   raise typer.Exit(1)

     

       2453
       2453
       +
       

     

       2454
       2454
       +
               # Load unified data

     

       2455
       2455
       +
               with open(index_path) as f:

     

       2456
       2456
       +
                   unified_data = json.load(f)

     

       2457
       2457
       +
       

     

       2458
       2458
       +
               # Check if references exist in the unified structure

     

       2459
       2459
       +
               if "references" not in unified_data:

     

       2460
       2460
       +
                   console.print(f"[red]No references found in {index_path}[/red]")

     

       2461
       2461
       +
                   console.print("Run 'thicket index' first to build the reference index")

     

       2462
       2462
       +
                   raise typer.Exit(1)

     

       2463
       2463
       +
       

     

       2464
       2464
       +
               # Extract reference data and reconstruct ReferenceIndex

     

       2465
       2465
       +
               ref_index = ReferenceIndex.from_dict({

     

       2466
       2466
       +
                   "references": unified_data["references"],

     

       2467
       2467
       +
                   "user_domains": unified_data.get("user_domains", {})

     

       2468
       2468
       +
               })

     

       2469
       2469
       +
       

     

       2470
       2470
       +
               # Initialize Git store to get entry details

     

       2471
       2471
       +
               git_store = GitStore(config.git_store)

     

       2472
       2472
       +
       

     

       2473
       2473
       +
               if entry_id and username:

     

       2474
       2474
       +
                   # Show specific thread

     

       2475
       2475
       +
                   thread_members = ref_index.get_thread_members(username, entry_id)

     

       2476
       2476
       +
                   _display_thread(thread_members, ref_index, git_store, f"Thread for {username}:{entry_id}")

     

       2477
       2477
       +
       

     

       2478
       2478
       +
               elif username:

     

       2479
       2479
       +
                   # Show all threads involving this user

     

       2480
       2480
       +
                   user_index = git_store._load_index()

     

       2481
       2481
       +
                   user = user_index.get_user(username)

     

       2482
       2482
       +
                   if not user:

     

       2483
       2483
       +
                       console.print(f"[red]User not found: {username}[/red]")

     

       2484
       2484
       +
                       raise typer.Exit(1)

     

       2485
       2485
       +
       

     

       2486
       2486
       +
                   entries = git_store.list_entries(username)

     

       2487
       2487
       +
                   threads_found = set()

     

       2488
       2488
       +
       

     

       2489
       2489
       +
                   console.print(f"[bold]Threads involving {username}:[/bold]\n")

     

       2490
       2490
       +
       

     

       2491
       2491
       +
                   for entry in entries:

     

       2492
       2492
       +
                       thread_members = ref_index.get_thread_members(username, entry.id)

     

       2493
       2493
       +
                       if len(thread_members) >= min_size:

     

       2494
       2494
       +
                           thread_key = tuple(sorted(thread_members))

     

       2495
       2495
       +
                           if thread_key not in threads_found:

     

       2496
       2496
       +
                               threads_found.add(thread_key)

     

       2497
       2497
       +
                               _display_thread(thread_members, ref_index, git_store, f"Thread #{len(threads_found)}")

     

       2498
       2498
       +
       

     

       2499
       2499
       +
               else:

     

       2500
       2500
       +
                   # Show all threads

     

       2501
       2501
       +
                   console.print("[bold]All conversation threads:[/bold]\n")

     

       2502
       2502
       +
       

     

       2503
       2503
       +
                   all_threads = set()

     

       2504
       2504
       +
                   processed_entries = set()

     

       2505
       2505
       +
       

     

       2506
       2506
       +
                   # Get all entries

     

       2507
       2507
       +
                   user_index = git_store._load_index()

     

       2508
       2508
       +
                   for username in user_index.users.keys():

     

       2509
       2509
       +
                       entries = git_store.list_entries(username)

     

       2510
       2510
       +
                       for entry in entries:

     

       2511
       2511
       +
                           entry_key = (username, entry.id)

     

       2512
       2512
       +
                           if entry_key in processed_entries:

     

       2513
       2513
       +
                               continue

     

       2514
       2514
       +
       

     

       2515
       2515
       +
                           thread_members = ref_index.get_thread_members(username, entry.id)

     

       2516
       2516
       +
                           if len(thread_members) >= min_size:

     

       2517
       2517
       +
                               thread_key = tuple(sorted(thread_members))

     

       2518
       2518
       +
                               if thread_key not in all_threads:

     

       2519
       2519
       +
                                   all_threads.add(thread_key)

     

       2520
       2520
       +
                                   _display_thread(thread_members, ref_index, git_store, f"Thread #{len(all_threads)}")

     

       2521
       2521
       +
       

     

       2522
       2522
       +
                                   # Mark all members as processed

     

       2523
       2523
       +
                                   for member in thread_members:

     

       2524
       2524
       +
                                       processed_entries.add(member)

     

       2525
       2525
       +
       

     

       2526
       2526
       +
                   if not all_threads:

     

       2527
       2527
       +
                       console.print("[yellow]No conversation threads found[/yellow]")

     

       2528
       2528
       +
                       console.print(f"(minimum thread size: {min_size})")

     

       2529
       2529
       +
       

     

       2530
       2530
       +
           except Exception as e:

     

       2531
       2531
       +
               console.print(f"[red]Error showing threads: {e}[/red]")

     

       2532
       2532
       +
               raise typer.Exit(1)

     

       2533
       2533
       +
       

     

       2534
       2534
       +
       

     

       2535
       2535
       +
       def _display_thread(thread_members, ref_index, git_store, title):

     

       2536
       2536
       +
           """Display a single conversation thread."""

     

       2537
       2537
       +
           console.print(f"[bold cyan]{title}[/bold cyan]")

     

       2538
       2538
       +
           console.print(f"Thread size: {len(thread_members)} entries")

     

       2539
       2539
       +
       

     

       2540
       2540
       +
           # Get entry details for each member

     

       2541
       2541
       +
           thread_entries = []

     

       2542
       2542
       +
           for username, entry_id in thread_members:

     

       2543
       2543
       +
               entry = git_store.get_entry(username, entry_id)

     

       2544
       2544
       +
               if entry:

     

       2545
       2545
       +
                   thread_entries.append((username, entry))

     

       2546
       2546
       +
       

     

       2547
       2547
       +
           # Sort by publication date

     

       2548
       2548
       +
           thread_entries.sort(key=lambda x: x[1].published or x[1].updated)

     

       2549
       2549
       +
       

     

       2550
       2550
       +
           # Display entries

     

       2551
       2551
       +
           for i, (username, entry) in enumerate(thread_entries):

     

       2552
       2552
       +
               prefix = "├─" if i < len(thread_entries) - 1 else "└─"

     

       2553
       2553
       +
       

     

       2554
       2554
       +
               # Get references for this entry

     

       2555
       2555
       +
               outbound = ref_index.get_outbound_refs(username, entry.id)

     

       2556
       2556
       +
               inbound = ref_index.get_inbound_refs(username, entry.id)

     

       2557
       2557
       +
       

     

       2558
       2558
       +
               ref_info = ""

     

       2559
       2559
       +
               if outbound or inbound:

     

       2560
       2560
       +
                   ref_info = f" ({len(outbound)} out, {len(inbound)} in)"

     

       2561
       2561
       +
       

     

       2562
       2562
       +
               console.print(f"  {prefix} [{username}] {entry.title[:60]}...{ref_info}")

     

       2563
       2563
       +
       

     

       2564
       2564
       +
               if entry.published:

     

       2565
       2565
       +
                   console.print(f"    Published: {entry.published.strftime('%Y-%m-%d')}")

     

       2566
       2566
       +
       

     

       2567
       2567
       +
           console.print()  # Empty line after each thread

     

       2568
       2568
       +
       </file>

     

       2569
       2569
       +
       

     

       2570
       2570
       +
       <file path="src/thicket/cli/commands/info_cmd.py">

     

       2571
       2571
       +
       """CLI command for displaying detailed information about a specific atom entry."""

     

       2572
       2572
       +
       

     

       2573
       2573
       +
       import json

     

       2574
       2574
       +
       from pathlib import Path

     

       2575
       2575
       +
       from typing import Optional

     

       2576
       2576
       +
       

     

       2577
       2577
       +
       import typer

     

       2578
       2578
       +
       from rich.console import Console

     

       2579
       2579
       +
       from rich.panel import Panel

     

       2580
       2580
       +
       from rich.table import Table

     

       2581
       2581
       +
       from rich.text import Text

     

       2582
       2582
       +
       

     

       2583
       2583
       +
       from ...core.git_store import GitStore

     

       2584
       2584
       +
       from ...core.reference_parser import ReferenceIndex

     

       2585
       2585
       +
       from ..main import app

     

       2586
       2586
       +
       from ..utils import load_config, get_tsv_mode

     

       2587
       2587
       +
       

     

       2588
       2588
       +
       console = Console()

     

       2589
       2589
       +
       

     

       2590
       2590
       +
       

     

       2591
       2591
       +
       @app.command()

     

       2592
       2592
       +
       def info(

     

       2593
       2593
       +
           identifier: str = typer.Argument(

     

       2594
       2594
       +
               ...,

     

       2595
       2595
       +
               help="The atom ID or URL of the entry to display information about"

     

       2596
       2596
       +
           ),

     

       2597
       2597
       +
           username: Optional[str] = typer.Option(

     

       2598
       2598
       +
               None,

     

       2599
       2599
       +
               "--username",

     

       2600
       2600
       +
               "-u",

     

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

     

       2602
       2602
       +
           ),

     

       2603
       2603
       +
           config_file: Optional[Path] = typer.Option(

     

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

     

       2605
       2605
       +
               "--config",

     

       2606
       2606
       +
               "-c",

     

       2607
       2607
       +
               help="Path to configuration file",

     

       2608
       2608
       +
           ),

     

       2609
       2609
       +
           show_content: bool = typer.Option(

     

       2610
       2610
       +
               False,

     

       2611
       2611
       +
               "--content",

     

       2612
       2612
       +
               help="Include the full content of the entry in the output"

     

       2613
       2613
       +
           ),

     

       2614
       2614
       +
       ) -> None:

     

       2615
       2615
       +
           """Display detailed information about a specific atom entry.

     

       2616
       2616
       +
           

     

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

     

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

     

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

     

       2620
       2620
       +
           """

     

       2621
       2621
       +
           try:

     

       2622
       2622
       +
               # Load configuration

     

       2623
       2623
       +
               config = load_config(config_file)

     

       2624
       2624
       +
               

     

       2625
       2625
       +
               # Initialize Git store

     

       2626
       2626
       +
               git_store = GitStore(config.git_store)

     

       2627
       2627
       +
               

     

       2628
       2628
       +
               # Find the entry

     

       2629
       2629
       +
               entry = None

     

       2630
       2630
       +
               found_username = None

     

       2631
       2631
       +
               

     

       2632
       2632
       +
               # Check if identifier looks like a URL

     

       2633
       2633
       +
               is_url = identifier.startswith(('http://', 'https://'))

     

       2634
       2634
       +
               

     

       2635
       2635
       +
               if username:

     

       2636
       2636
       +
                   # Search specific username

     

       2637
       2637
       +
                   if is_url:

     

       2638
       2638
       +
                       # Search by URL

     

       2639
       2639
       +
                       entries = git_store.list_entries(username)

     

       2640
       2640
       +
                       for e in entries:

     

       2641
       2641
       +
                           if str(e.link) == identifier:

     

       2642
       2642
       +
                               entry = e

     

       2643
       2643
       +
                               found_username = username

     

       2644
       2644
       +
                               break

     

       2645
       2645
       +
                   else:

     

       2646
       2646
       +
                       # Search by atom ID

     

       2647
       2647
       +
                       entry = git_store.get_entry(username, identifier)

     

       2648
       2648
       +
                       if entry:

     

       2649
       2649
       +
                           found_username = username

     

       2650
       2650
       +
               else:

     

       2651
       2651
       +
                   # Search all users

     

       2652
       2652
       +
                   index = git_store._load_index()

     

       2653
       2653
       +
                   for user in index.users.keys():

     

       2654
       2654
       +
                       if is_url:

     

       2655
       2655
       +
                           # Search by URL

     

       2656
       2656
       +
                           entries = git_store.list_entries(user)

     

       2657
       2657
       +
                           for e in entries:

     

       2658
       2658
       +
                               if str(e.link) == identifier:

     

       2659
       2659
       +
                                   entry = e

     

       2660
       2660
       +
                                   found_username = user

     

       2661
       2661
       +
                                   break

     

       2662
       2662
       +
                           if entry:

     

       2663
       2663
       +
                               break

     

       2664
       2664
       +
                       else:

     

       2665
       2665
       +
                           # Search by atom ID

     

       2666
       2666
       +
                           entry = git_store.get_entry(user, identifier)

     

       2667
       2667
       +
                           if entry:

     

       2668
       2668
       +
                               found_username = user

     

       2669
       2669
       +
                               break

     

       2670
       2670
       +
               

     

       2671
       2671
       +
               if not entry or not found_username:

     

       2672
       2672
       +
                   if username:

     

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

     

       2674
       2674
       +
                   else:

     

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

     

       2676
       2676
       +
                   raise typer.Exit(1)

     

       2677
       2677
       +
               

     

       2678
       2678
       +
               # Load reference index if available

     

       2679
       2679
       +
               links_path = config.git_store / "links.json"

     

       2680
       2680
       +
               ref_index = None

     

       2681
       2681
       +
               if links_path.exists():

     

       2682
       2682
       +
                   with open(links_path) as f:

     

       2683
       2683
       +
                       unified_data = json.load(f)

     

       2684
       2684
       +
                   

     

       2685
       2685
       +
                   # Check if references exist in the unified structure

     

       2686
       2686
       +
                   if "references" in unified_data:

     

       2687
       2687
       +
                       ref_index = ReferenceIndex.from_dict({

     

       2688
       2688
       +
                           "references": unified_data["references"],

     

       2689
       2689
       +
                           "user_domains": unified_data.get("user_domains", {})

     

       2690
       2690
       +
                       })

     

       2691
       2691
       +
               

     

       2692
       2692
       +
               # Display information

     

       2693
       2693
       +
               if get_tsv_mode():

     

       2694
       2694
       +
                   _display_entry_info_tsv(entry, found_username, ref_index, show_content)

     

       2695
       2695
       +
               else:

     

       2696
       2696
       +
                   _display_entry_info(entry, found_username)

     

       2697
       2697
       +
                   

     

       2698
       2698
       +
                   if ref_index:

     

       2699
       2699
       +
                       _display_link_info(entry, found_username, ref_index)

     

       2700
       2700
       +
                   else:

     

       2701
       2701
       +
                       console.print("\n[yellow]No reference index found. Run 'thicket links' and 'thicket index' to build cross-reference data.[/yellow]")

     

       2702
       2702
       +
                   

     

       2703
       2703
       +
                   # Optionally display content

     

       2704
       2704
       +
                   if show_content and entry.content:

     

       2705
       2705
       +
                       _display_content(entry.content)

     

       2706
       2706
       +
                   

     

       2707
       2707
       +
           except Exception as e:

     

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

     

       2709
       2709
       +
               raise typer.Exit(1)

     

       2710
       2710
       +
       

     

       2711
       2711
       +
       

     

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

     

       2713
       2713
       +
           """Display basic entry information in a structured format."""

     

       2714
       2714
       +
           

     

       2715
       2715
       +
           # Create main info panel

     

       2716
       2716
       +
           info_table = Table.grid(padding=(0, 2))

     

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

     

       2718
       2718
       +
           info_table.add_column("Value", style="white")

     

       2719
       2719
       +
           

     

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

     

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

     

       2722
       2722
       +
           info_table.add_row("Title", entry.title)

     

       2723
       2723
       +
           info_table.add_row("Link", str(entry.link))

     

       2724
       2724
       +
           

     

       2725
       2725
       +
           if entry.published:

     

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

     

       2727
       2727
       +
           

     

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

     

       2729
       2729
       +
           

     

       2730
       2730
       +
           if entry.summary:

     

       2731
       2731
       +
               # Truncate long summaries

     

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

     

       2733
       2733
       +
               info_table.add_row("Summary", summary)

     

       2734
       2734
       +
           

     

       2735
       2735
       +
           if entry.categories:

     

       2736
       2736
       +
               categories_text = ", ".join(entry.categories)

     

       2737
       2737
       +
               info_table.add_row("Categories", categories_text)

     

       2738
       2738
       +
           

     

       2739
       2739
       +
           if entry.author:

     

       2740
       2740
       +
               author_info = []

     

       2741
       2741
       +
               if "name" in entry.author:

     

       2742
       2742
       +
                   author_info.append(entry.author["name"])

     

       2743
       2743
       +
               if "email" in entry.author:

     

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

     

       2745
       2745
       +
               if author_info:

     

       2746
       2746
       +
                   info_table.add_row("Author", " ".join(author_info))

     

       2747
       2747
       +
           

     

       2748
       2748
       +
           if entry.content_type:

     

       2749
       2749
       +
               info_table.add_row("Content Type", entry.content_type)

     

       2750
       2750
       +
           

     

       2751
       2751
       +
           if entry.rights:

     

       2752
       2752
       +
               info_table.add_row("Rights", entry.rights)

     

       2753
       2753
       +
           

     

       2754
       2754
       +
           if entry.source:

     

       2755
       2755
       +
               info_table.add_row("Source Feed", entry.source)

     

       2756
       2756
       +
           

     

       2757
       2757
       +
           panel = Panel(

     

       2758
       2758
       +
               info_table,

     

       2759
       2759
       +
               title=f"[bold]Entry Information[/bold]",

     

       2760
       2760
       +
               border_style="blue"

     

       2761
       2761
       +
           )

     

       2762
       2762
       +
           

     

       2763
       2763
       +
           console.print(panel)

     

       2764
       2764
       +
       

     

       2765
       2765
       +
       

     

       2766
       2766
       +
       def _display_link_info(entry, username: str, ref_index: ReferenceIndex) -> None:

     

       2767
       2767
       +
           """Display inbound and outbound link information."""

     

       2768
       2768
       +
           

     

       2769
       2769
       +
           # Get links

     

       2770
       2770
       +
           outbound_refs = ref_index.get_outbound_refs(username, entry.id)

     

       2771
       2771
       +
           inbound_refs = ref_index.get_inbound_refs(username, entry.id)

     

       2772
       2772
       +
           

     

       2773
       2773
       +
           if not outbound_refs and not inbound_refs:

     

       2774
       2774
       +
               console.print("\n[dim]No cross-references found for this entry.[/dim]")

     

       2775
       2775
       +
               return

     

       2776
       2776
       +
           

     

       2777
       2777
       +
           # Create links table

     

       2778
       2778
       +
           links_table = Table(title="Cross-References")

     

       2779
       2779
       +
           links_table.add_column("Direction", style="cyan", width=10)

     

       2780
       2780
       +
           links_table.add_column("Target/Source", style="green", width=20)

     

       2781
       2781
       +
           links_table.add_column("URL", style="blue", width=50)

     

       2782
       2782
       +
           

     

       2783
       2783
       +
           # Add outbound references

     

       2784
       2784
       +
           for ref in outbound_refs:

     

       2785
       2785
       +
               target_info = f"{ref.target_username}:{ref.target_entry_id}" if ref.target_username and ref.target_entry_id else "External"

     

       2786
       2786
       +
               links_table.add_row("→ Out", target_info, ref.target_url)

     

       2787
       2787
       +
           

     

       2788
       2788
       +
           # Add inbound references

     

       2789
       2789
       +
           for ref in inbound_refs:

     

       2790
       2790
       +
               source_info = f"{ref.source_username}:{ref.source_entry_id}"

     

       2791
       2791
       +
               links_table.add_row("← In", source_info, ref.target_url)

     

       2792
       2792
       +
           

     

       2793
       2793
       +
           console.print()

     

       2794
       2794
       +
           console.print(links_table)

     

       2795
       2795
       +
           

     

       2796
       2796
       +
           # Summary

     

       2797
       2797
       +
           console.print(f"\n[bold]Summary:[/bold] {len(outbound_refs)} outbound, {len(inbound_refs)} inbound references")

     

       2798
       2798
       +
       

     

       2799
       2799
       +
       

     

       2800
       2800
       +
       def _display_content(content: str) -> None:

     

       2801
       2801
       +
           """Display the full content of the entry."""

     

       2802
       2802
       +
           

     

       2803
       2803
       +
           # Truncate very long content

     

       2804
       2804
       +
           display_content = content

     

       2805
       2805
       +
           if len(content) > 5000:

     

       2806
       2806
       +
               display_content = content[:5000] + "\n\n[... content truncated ...]"

     

       2807
       2807
       +
           

     

       2808
       2808
       +
           panel = Panel(

     

       2809
       2809
       +
               display_content,

     

       2810
       2810
       +
               title="[bold]Entry Content[/bold]",

     

       2811
       2811
       +
               border_style="green",

     

       2812
       2812
       +
               expand=False

     

       2813
       2813
       +
           )

     

       2814
       2814
       +
           

     

       2815
       2815
       +
           console.print()

     

       2816
       2816
       +
           console.print(panel)

     

       2817
       2817
       +
       

     

       2818
       2818
       +
       

     

       2819
       2819
       +
       def _display_entry_info_tsv(entry, username: str, ref_index: Optional[ReferenceIndex], show_content: bool) -> None:

     

       2820
       2820
       +
           """Display entry information in TSV format."""

     

       2821
       2821
       +
           

     

       2822
       2822
       +
           # Basic info

     

       2823
       2823
       +
           print("Field\tValue")

     

       2824
       2824
       +
           print(f"User\t{username}")

     

       2825
       2825
       +
           print(f"Atom ID\t{entry.id}")

     

       2826
       2826
       +
           print(f"Title\t{entry.title.replace(chr(9), ' ').replace(chr(10), ' ').replace(chr(13), ' ')}")

     

       2827
       2827
       +
           print(f"Link\t{entry.link}")

     

       2828
       2828
       +
           

     

       2829
       2829
       +
           if entry.published:

     

       2830
       2830
       +
               print(f"Published\t{entry.published.strftime('%Y-%m-%d %H:%M:%S UTC')}")

     

       2831
       2831
       +
           

     

       2832
       2832
       +
           print(f"Updated\t{entry.updated.strftime('%Y-%m-%d %H:%M:%S UTC')}")

     

       2833
       2833
       +
           

     

       2834
       2834
       +
           if entry.summary:

     

       2835
       2835
       +
               # Escape tabs and newlines in summary

     

       2836
       2836
       +
               summary = entry.summary.replace('\t', ' ').replace('\n', ' ').replace('\r', ' ')

     

       2837
       2837
       +
               print(f"Summary\t{summary}")

     

       2838
       2838
       +
           

     

       2839
       2839
       +
           if entry.categories:

     

       2840
       2840
       +
               print(f"Categories\t{', '.join(entry.categories)}")

     

       2841
       2841
       +
           

     

       2842
       2842
       +
           if entry.author:

     

       2843
       2843
       +
               author_info = []

     

       2844
       2844
       +
               if "name" in entry.author:

     

       2845
       2845
       +
                   author_info.append(entry.author["name"])

     

       2846
       2846
       +
               if "email" in entry.author:

     

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

     

       2848
       2848
       +
               if author_info:

     

       2849
       2849
       +
                   print(f"Author\t{' '.join(author_info)}")

     

       2850
       2850
       +
           

     

       2851
       2851
       +
           if entry.content_type:

     

       2852
       2852
       +
               print(f"Content Type\t{entry.content_type}")

     

       2853
       2853
       +
           

     

       2854
       2854
       +
           if entry.rights:

     

       2855
       2855
       +
               print(f"Rights\t{entry.rights}")

     

       2856
       2856
       +
           

     

       2857
       2857
       +
           if entry.source:

     

       2858
       2858
       +
               print(f"Source Feed\t{entry.source}")

     

       2859
       2859
       +
           

     

       2860
       2860
       +
           # Add reference info if available

     

       2861
       2861
       +
           if ref_index:

     

       2862
       2862
       +
               outbound_refs = ref_index.get_outbound_refs(username, entry.id)

     

       2863
       2863
       +
               inbound_refs = ref_index.get_inbound_refs(username, entry.id)

     

       2864
       2864
       +
               

     

       2865
       2865
       +
               print(f"Outbound References\t{len(outbound_refs)}")

     

       2866
       2866
       +
               print(f"Inbound References\t{len(inbound_refs)}")

     

       2867
       2867
       +
               

     

       2868
       2868
       +
               # Show each reference

     

       2869
       2869
       +
               for ref in outbound_refs:

     

       2870
       2870
       +
                   target_info = f"{ref.target_username}:{ref.target_entry_id}" if ref.target_username and ref.target_entry_id else "External"

     

       2871
       2871
       +
                   print(f"Outbound Reference\t{target_info}\t{ref.target_url}")

     

       2872
       2872
       +
               

     

       2873
       2873
       +
               for ref in inbound_refs:

     

       2874
       2874
       +
                   source_info = f"{ref.source_username}:{ref.source_entry_id}"

     

       2875
       2875
       +
                   print(f"Inbound Reference\t{source_info}\t{ref.target_url}")

     

       2876
       2876
       +
           

     

       2877
       2877
       +
           # Show content if requested

     

       2878
       2878
       +
           if show_content and entry.content:

     

       2879
       2879
       +
               # Escape tabs and newlines in content

     

       2880
       2880
       +
               content = entry.content.replace('\t', ' ').replace('\n', ' ').replace('\r', ' ')

     

       2881
       2881
       +
               print(f"Content\t{content}")

     

       2882
       2882
       +
       </file>

     

       2883
       2883
       +
       

     

       2884
       2884
       +
       <file path="src/thicket/cli/commands/init.py">

     

       2885
       2885
       +
       """Initialize command for thicket."""

     

       2886
       2886
       +
       

     

       2887
       2887
       +
       from pathlib import Path

     

       2888
       2888
       +
       from typing import Optional

     

       2889
       2889
       +
       

     

       2890
       2890
       +
       import typer

     

       2891
       2891
       +
       from pydantic import ValidationError

     

       2892
       2892
       +
       

     

       2893
       2893
       +
       from ...core.git_store import GitStore

     

       2894
       2894
       +
       from ...models import ThicketConfig

     

       2895
       2895
       +
       from ..main import app

     

       2896
       2896
       +
       from ..utils import print_error, print_success, save_config

     

       2897
       2897
       +
       

     

       2898
       2898
       +
       

     

       2899
       2899
       +
       @app.command()

     

       2900
       2900
       +
       def init(

     

       2901
       2901
       +
           git_store: Path = typer.Argument(..., help="Path to Git repository for storing feeds"),

     

       2902
       2902
       +
           cache_dir: Optional[Path] = typer.Option(

     

       2903
       2903
       +
               None, "--cache-dir", "-c", help="Cache directory (default: ~/.cache/thicket)"

     

       2904
       2904
       +
           ),

     

       2905
       2905
       +
           config_file: Optional[Path] = typer.Option(

     

       2906
       2906
       +
               None, "--config", help="Configuration file path (default: thicket.yaml)"

     

       2907
       2907
       +
           ),

     

       2908
       2908
       +
           force: bool = typer.Option(

     

       2909
       2909
       +
               False, "--force", "-f", help="Overwrite existing configuration"

     

       2910
       2910
       +
           ),

     

       2911
       2911
       +
       ) -> None:

     

       2912
       2912
       +
           """Initialize a new thicket configuration and Git store."""

     

       2913
       2913
       +
       

     

       2914
       2914
       +
           # Set default paths

     

       2915
       2915
       +
           if cache_dir is None:

     

       2916
       2916
       +
               from platformdirs import user_cache_dir

     

       2917
       2917
       +
               cache_dir = Path(user_cache_dir("thicket"))

     

       2918
       2918
       +
       

     

       2919
       2919
       +
           if config_file is None:

     

       2920
       2920
       +
               config_file = Path("thicket.yaml")

     

       2921
       2921
       +
       

     

       2922
       2922
       +
           # Check if config already exists

     

       2923
       2923
       +
           if config_file.exists() and not force:

     

       2924
       2924
       +
               print_error(f"Configuration file already exists: {config_file}")

     

       2925
       2925
       +
               print_error("Use --force to overwrite")

     

       2926
       2926
       +
               raise typer.Exit(1)

     

       2927
       2927
       +
       

     

       2928
       2928
       +
           # Create cache directory

     

       2929
       2929
       +
           cache_dir.mkdir(parents=True, exist_ok=True)

     

       2930
       2930
       +
       

     

       2931
       2931
       +
           # Create Git store

     

       2932
       2932
       +
           try:

     

       2933
       2933
       +
               GitStore(git_store)

     

       2934
       2934
       +
               print_success(f"Initialized Git store at: {git_store}")

     

       2935
       2935
       +
           except Exception as e:

     

       2936
       2936
       +
               print_error(f"Failed to initialize Git store: {e}")

     

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

     

       2938
       2938
       +
       

     

       2939
       2939
       +
           # Create configuration

     

       2940
       2940
       +
           try:

     

       2941
       2941
       +
               config = ThicketConfig(

     

       2942
       2942
       +
                   git_store=git_store,

     

       2943
       2943
       +
                   cache_dir=cache_dir,

     

       2944
       2944
       +
                   users=[]

     

       2945
       2945
       +
               )

     

       2946
       2946
       +
       

     

       2947
       2947
       +
               save_config(config, config_file)

     

       2948
       2948
       +
               print_success(f"Created configuration file: {config_file}")

     

       2949
       2949
       +
       

     

       2950
       2950
       +
           except ValidationError as e:

     

       2951
       2951
       +
               print_error(f"Invalid configuration: {e}")

     

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

     

       2953
       2953
       +
           except Exception as e:

     

       2954
       2954
       +
               print_error(f"Failed to create configuration: {e}")

     

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

     

       2956
       2956
       +
       

     

       2957
       2957
       +
           print_success("Thicket initialized successfully!")

     

       2958
       2958
       +
           print_success(f"Git store: {git_store}")

     

       2959
       2959
       +
           print_success(f"Cache directory: {cache_dir}")

     

       2960
       2960
       +
           print_success(f"Configuration: {config_file}")

     

       2961
       2961
       +
           print_success("Run 'thicket add user' to add your first user and feed.")

     

       2962
       2962
       +
       </file>

     

       2963
       2963
       +
       

     

       2964
       2964
       +
       <file path="src/thicket/cli/__init__.py">

     

       2965
       2965
       +
       """CLI interface for thicket."""

     

       2966
       2966
       +
       

     

       2967
       2967
       +
       from .main import app

     

       2968
       2968
       +
       

     

       2969
       2969
       +
       __all__ = ["app"]

     

       2970
       2970
       +
       </file>

     

       2971
       2971
       +
       

     

       2972
       2972
       +
       <file path="src/thicket/core/__init__.py">

     

       2973
       2973
       +
       """Core business logic for thicket."""

     

       2974
       2974
       +
       

     

       2975
       2975
       +
       from .feed_parser import FeedParser

     

       2976
       2976
       +
       from .git_store import GitStore

     

       2977
       2977
       +
       

     

       2978
       2978
       +
       __all__ = ["FeedParser", "GitStore"]

     

       2979
       2979
       +
       </file>

     

       2980
       2980
       +
       

     

       2981
       2981
       +
       <file path="src/thicket/core/feed_parser.py">

     

       2982
       2982
       +
       """Feed parsing and normalization with auto-discovery."""

     

       2983
       2983
       +
       

     

       2984
       2984
       +
       from datetime import datetime

     

       2985
       2985
       +
       from typing import Optional

     

       2986
       2986
       +
       from urllib.parse import urlparse

     

       2987
       2987
       +
       

     

       2988
       2988
       +
       import bleach

     

       2989
       2989
       +
       import feedparser

     

       2990
       2990
       +
       import httpx

     

       2991
       2991
       +
       from pydantic import HttpUrl, ValidationError

     

       2992
       2992
       +
       

     

       2993
       2993
       +
       from ..models import AtomEntry, FeedMetadata

     

       2994
       2994
       +
       

     

       2995
       2995
       +
       

     

       2996
       2996
       +
       class FeedParser:

     

       2997
       2997
       +
           """Parser for RSS/Atom feeds with normalization and auto-discovery."""

     

       2998
       2998
       +
       

     

       2999
       2999
       +
           def __init__(self, user_agent: str = "thicket/0.1.0"):

     

       3000
       3000
       +
               """Initialize the feed parser."""

     

       3001
       3001
       +
               self.user_agent = user_agent

     

       3002
       3002
       +
               self.allowed_tags = [

     

       3003
       3003
       +
                   "a", "abbr", "acronym", "b", "blockquote", "br", "code", "em",

     

       3004
       3004
       +
                   "i", "li", "ol", "p", "pre", "strong", "ul", "h1", "h2", "h3",

     

       3005
       3005
       +
                   "h4", "h5", "h6", "img", "div", "span",

     

       3006
       3006
       +
               ]

     

       3007
       3007
       +
               self.allowed_attributes = {

     

       3008
       3008
       +
                   "a": ["href", "title"],

     

       3009
       3009
       +
                   "abbr": ["title"],

     

       3010
       3010
       +
                   "acronym": ["title"],

     

       3011
       3011
       +
                   "img": ["src", "alt", "title", "width", "height"],

     

       3012
       3012
       +
                   "blockquote": ["cite"],

     

       3013
       3013
       +
               }

     

       3014
       3014
       +
       

     

       3015
       3015
       +
           async def fetch_feed(self, url: HttpUrl) -> str:

     

       3016
       3016
       +
               """Fetch feed content from URL."""

     

       3017
       3017
       +
               async with httpx.AsyncClient() as client:

     

       3018
       3018
       +
                   response = await client.get(

     

       3019
       3019
       +
                       str(url),

     

       3020
       3020
       +
                       headers={"User-Agent": self.user_agent},

     

       3021
       3021
       +
                       timeout=30.0,

     

       3022
       3022
       +
                       follow_redirects=True,

     

       3023
       3023
       +
                   )

     

       3024
       3024
       +
                   response.raise_for_status()

     

       3025
       3025
       +
                   return response.text

     

       3026
       3026
       +
       

     

       3027
       3027
       +
           def parse_feed(self, content: str, source_url: Optional[HttpUrl] = None) -> tuple[FeedMetadata, list[AtomEntry]]:

     

       3028
       3028
       +
               """Parse feed content and return metadata and entries."""

     

       3029
       3029
       +
               parsed = feedparser.parse(content)

     

       3030
       3030
       +
       

     

       3031
       3031
       +
               if parsed.bozo and parsed.bozo_exception:

     

       3032
       3032
       +
                   # Try to continue with potentially malformed feed

     

       3033
       3033
       +
                   pass

     

       3034
       3034
       +
       

     

       3035
       3035
       +
               # Extract feed metadata

     

       3036
       3036
       +
               feed_meta = self._extract_feed_metadata(parsed.feed)

     

       3037
       3037
       +
       

     

       3038
       3038
       +
               # Extract and normalize entries

     

       3039
       3039
       +
               entries = []

     

       3040
       3040
       +
               for entry in parsed.entries:

     

       3041
       3041
       +
                   try:

     

       3042
       3042
       +
                       atom_entry = self._normalize_entry(entry, source_url)

     

       3043
       3043
       +
                       entries.append(atom_entry)

     

       3044
       3044
       +
                   except Exception as e:

     

       3045
       3045
       +
                       # Log error but continue processing other entries

     

       3046
       3046
       +
                       print(f"Error processing entry {getattr(entry, 'id', 'unknown')}: {e}")

     

       3047
       3047
       +
                       continue

     

       3048
       3048
       +
       

     

       3049
       3049
       +
               return feed_meta, entries

     

       3050
       3050
       +
       

     

       3051
       3051
       +
           def _extract_feed_metadata(self, feed: feedparser.FeedParserDict) -> FeedMetadata:

     

       3052
       3052
       +
               """Extract metadata from feed for auto-discovery."""

     

       3053
       3053
       +
               # Parse author information

     

       3054
       3054
       +
               author_name = None

     

       3055
       3055
       +
               author_email = None

     

       3056
       3056
       +
               author_uri = None

     

       3057
       3057
       +
       

     

       3058
       3058
       +
               if hasattr(feed, 'author_detail'):

     

       3059
       3059
       +
                   author_name = feed.author_detail.get('name')

     

       3060
       3060
       +
                   author_email = feed.author_detail.get('email')

     

       3061
       3061
       +
                   author_uri = feed.author_detail.get('href')

     

       3062
       3062
       +
               elif hasattr(feed, 'author'):

     

       3063
       3063
       +
                   author_name = feed.author

     

       3064
       3064
       +
       

     

       3065
       3065
       +
               # Parse managing editor for RSS feeds

     

       3066
       3066
       +
               if not author_email and hasattr(feed, 'managingEditor'):

     

       3067
       3067
       +
                   author_email = feed.managingEditor

     

       3068
       3068
       +
       

     

       3069
       3069
       +
               # Parse feed link

     

       3070
       3070
       +
               feed_link = None

     

       3071
       3071
       +
               if hasattr(feed, 'link'):

     

       3072
       3072
       +
                   try:

     

       3073
       3073
       +
                       feed_link = HttpUrl(feed.link)

     

       3074
       3074
       +
                   except ValidationError:

     

       3075
       3075
       +
                       pass

     

       3076
       3076
       +
       

     

       3077
       3077
       +
               # Parse image/icon/logo

     

       3078
       3078
       +
               logo = None

     

       3079
       3079
       +
               icon = None

     

       3080
       3080
       +
               image_url = None

     

       3081
       3081
       +
       

     

       3082
       3082
       +
               if hasattr(feed, 'image'):

     

       3083
       3083
       +
                   try:

     

       3084
       3084
       +
                       image_url = HttpUrl(feed.image.get('href', feed.image.get('url', '')))

     

       3085
       3085
       +
                   except (ValidationError, AttributeError):

     

       3086
       3086
       +
                       pass

     

       3087
       3087
       +
       

     

       3088
       3088
       +
               if hasattr(feed, 'icon'):

     

       3089
       3089
       +
                   try:

     

       3090
       3090
       +
                       icon = HttpUrl(feed.icon)

     

       3091
       3091
       +
                   except ValidationError:

     

       3092
       3092
       +
                       pass

     

       3093
       3093
       +
       

     

       3094
       3094
       +
               if hasattr(feed, 'logo'):

     

       3095
       3095
       +
                   try:

     

       3096
       3096
       +
                       logo = HttpUrl(feed.logo)

     

       3097
       3097
       +
                   except ValidationError:

     

       3098
       3098
       +
                       pass

     

       3099
       3099
       +
       

     

       3100
       3100
       +
               return FeedMetadata(

     

       3101
       3101
       +
                   title=getattr(feed, 'title', None),

     

       3102
       3102
       +
                   author_name=author_name,

     

       3103
       3103
       +
                   author_email=author_email,

     

       3104
       3104
       +
                   author_uri=HttpUrl(author_uri) if author_uri else None,

     

       3105
       3105
       +
                   link=feed_link,

     

       3106
       3106
       +
                   logo=logo,

     

       3107
       3107
       +
                   icon=icon,

     

       3108
       3108
       +
                   image_url=image_url,

     

       3109
       3109
       +
                   description=getattr(feed, 'description', None),

     

       3110
       3110
       +
               )

     

       3111
       3111
       +
       

     

       3112
       3112
       +
           def _normalize_entry(self, entry: feedparser.FeedParserDict, source_url: Optional[HttpUrl] = None) -> AtomEntry:

     

       3113
       3113
       +
               """Normalize an entry to Atom format."""

     

       3114
       3114
       +
               # Parse timestamps

     

       3115
       3115
       +
               updated = self._parse_timestamp(entry.get('updated_parsed') or entry.get('published_parsed'))

     

       3116
       3116
       +
               published = self._parse_timestamp(entry.get('published_parsed'))

     

       3117
       3117
       +
       

     

       3118
       3118
       +
               # Parse content

     

       3119
       3119
       +
               content = self._extract_content(entry)

     

       3120
       3120
       +
               content_type = self._extract_content_type(entry)

     

       3121
       3121
       +
       

     

       3122
       3122
       +
               # Parse author

     

       3123
       3123
       +
               author = self._extract_author(entry)

     

       3124
       3124
       +
       

     

       3125
       3125
       +
               # Parse categories/tags

     

       3126
       3126
       +
               categories = []

     

       3127
       3127
       +
               if hasattr(entry, 'tags'):

     

       3128
       3128
       +
                   categories = [tag.get('term', '') for tag in entry.tags if tag.get('term')]

     

       3129
       3129
       +
       

     

       3130
       3130
       +
               # Sanitize HTML content

     

       3131
       3131
       +
               if content:

     

       3132
       3132
       +
                   content = self._sanitize_html(content)

     

       3133
       3133
       +
       

     

       3134
       3134
       +
               summary = entry.get('summary', '')

     

       3135
       3135
       +
               if summary:

     

       3136
       3136
       +
                   summary = self._sanitize_html(summary)

     

       3137
       3137
       +
       

     

       3138
       3138
       +
               return AtomEntry(

     

       3139
       3139
       +
                   id=entry.get('id', entry.get('link', '')),

     

       3140
       3140
       +
                   title=entry.get('title', ''),

     

       3141
       3141
       +
                   link=HttpUrl(entry.get('link', '')),

     

       3142
       3142
       +
                   updated=updated,

     

       3143
       3143
       +
                   published=published,

     

       3144
       3144
       +
                   summary=summary or None,

     

       3145
       3145
       +
                   content=content or None,

     

       3146
       3146
       +
                   content_type=content_type,

     

       3147
       3147
       +
                   author=author,

     

       3148
       3148
       +
                   categories=categories,

     

       3149
       3149
       +
                   rights=entry.get('rights', None),

     

       3150
       3150
       +
                   source=str(source_url) if source_url else None,

     

       3151
       3151
       +
               )

     

       3152
       3152
       +
       

     

       3153
       3153
       +
           def _parse_timestamp(self, time_struct) -> datetime:

     

       3154
       3154
       +
               """Parse feedparser time struct to datetime."""

     

       3155
       3155
       +
               if time_struct:

     

       3156
       3156
       +
                   return datetime(*time_struct[:6])

     

       3157
       3157
       +
               return datetime.now()

     

       3158
       3158
       +
       

     

       3159
       3159
       +
           def _extract_content(self, entry: feedparser.FeedParserDict) -> Optional[str]:

     

       3160
       3160
       +
               """Extract the best content from an entry."""

     

       3161
       3161
       +
               # Prefer content over summary

     

       3162
       3162
       +
               if hasattr(entry, 'content') and entry.content:

     

       3163
       3163
       +
                   # Find the best content (prefer text/html, then text/plain)

     

       3164
       3164
       +
                   for content_item in entry.content:

     

       3165
       3165
       +
                       if content_item.get('type') in ['text/html', 'html']:

     

       3166
       3166
       +
                           return content_item.get('value', '')

     

       3167
       3167
       +
                       elif content_item.get('type') in ['text/plain', 'text']:

     

       3168
       3168
       +
                           return content_item.get('value', '')

     

       3169
       3169
       +
                   # Fallback to first content item

     

       3170
       3170
       +
                   return entry.content[0].get('value', '')

     

       3171
       3171
       +
       

     

       3172
       3172
       +
               # Fallback to summary

     

       3173
       3173
       +
               return entry.get('summary', '')

     

       3174
       3174
       +
       

     

       3175
       3175
       +
           def _extract_content_type(self, entry: feedparser.FeedParserDict) -> str:

     

       3176
       3176
       +
               """Extract content type from entry."""

     

       3177
       3177
       +
               if hasattr(entry, 'content') and entry.content:

     

       3178
       3178
       +
                   content_type = entry.content[0].get('type', 'html')

     

       3179
       3179
       +
                   # Normalize content type

     

       3180
       3180
       +
                   if content_type in ['text/html', 'html']:

     

       3181
       3181
       +
                       return 'html'

     

       3182
       3182
       +
                   elif content_type in ['text/plain', 'text']:

     

       3183
       3183
       +
                       return 'text'

     

       3184
       3184
       +
                   elif content_type == 'xhtml':

     

       3185
       3185
       +
                       return 'xhtml'

     

       3186
       3186
       +
               return 'html'

     

       3187
       3187
       +
       

     

       3188
       3188
       +
           def _extract_author(self, entry: feedparser.FeedParserDict) -> Optional[dict]:

     

       3189
       3189
       +
               """Extract author information from entry."""

     

       3190
       3190
       +
               author = {}

     

       3191
       3191
       +
       

     

       3192
       3192
       +
               if hasattr(entry, 'author_detail'):

     

       3193
       3193
       +
                   author.update({

     

       3194
       3194
       +
                       'name': entry.author_detail.get('name'),

     

       3195
       3195
       +
                       'email': entry.author_detail.get('email'),

     

       3196
       3196
       +
                       'uri': entry.author_detail.get('href'),

     

       3197
       3197
       +
                   })

     

       3198
       3198
       +
               elif hasattr(entry, 'author'):

     

       3199
       3199
       +
                   author['name'] = entry.author

     

       3200
       3200
       +
       

     

       3201
       3201
       +
               return author if author else None

     

       3202
       3202
       +
       

     

       3203
       3203
       +
           def _sanitize_html(self, html: str) -> str:

     

       3204
       3204
       +
               """Sanitize HTML content to prevent XSS."""

     

       3205
       3205
       +
               return bleach.clean(

     

       3206
       3206
       +
                   html,

     

       3207
       3207
       +
                   tags=self.allowed_tags,

     

       3208
       3208
       +
                   attributes=self.allowed_attributes,

     

       3209
       3209
       +
                   strip=True,

     

       3210
       3210
       +
               )

     

       3211
       3211
       +
       

     

       3212
       3212
       +
           def sanitize_entry_id(self, entry_id: str) -> str:

     

       3213
       3213
       +
               """Sanitize entry ID to be a safe filename."""

     

       3214
       3214
       +
               # Parse URL to get meaningful parts

     

       3215
       3215
       +
               parsed = urlparse(entry_id)

     

       3216
       3216
       +
       

     

       3217
       3217
       +
               # Start with the path component

     

       3218
       3218
       +
               if parsed.path:

     

       3219
       3219
       +
                   # Remove leading slash and replace problematic characters

     

       3220
       3220
       +
                   safe_id = parsed.path.lstrip('/').replace('/', '_').replace('\\', '_')

     

       3221
       3221
       +
               else:

     

       3222
       3222
       +
                   # Use the entire ID as fallback

     

       3223
       3223
       +
                   safe_id = entry_id

     

       3224
       3224
       +
       

     

       3225
       3225
       +
               # Replace problematic characters

     

       3226
       3226
       +
               safe_chars = []

     

       3227
       3227
       +
               for char in safe_id:

     

       3228
       3228
       +
                   if char.isalnum() or char in '-_.':

     

       3229
       3229
       +
                       safe_chars.append(char)

     

       3230
       3230
       +
                   else:

     

       3231
       3231
       +
                       safe_chars.append('_')

     

       3232
       3232
       +
       

     

       3233
       3233
       +
               safe_id = ''.join(safe_chars)

     

       3234
       3234
       +
       

     

       3235
       3235
       +
               # Ensure it's not too long (max 200 chars)

     

       3236
       3236
       +
               if len(safe_id) > 200:

     

       3237
       3237
       +
                   safe_id = safe_id[:200]

     

       3238
       3238
       +
       

     

       3239
       3239
       +
               # Ensure it's not empty

     

       3240
       3240
       +
               if not safe_id:

     

       3241
       3241
       +
                   safe_id = "entry"

     

       3242
       3242
       +
       

     

       3243
       3243
       +
               return safe_id

     

       3244
       3244
       +
       </file>

     

       3245
       3245
       +
       

     

       3246
       3246
       +
       <file path="src/thicket/core/reference_parser.py">

     

       3247
       3247
       +
       """Reference detection and parsing for blog entries."""

     

       3248
       3248
       +
       

     

       3249
       3249
       +
       import re

     

       3250
       3250
       +
       from typing import Optional

     

       3251
       3251
       +
       from urllib.parse import urlparse

     

       3252
       3252
       +
       

     

       3253
       3253
       +
       from ..models import AtomEntry

     

       3254
       3254
       +
       

     

       3255
       3255
       +
       

     

       3256
       3256
       +
       class BlogReference:

     

       3257
       3257
       +
           """Represents a reference from one blog entry to another."""

     

       3258
       3258
       +
       

     

       3259
       3259
       +
           def __init__(

     

       3260
       3260
       +
               self,

     

       3261
       3261
       +
               source_entry_id: str,

     

       3262
       3262
       +
               source_username: str,

     

       3263
       3263
       +
               target_url: str,

     

       3264
       3264
       +
               target_username: Optional[str] = None,

     

       3265
       3265
       +
               target_entry_id: Optional[str] = None,

     

       3266
       3266
       +
           ):

     

       3267
       3267
       +
               self.source_entry_id = source_entry_id

     

       3268
       3268
       +
               self.source_username = source_username

     

       3269
       3269
       +
               self.target_url = target_url

     

       3270
       3270
       +
               self.target_username = target_username

     

       3271
       3271
       +
               self.target_entry_id = target_entry_id

     

       3272
       3272
       +
       

     

       3273
       3273
       +
           def to_dict(self) -> dict:

     

       3274
       3274
       +
               """Convert to dictionary for JSON serialization."""

     

       3275
       3275
       +
               result = {

     

       3276
       3276
       +
                   "source_entry_id": self.source_entry_id,

     

       3277
       3277
       +
                   "source_username": self.source_username,

     

       3278
       3278
       +
                   "target_url": self.target_url,

     

       3279
       3279
       +
               }

     

       3280
       3280
       +
       

     

       3281
       3281
       +
               # Only include optional fields if they are not None

     

       3282
       3282
       +
               if self.target_username is not None:

     

       3283
       3283
       +
                   result["target_username"] = self.target_username

     

       3284
       3284
       +
               if self.target_entry_id is not None:

     

       3285
       3285
       +
                   result["target_entry_id"] = self.target_entry_id

     

       3286
       3286
       +
       

     

       3287
       3287
       +
               return result

     

       3288
       3288
       +
       

     

       3289
       3289
       +
           @classmethod

     

       3290
       3290
       +
           def from_dict(cls, data: dict) -> "BlogReference":

     

       3291
       3291
       +
               """Create from dictionary."""

     

       3292
       3292
       +
               return cls(

     

       3293
       3293
       +
                   source_entry_id=data["source_entry_id"],

     

       3294
       3294
       +
                   source_username=data["source_username"],

     

       3295
       3295
       +
                   target_url=data["target_url"],

     

       3296
       3296
       +
                   target_username=data.get("target_username"),

     

       3297
       3297
       +
                   target_entry_id=data.get("target_entry_id"),

     

       3298
       3298
       +
               )

     

       3299
       3299
       +
       

     

       3300
       3300
       +
       

     

       3301
       3301
       +
       class ReferenceIndex:

     

       3302
       3302
       +
           """Index of blog-to-blog references for creating threaded views."""

     

       3303
       3303
       +
       

     

       3304
       3304
       +
           def __init__(self):

     

       3305
       3305
       +
               self.references: list[BlogReference] = []

     

       3306
       3306
       +
               self.outbound_refs: dict[

     

       3307
       3307
       +
                   str, list[BlogReference]

     

       3308
       3308
       +
               ] = {}  # entry_id -> outbound refs

     

       3309
       3309
       +
               self.inbound_refs: dict[

     

       3310
       3310
       +
                   str, list[BlogReference]

     

       3311
       3311
       +
               ] = {}  # entry_id -> inbound refs

     

       3312
       3312
       +
               self.user_domains: dict[str, set[str]] = {}  # username -> set of domains

     

       3313
       3313
       +
       

     

       3314
       3314
       +
           def add_reference(self, ref: BlogReference) -> None:

     

       3315
       3315
       +
               """Add a reference to the index."""

     

       3316
       3316
       +
               self.references.append(ref)

     

       3317
       3317
       +
       

     

       3318
       3318
       +
               # Update outbound references

     

       3319
       3319
       +
               source_key = f"{ref.source_username}:{ref.source_entry_id}"

     

       3320
       3320
       +
               if source_key not in self.outbound_refs:

     

       3321
       3321
       +
                   self.outbound_refs[source_key] = []

     

       3322
       3322
       +
               self.outbound_refs[source_key].append(ref)

     

       3323
       3323
       +
       

     

       3324
       3324
       +
               # Update inbound references if we can identify the target

     

       3325
       3325
       +
               if ref.target_username and ref.target_entry_id:

     

       3326
       3326
       +
                   target_key = f"{ref.target_username}:{ref.target_entry_id}"

     

       3327
       3327
       +
                   if target_key not in self.inbound_refs:

     

       3328
       3328
       +
                       self.inbound_refs[target_key] = []

     

       3329
       3329
       +
                   self.inbound_refs[target_key].append(ref)

     

       3330
       3330
       +
       

     

       3331
       3331
       +
           def get_outbound_refs(self, username: str, entry_id: str) -> list[BlogReference]:

     

       3332
       3332
       +
               """Get all outbound references from an entry."""

     

       3333
       3333
       +
               key = f"{username}:{entry_id}"

     

       3334
       3334
       +
               return self.outbound_refs.get(key, [])

     

       3335
       3335
       +
       

     

       3336
       3336
       +
           def get_inbound_refs(self, username: str, entry_id: str) -> list[BlogReference]:

     

       3337
       3337
       +
               """Get all inbound references to an entry."""

     

       3338
       3338
       +
               key = f"{username}:{entry_id}"

     

       3339
       3339
       +
               return self.inbound_refs.get(key, [])

     

       3340
       3340
       +
       

     

       3341
       3341
       +
           def get_thread_members(self, username: str, entry_id: str) -> set[tuple[str, str]]:

     

       3342
       3342
       +
               """Get all entries that are part of the same thread."""

     

       3343
       3343
       +
               visited = set()

     

       3344
       3344
       +
               to_visit = [(username, entry_id)]

     

       3345
       3345
       +
               thread_members = set()

     

       3346
       3346
       +
       

     

       3347
       3347
       +
               while to_visit:

     

       3348
       3348
       +
                   current_user, current_entry = to_visit.pop()

     

       3349
       3349
       +
                   if (current_user, current_entry) in visited:

     

       3350
       3350
       +
                       continue

     

       3351
       3351
       +
       

     

       3352
       3352
       +
                   visited.add((current_user, current_entry))

     

       3353
       3353
       +
                   thread_members.add((current_user, current_entry))

     

       3354
       3354
       +
       

     

       3355
       3355
       +
                   # Add outbound references

     

       3356
       3356
       +
                   for ref in self.get_outbound_refs(current_user, current_entry):

     

       3357
       3357
       +
                       if ref.target_username and ref.target_entry_id:

     

       3358
       3358
       +
                           to_visit.append((ref.target_username, ref.target_entry_id))

     

       3359
       3359
       +
       

     

       3360
       3360
       +
                   # Add inbound references

     

       3361
       3361
       +
                   for ref in self.get_inbound_refs(current_user, current_entry):

     

       3362
       3362
       +
                       to_visit.append((ref.source_username, ref.source_entry_id))

     

       3363
       3363
       +
       

     

       3364
       3364
       +
               return thread_members

     

       3365
       3365
       +
       

     

       3366
       3366
       +
           def to_dict(self) -> dict:

     

       3367
       3367
       +
               """Convert to dictionary for JSON serialization."""

     

       3368
       3368
       +
               return {

     

       3369
       3369
       +
                   "references": [ref.to_dict() for ref in self.references],

     

       3370
       3370
       +
                   "user_domains": {k: list(v) for k, v in self.user_domains.items()},

     

       3371
       3371
       +
               }

     

       3372
       3372
       +
       

     

       3373
       3373
       +
           @classmethod

     

       3374
       3374
       +
           def from_dict(cls, data: dict) -> "ReferenceIndex":

     

       3375
       3375
       +
               """Create from dictionary."""

     

       3376
       3376
       +
               index = cls()

     

       3377
       3377
       +
               for ref_data in data.get("references", []):

     

       3378
       3378
       +
                   ref = BlogReference.from_dict(ref_data)

     

       3379
       3379
       +
                   index.add_reference(ref)

     

       3380
       3380
       +
       

     

       3381
       3381
       +
               for username, domains in data.get("user_domains", {}).items():

     

       3382
       3382
       +
                   index.user_domains[username] = set(domains)

     

       3383
       3383
       +
       

     

       3384
       3384
       +
               return index

     

       3385
       3385
       +
       

     

       3386
       3386
       +
       

     

       3387
       3387
       +
       class ReferenceParser:

     

       3388
       3388
       +
           """Parses blog entries to detect references to other blogs."""

     

       3389
       3389
       +
       

     

       3390
       3390
       +
           def __init__(self):

     

       3391
       3391
       +
               # Common blog platforms and patterns

     

       3392
       3392
       +
               self.blog_patterns = [

     

       3393
       3393
       +
                   r"https?://[^/]+\.(?:org|com|net|io|dev|me|co\.uk)/.*",  # Common blog domains

     

       3394
       3394
       +
                   r"https?://[^/]+\.github\.io/.*",  # GitHub Pages

     

       3395
       3395
       +
                   r"https?://[^/]+\.substack\.com/.*",  # Substack

     

       3396
       3396
       +
                   r"https?://medium\.com/.*",  # Medium

     

       3397
       3397
       +
                   r"https?://[^/]+\.wordpress\.com/.*",  # WordPress.com

     

       3398
       3398
       +
                   r"https?://[^/]+\.blogspot\.com/.*",  # Blogger

     

       3399
       3399
       +
               ]

     

       3400
       3400
       +
       

     

       3401
       3401
       +
               # Compile regex patterns

     

       3402
       3402
       +
               self.link_pattern = re.compile(

     

       3403
       3403
       +
                   r'<a[^>]+href="([^"]+)"[^>]*>(.*?)</a>', re.IGNORECASE | re.DOTALL

     

       3404
       3404
       +
               )

     

       3405
       3405
       +
               self.url_pattern = re.compile(r'https?://[^\s<>"]+')

     

       3406
       3406
       +
       

     

       3407
       3407
       +
           def extract_links_from_html(self, html_content: str) -> list[tuple[str, str]]:

     

       3408
       3408
       +
               """Extract all links from HTML content."""

     

       3409
       3409
       +
               links = []

     

       3410
       3410
       +
       

     

       3411
       3411
       +
               # Extract links from <a> tags

     

       3412
       3412
       +
               for match in self.link_pattern.finditer(html_content):

     

       3413
       3413
       +
                   url = match.group(1)

     

       3414
       3414
       +
                   text = re.sub(

     

       3415
       3415
       +
                       r"<[^>]+>", "", match.group(2)

     

       3416
       3416
       +
                   ).strip()  # Remove HTML tags from link text

     

       3417
       3417
       +
                   links.append((url, text))

     

       3418
       3418
       +
       

     

       3419
       3419
       +
               return links

     

       3420
       3420
       +
       

     

       3421
       3421
       +
           def is_blog_url(self, url: str) -> bool:

     

       3422
       3422
       +
               """Check if a URL likely points to a blog post."""

     

       3423
       3423
       +
               for pattern in self.blog_patterns:

     

       3424
       3424
       +
                   if re.match(pattern, url):

     

       3425
       3425
       +
                       return True

     

       3426
       3426
       +
               return False

     

       3427
       3427
       +
       

     

       3428
       3428
       +
           def _is_likely_blog_post_url(self, url: str) -> bool:

     

       3429
       3429
       +
               """Check if a same-domain URL likely points to a blog post (not CSS, images, etc.)."""

     

       3430
       3430
       +
               parsed_url = urlparse(url)

     

       3431
       3431
       +
               path = parsed_url.path.lower()

     

       3432
       3432
       +
       

     

       3433
       3433
       +
               # Skip obvious non-blog content

     

       3434
       3434
       +
               if any(path.endswith(ext) for ext in ['.css', '.js', '.png', '.jpg', '.jpeg', '.gif', '.svg', '.ico', '.pdf', '.xml', '.json']):

     

       3435
       3435
       +
                   return False

     

       3436
       3436
       +
       

     

       3437
       3437
       +
               # Skip common non-blog paths

     

       3438
       3438
       +
               if any(segment in path for segment in ['/static/', '/assets/', '/css/', '/js/', '/images/', '/img/', '/media/', '/uploads/']):

     

       3439
       3439
       +
                   return False

     

       3440
       3440
       +
       

     

       3441
       3441
       +
               # Skip fragment-only links (same page anchors)

     

       3442
       3442
       +
               if not path or path == '/':

     

       3443
       3443
       +
                   return False

     

       3444
       3444
       +
       

     

       3445
       3445
       +
               # Look for positive indicators of blog posts

     

       3446
       3446
       +
               # Common blog post patterns: dates, slugs, post indicators

     

       3447
       3447
       +
               blog_indicators = [

     

       3448
       3448
       +
                   r'/\d{4}/',  # Year in path

     

       3449
       3449
       +
                   r'/\d{4}/\d{2}/',  # Year/month in path

     

       3450
       3450
       +
                   r'/blog/',

     

       3451
       3451
       +
                   r'/post/',

     

       3452
       3452
       +
                   r'/posts/',

     

       3453
       3453
       +
                   r'/articles?/',

     

       3454
       3454
       +
                   r'/notes?/',

     

       3455
       3455
       +
                   r'/entries/',

     

       3456
       3456
       +
                   r'/writing/',

     

       3457
       3457
       +
               ]

     

       3458
       3458
       +
       

     

       3459
       3459
       +
               for pattern in blog_indicators:

     

       3460
       3460
       +
                   if re.search(pattern, path):

     

       3461
       3461
       +
                       return True

     

       3462
       3462
       +
       

     

       3463
       3463
       +
               # If it has a reasonable path depth and doesn't match exclusions, likely a blog post

     

       3464
       3464
       +
               path_segments = [seg for seg in path.split('/') if seg]

     

       3465
       3465
       +
               return len(path_segments) >= 1  # At least one meaningful path segment

     

       3466
       3466
       +
       

     

       3467
       3467
       +
           def resolve_target_user(

     

       3468
       3468
       +
               self, url: str, user_domains: dict[str, set[str]]

     

       3469
       3469
       +
           ) -> Optional[str]:

     

       3470
       3470
       +
               """Try to resolve a URL to a known user based on domain mapping."""

     

       3471
       3471
       +
               parsed_url = urlparse(url)

     

       3472
       3472
       +
               domain = parsed_url.netloc.lower()

     

       3473
       3473
       +
       

     

       3474
       3474
       +
               for username, domains in user_domains.items():

     

       3475
       3475
       +
                   if domain in domains:

     

       3476
       3476
       +
                       return username

     

       3477
       3477
       +
       

     

       3478
       3478
       +
               return None

     

       3479
       3479
       +
       

     

       3480
       3480
       +
           def extract_references(

     

       3481
       3481
       +
               self, entry: AtomEntry, username: str, user_domains: dict[str, set[str]]

     

       3482
       3482
       +
           ) -> list[BlogReference]:

     

       3483
       3483
       +
               """Extract all blog references from an entry."""

     

       3484
       3484
       +
               references = []

     

       3485
       3485
       +
       

     

       3486
       3486
       +
               # Combine all text content for analysis

     

       3487
       3487
       +
               content_to_search = []

     

       3488
       3488
       +
               if entry.content:

     

       3489
       3489
       +
                   content_to_search.append(entry.content)

     

       3490
       3490
       +
               if entry.summary:

     

       3491
       3491
       +
                   content_to_search.append(entry.summary)

     

       3492
       3492
       +
       

     

       3493
       3493
       +
               for content in content_to_search:

     

       3494
       3494
       +
                   links = self.extract_links_from_html(content)

     

       3495
       3495
       +
       

     

       3496
       3496
       +
                   for url, _link_text in links:

     

       3497
       3497
       +
                       entry_domain = (

     

       3498
       3498
       +
                           urlparse(str(entry.link)).netloc.lower() if entry.link else ""

     

       3499
       3499
       +
                       )

     

       3500
       3500
       +
                       link_domain = urlparse(url).netloc.lower()

     

       3501
       3501
       +
       

     

       3502
       3502
       +
                       # Check if this looks like a blog URL

     

       3503
       3503
       +
                       if not self.is_blog_url(url):

     

       3504
       3504
       +
                           continue

     

       3505
       3505
       +
       

     

       3506
       3506
       +
                       # For same-domain links, apply additional filtering to avoid non-blog content

     

       3507
       3507
       +
                       if link_domain == entry_domain:

     

       3508
       3508
       +
                           # Only include same-domain links that look like blog posts

     

       3509
       3509
       +
                           if not self._is_likely_blog_post_url(url):

     

       3510
       3510
       +
                               continue

     

       3511
       3511
       +
       

     

       3512
       3512
       +
                       # Try to resolve to a known user

     

       3513
       3513
       +
                       if link_domain == entry_domain:

     

       3514
       3514
       +
                           # Same domain - target user is the same as source user

     

       3515
       3515
       +
                           target_username: Optional[str] = username

     

       3516
       3516
       +
                       else:

     

       3517
       3517
       +
                           # Different domain - try to resolve

     

       3518
       3518
       +
                           target_username = self.resolve_target_user(url, user_domains)

     

       3519
       3519
       +
       

     

       3520
       3520
       +
                       ref = BlogReference(

     

       3521
       3521
       +
                           source_entry_id=entry.id,

     

       3522
       3522
       +
                           source_username=username,

     

       3523
       3523
       +
                           target_url=url,

     

       3524
       3524
       +
                           target_username=target_username,

     

       3525
       3525
       +
                           target_entry_id=None,  # Will be resolved later if possible

     

       3526
       3526
       +
                       )

     

       3527
       3527
       +
       

     

       3528
       3528
       +
                       references.append(ref)

     

       3529
       3529
       +
       

     

       3530
       3530
       +
               return references

     

       3531
       3531
       +
       

     

       3532
       3532
       +
           def build_user_domain_mapping(self, git_store: "GitStore") -> dict[str, set[str]]:

     

       3533
       3533
       +
               """Build mapping of usernames to their known domains."""

     

       3534
       3534
       +
               user_domains = {}

     

       3535
       3535
       +
               index = git_store._load_index()

     

       3536
       3536
       +
       

     

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

     

       3538
       3538
       +
                   domains = set()

     

       3539
       3539
       +
       

     

       3540
       3540
       +
                   # Add domains from feeds

     

       3541
       3541
       +
                   for feed_url in user_metadata.feeds:

     

       3542
       3542
       +
                       domain = urlparse(feed_url).netloc.lower()

     

       3543
       3543
       +
                       if domain:

     

       3544
       3544
       +
                           domains.add(domain)

     

       3545
       3545
       +
       

     

       3546
       3546
       +
                   # Add domain from homepage

     

       3547
       3547
       +
                   if user_metadata.homepage:

     

       3548
       3548
       +
                       domain = urlparse(str(user_metadata.homepage)).netloc.lower()

     

       3549
       3549
       +
                       if domain:

     

       3550
       3550
       +
                           domains.add(domain)

     

       3551
       3551
       +
       

     

       3552
       3552
       +
                   user_domains[username] = domains

     

       3553
       3553
       +
       

     

       3554
       3554
       +
               return user_domains

     

       3555
       3555
       +
       

     

       3556
       3556
       +
           def _build_url_to_entry_mapping(self, git_store: "GitStore") -> dict[str, str]:

     

       3557
       3557
       +
               """Build a comprehensive mapping from URLs to entry IDs using git store data.

     

       3558
       3558
       +
               

     

       3559
       3559
       +
               This creates a bidirectional mapping that handles:

     

       3560
       3560
       +
               - Entry link URLs -> Entry IDs

     

       3561
       3561
       +
               - URL variations (with/without www, http/https)

     

       3562
       3562
       +
               - Multiple URLs pointing to the same entry

     

       3563
       3563
       +
               """

     

       3564
       3564
       +
               url_to_entry: dict[str, str] = {}

     

       3565
       3565
       +
       

     

       3566
       3566
       +
               # Load index to get all users

     

       3567
       3567
       +
               index = git_store._load_index()

     

       3568
       3568
       +
       

     

       3569
       3569
       +
               for username in index.users.keys():

     

       3570
       3570
       +
                   entries = git_store.list_entries(username)

     

       3571
       3571
       +
       

     

       3572
       3572
       +
                   for entry in entries:

     

       3573
       3573
       +
                       if entry.link:

     

       3574
       3574
       +
                           link_url = str(entry.link)

     

       3575
       3575
       +
                           entry_id = entry.id

     

       3576
       3576
       +
       

     

       3577
       3577
       +
                           # Map the canonical link URL

     

       3578
       3578
       +
                           url_to_entry[link_url] = entry_id

     

       3579
       3579
       +
       

     

       3580
       3580
       +
                           # Handle common URL variations

     

       3581
       3581
       +
                           parsed = urlparse(link_url)

     

       3582
       3582
       +
                           if parsed.netloc and parsed.path:

     

       3583
       3583
       +
                               # Add version without www

     

       3584
       3584
       +
                               if parsed.netloc.startswith('www.'):

     

       3585
       3585
       +
                                   no_www_url = f"{parsed.scheme}://{parsed.netloc[4:]}{parsed.path}"

     

       3586
       3586
       +
                                   if parsed.query:

     

       3587
       3587
       +
                                       no_www_url += f"?{parsed.query}"

     

       3588
       3588
       +
                                   if parsed.fragment:

     

       3589
       3589
       +
                                       no_www_url += f"#{parsed.fragment}"

     

       3590
       3590
       +
                                   url_to_entry[no_www_url] = entry_id

     

       3591
       3591
       +
       

     

       3592
       3592
       +
                               # Add version with www if not present

     

       3593
       3593
       +
                               elif not parsed.netloc.startswith('www.'):

     

       3594
       3594
       +
                                   www_url = f"{parsed.scheme}://www.{parsed.netloc}{parsed.path}"

     

       3595
       3595
       +
                                   if parsed.query:

     

       3596
       3596
       +
                                       www_url += f"?{parsed.query}"

     

       3597
       3597
       +
                                   if parsed.fragment:

     

       3598
       3598
       +
                                       www_url += f"#{parsed.fragment}"

     

       3599
       3599
       +
                                   url_to_entry[www_url] = entry_id

     

       3600
       3600
       +
       

     

       3601
       3601
       +
                               # Add http/https variations

     

       3602
       3602
       +
                               if parsed.scheme == 'https':

     

       3603
       3603
       +
                                   http_url = link_url.replace('https://', 'http://', 1)

     

       3604
       3604
       +
                                   url_to_entry[http_url] = entry_id

     

       3605
       3605
       +
                               elif parsed.scheme == 'http':

     

       3606
       3606
       +
                                   https_url = link_url.replace('http://', 'https://', 1)

     

       3607
       3607
       +
                                   url_to_entry[https_url] = entry_id

     

       3608
       3608
       +
       

     

       3609
       3609
       +
               return url_to_entry

     

       3610
       3610
       +
       

     

       3611
       3611
       +
           def _normalize_url(self, url: str) -> str:

     

       3612
       3612
       +
               """Normalize URL for consistent matching.

     

       3613
       3613
       +
               

     

       3614
       3614
       +
               Handles common variations like trailing slashes, fragments, etc.

     

       3615
       3615
       +
               """

     

       3616
       3616
       +
               parsed = urlparse(url)

     

       3617
       3617
       +
       

     

       3618
       3618
       +
               # Remove trailing slash from path

     

       3619
       3619
       +
               path = parsed.path.rstrip('/') if parsed.path != '/' else parsed.path

     

       3620
       3620
       +
       

     

       3621
       3621
       +
               # Reconstruct without fragment for consistent matching

     

       3622
       3622
       +
               normalized = f"{parsed.scheme}://{parsed.netloc}{path}"

     

       3623
       3623
       +
               if parsed.query:

     

       3624
       3624
       +
                   normalized += f"?{parsed.query}"

     

       3625
       3625
       +
       

     

       3626
       3626
       +
               return normalized

     

       3627
       3627
       +
       

     

       3628
       3628
       +
           def resolve_target_entry_ids(

     

       3629
       3629
       +
               self, references: list[BlogReference], git_store: "GitStore"

     

       3630
       3630
       +
           ) -> list[BlogReference]:

     

       3631
       3631
       +
               """Resolve target_entry_id for references using comprehensive URL mapping."""

     

       3632
       3632
       +
               resolved_refs = []

     

       3633
       3633
       +
       

     

       3634
       3634
       +
               # Build comprehensive URL to entry ID mapping

     

       3635
       3635
       +
               url_to_entry = self._build_url_to_entry_mapping(git_store)

     

       3636
       3636
       +
       

     

       3637
       3637
       +
               for ref in references:

     

       3638
       3638
       +
                   # If we already have a target_entry_id, keep the reference as-is

     

       3639
       3639
       +
                   if ref.target_entry_id is not None:

     

       3640
       3640
       +
                       resolved_refs.append(ref)

     

       3641
       3641
       +
                       continue

     

       3642
       3642
       +
       

     

       3643
       3643
       +
                   # If we don't have a target_username, we can't resolve it

     

       3644
       3644
       +
                   if ref.target_username is None:

     

       3645
       3645
       +
                       resolved_refs.append(ref)

     

       3646
       3646
       +
                       continue

     

       3647
       3647
       +
       

     

       3648
       3648
       +
                   # Try to resolve using URL mapping

     

       3649
       3649
       +
                   resolved_entry_id = None

     

       3650
       3650
       +
       

     

       3651
       3651
       +
                   # First, try exact match

     

       3652
       3652
       +
                   if ref.target_url in url_to_entry:

     

       3653
       3653
       +
                       resolved_entry_id = url_to_entry[ref.target_url]

     

       3654
       3654
       +
                   else:

     

       3655
       3655
       +
                       # Try normalized URL matching

     

       3656
       3656
       +
                       normalized_target = self._normalize_url(ref.target_url)

     

       3657
       3657
       +
                       if normalized_target in url_to_entry:

     

       3658
       3658
       +
                           resolved_entry_id = url_to_entry[normalized_target]

     

       3659
       3659
       +
                       else:

     

       3660
       3660
       +
                           # Try URL variations

     

       3661
       3661
       +
                           for mapped_url, entry_id in url_to_entry.items():

     

       3662
       3662
       +
                               if self._normalize_url(mapped_url) == normalized_target:

     

       3663
       3663
       +
                                   resolved_entry_id = entry_id

     

       3664
       3664
       +
                                   break

     

       3665
       3665
       +
       

     

       3666
       3666
       +
                   # Verify the resolved entry belongs to the target username

     

       3667
       3667
       +
                   if resolved_entry_id:

     

       3668
       3668
       +
                       # Double-check by loading the actual entry

     

       3669
       3669
       +
                       entries = git_store.list_entries(ref.target_username)

     

       3670
       3670
       +
                       entry_found = any(entry.id == resolved_entry_id for entry in entries)

     

       3671
       3671
       +
                       if not entry_found:

     

       3672
       3672
       +
                           resolved_entry_id = None

     

       3673
       3673
       +
       

     

       3674
       3674
       +
                   # Create a new reference with the resolved target_entry_id

     

       3675
       3675
       +
                   resolved_ref = BlogReference(

     

       3676
       3676
       +
                       source_entry_id=ref.source_entry_id,

     

       3677
       3677
       +
                       source_username=ref.source_username,

     

       3678
       3678
       +
                       target_url=ref.target_url,

     

       3679
       3679
       +
                       target_username=ref.target_username,

     

       3680
       3680
       +
                       target_entry_id=resolved_entry_id,

     

       3681
       3681
       +
                   )

     

       3682
       3682
       +
                   resolved_refs.append(resolved_ref)

     

       3683
       3683
       +
       

     

       3684
       3684
       +
               return resolved_refs

     

       3685
       3685
       +
       </file>

     

       3686
       3686
       +
       

     

       3687
       3687
       +
       <file path="src/thicket/models/__init__.py">

     

       3688
       3688
       +
       """Data models for thicket."""

     

       3689
       3689
       +
       

     

       3690
       3690
       +
       from .config import ThicketConfig, UserConfig

     

       3691
       3691
       +
       from .feed import AtomEntry, DuplicateMap, FeedMetadata

     

       3692
       3692
       +
       from .user import GitStoreIndex, UserMetadata

     

       3693
       3693
       +
       

     

       3694
       3694
       +
       __all__ = [

     

       3695
       3695
       +
           "ThicketConfig",

     

       3696
       3696
       +
           "UserConfig",

     

       3697
       3697
       +
           "AtomEntry",

     

       3698
       3698
       +
           "DuplicateMap",

     

       3699
       3699
       +
           "FeedMetadata",

     

       3700
       3700
       +
           "GitStoreIndex",

     

       3701
       3701
       +
           "UserMetadata",

     

       3702
       3702
       +
       ]

     

       3703
       3703
       +
       </file>

     

       3704
       3704
       +
       

     

       3705
       3705
       +
       <file path="src/thicket/models/feed.py">

     

       3706
       3706
       +
       """Feed and entry models for thicket."""

     

       3707
       3707
       +
       

     

       3708
       3708
       +
       from datetime import datetime

     

       3709
       3709
       +
       from typing import TYPE_CHECKING, Optional

     

       3710
       3710
       +
       

     

       3711
       3711
       +
       from pydantic import BaseModel, ConfigDict, EmailStr, HttpUrl

     

       3712
       3712
       +
       

     

       3713
       3713
       +
       if TYPE_CHECKING:

     

       3714
       3714
       +
           from .config import UserConfig

     

       3715
       3715
       +
       

     

       3716
       3716
       +
       

     

       3717
       3717
       +
       class AtomEntry(BaseModel):

     

       3718
       3718
       +
           """Represents an Atom feed entry stored in the Git repository."""

     

       3719
       3719
       +
       

     

       3720
       3720
       +
           model_config = ConfigDict(

     

       3721
       3721
       +
               json_encoders={datetime: lambda v: v.isoformat()},

     

       3722
       3722
       +
               str_strip_whitespace=True,

     

       3723
       3723
       +
           )

     

       3724
       3724
       +
       

     

       3725
       3725
       +
           id: str  # Original Atom ID

     

       3726
       3726
       +
           title: str

     

       3727
       3727
       +
           link: HttpUrl

     

       3728
       3728
       +
           updated: datetime

     

       3729
       3729
       +
           published: Optional[datetime] = None

     

       3730
       3730
       +
           summary: Optional[str] = None

     

       3731
       3731
       +
           content: Optional[str] = None  # Full body content from Atom entry

     

       3732
       3732
       +
           content_type: Optional[str] = "html"  # text, html, xhtml

     

       3733
       3733
       +
           author: Optional[dict] = None

     

       3734
       3734
       +
           categories: list[str] = []

     

       3735
       3735
       +
           rights: Optional[str] = None  # Copyright info

     

       3736
       3736
       +
           source: Optional[str] = None  # Source feed URL

     

       3737
       3737
       +
       

     

       3738
       3738
       +
       

     

       3739
       3739
       +
       class FeedMetadata(BaseModel):

     

       3740
       3740
       +
           """Metadata extracted from a feed for auto-discovery."""

     

       3741
       3741
       +
       

     

       3742
       3742
       +
           title: Optional[str] = None

     

       3743
       3743
       +
           author_name: Optional[str] = None

     

       3744
       3744
       +
           author_email: Optional[EmailStr] = None

     

       3745
       3745
       +
           author_uri: Optional[HttpUrl] = None

     

       3746
       3746
       +
           link: Optional[HttpUrl] = None

     

       3747
       3747
       +
           logo: Optional[HttpUrl] = None

     

       3748
       3748
       +
           icon: Optional[HttpUrl] = None

     

       3749
       3749
       +
           image_url: Optional[HttpUrl] = None

     

       3750
       3750
       +
           description: Optional[str] = None

     

       3751
       3751
       +
       

     

       3752
       3752
       +
           def to_user_config(self, username: str, feed_url: HttpUrl) -> "UserConfig":

     

       3753
       3753
       +
               """Convert discovered metadata to UserConfig with fallbacks."""

     

       3754
       3754
       +
               from .config import UserConfig

     

       3755
       3755
       +
       

     

       3756
       3756
       +
               return UserConfig(

     

       3757
       3757
       +
                   username=username,

     

       3758
       3758
       +
                   feeds=[feed_url],

     

       3759
       3759
       +
                   display_name=self.author_name or self.title,

     

       3760
       3760
       +
                   email=self.author_email,

     

       3761
       3761
       +
                   homepage=self.author_uri or self.link,

     

       3762
       3762
       +
                   icon=self.logo or self.icon or self.image_url,

     

       3763
       3763
       +
               )

     

       3764
       3764
       +
       

     

       3765
       3765
       +
       

     

       3766
       3766
       +
       class DuplicateMap(BaseModel):

     

       3767
       3767
       +
           """Maps duplicate entry IDs to canonical entry IDs."""

     

       3768
       3768
       +
       

     

       3769
       3769
       +
           duplicates: dict[str, str] = {}  # duplicate_id -> canonical_id

     

       3770
       3770
       +
           comment: str = "Entry IDs that map to the same canonical content"

     

       3771
       3771
       +
       

     

       3772
       3772
       +
           def add_duplicate(self, duplicate_id: str, canonical_id: str) -> None:

     

       3773
       3773
       +
               """Add a duplicate mapping."""

     

       3774
       3774
       +
               self.duplicates[duplicate_id] = canonical_id

     

       3775
       3775
       +
       

     

       3776
       3776
       +
           def remove_duplicate(self, duplicate_id: str) -> bool:

     

       3777
       3777
       +
               """Remove a duplicate mapping. Returns True if existed."""

     

       3778
       3778
       +
               return self.duplicates.pop(duplicate_id, None) is not None

     

       3779
       3779
       +
       

     

       3780
       3780
       +
           def get_canonical(self, entry_id: str) -> str:

     

       3781
       3781
       +
               """Get canonical ID for an entry (returns original if not duplicate)."""

     

       3782
       3782
       +
               return self.duplicates.get(entry_id, entry_id)

     

       3783
       3783
       +
       

     

       3784
       3784
       +
           def is_duplicate(self, entry_id: str) -> bool:

     

       3785
       3785
       +
               """Check if entry ID is marked as duplicate."""

     

       3786
       3786
       +
               return entry_id in self.duplicates

     

       3787
       3787
       +
       

     

       3788
       3788
       +
           def get_duplicates_for_canonical(self, canonical_id: str) -> list[str]:

     

       3789
       3789
       +
               """Get all duplicate IDs that map to a canonical ID."""

     

       3790
       3790
       +
               return [

     

       3791
       3791
       +
                   duplicate_id

     

       3792
       3792
       +
                   for duplicate_id, canonical in self.duplicates.items()

     

       3793
       3793
       +
                   if canonical == canonical_id

     

       3794
       3794
       +
               ]

     

       3795
       3795
       +
       </file>

     

       3796
       3796
       +
       

     

       3797
       3797
       +
       <file path="src/thicket/models/user.py">

     

       3798
       3798
       +
       """User metadata models for thicket."""

     

       3799
       3799
       +
       

     

       3800
       3800
       +
       from datetime import datetime

     

       3801
       3801
       +
       from typing import Optional

     

       3802
       3802
       +
       

     

       3803
       3803
       +
       from pydantic import BaseModel, ConfigDict

     

       3804
       3804
       +
       

     

       3805
       3805
       +
       

     

       3806
       3806
       +
       class UserMetadata(BaseModel):

     

       3807
       3807
       +
           """Metadata about a user stored in the Git repository."""

     

       3808
       3808
       +
       

     

       3809
       3809
       +
           model_config = ConfigDict(

     

       3810
       3810
       +
               json_encoders={datetime: lambda v: v.isoformat()},

     

       3811
       3811
       +
               str_strip_whitespace=True,

     

       3812
       3812
       +
           )

     

       3813
       3813
       +
       

     

       3814
       3814
       +
           username: str

     

       3815
       3815
       +
           display_name: Optional[str] = None

     

       3816
       3816
       +
           email: Optional[str] = None

     

       3817
       3817
       +
           homepage: Optional[str] = None

     

       3818
       3818
       +
           icon: Optional[str] = None

     

       3819
       3819
       +
           feeds: list[str] = []

     

       3820
       3820
       +
           directory: str  # Directory name in Git store

     

       3821
       3821
       +
           created: datetime

     

       3822
       3822
       +
           last_updated: datetime

     

       3823
       3823
       +
           entry_count: int = 0

     

       3824
       3824
       +
       

     

       3825
       3825
       +
           def update_timestamp(self) -> None:

     

       3826
       3826
       +
               """Update the last_updated timestamp to now."""

     

       3827
       3827
       +
               self.last_updated = datetime.now()

     

       3828
       3828
       +
       

     

       3829
       3829
       +
           def increment_entry_count(self, count: int = 1) -> None:

     

       3830
       3830
       +
               """Increment the entry count by the given amount."""

     

       3831
       3831
       +
               self.entry_count += count

     

       3832
       3832
       +
               self.update_timestamp()

     

       3833
       3833
       +
       

     

       3834
       3834
       +
       

     

       3835
       3835
       +
       class GitStoreIndex(BaseModel):

     

       3836
       3836
       +
           """Index of all users and their directories in the Git store."""

     

       3837
       3837
       +
       

     

       3838
       3838
       +
           model_config = ConfigDict(

     

       3839
       3839
       +
               json_encoders={datetime: lambda v: v.isoformat()}

     

       3840
       3840
       +
           )

     

       3841
       3841
       +
       

     

       3842
       3842
       +
           users: dict[str, UserMetadata] = {}  # username -> UserMetadata

     

       3843
       3843
       +
           created: datetime

     

       3844
       3844
       +
           last_updated: datetime

     

       3845
       3845
       +
           total_entries: int = 0

     

       3846
       3846
       +
       

     

       3847
       3847
       +
           def add_user(self, user_metadata: UserMetadata) -> None:

     

       3848
       3848
       +
               """Add or update a user in the index."""

     

       3849
       3849
       +
               self.users[user_metadata.username] = user_metadata

     

       3850
       3850
       +
               self.last_updated = datetime.now()

     

       3851
       3851
       +
       

     

       3852
       3852
       +
           def remove_user(self, username: str) -> bool:

     

       3853
       3853
       +
               """Remove a user from the index. Returns True if user existed."""

     

       3854
       3854
       +
               if username in self.users:

     

       3855
       3855
       +
                   del self.users[username]

     

       3856
       3856
       +
                   self.last_updated = datetime.now()

     

       3857
       3857
       +
                   return True

     

       3858
       3858
       +
               return False

     

       3859
       3859
       +
       

     

       3860
       3860
       +
           def get_user(self, username: str) -> Optional[UserMetadata]:

     

       3861
       3861
       +
               """Get user metadata by username."""

     

       3862
       3862
       +
               return self.users.get(username)

     

       3863
       3863
       +
       

     

       3864
       3864
       +
           def update_entry_count(self, username: str, count: int) -> None:

     

       3865
       3865
       +
               """Update entry count for a user and total."""

     

       3866
       3866
       +
               user = self.get_user(username)

     

       3867
       3867
       +
               if user:

     

       3868
       3868
       +
                   user.increment_entry_count(count)

     

       3869
       3869
       +
                   self.total_entries += count

     

       3870
       3870
       +
                   self.last_updated = datetime.now()

     

       3871
       3871
       +
       

     

       3872
       3872
       +
           def recalculate_totals(self) -> None:

     

       3873
       3873
       +
               """Recalculate total entries from all users."""

     

       3874
       3874
       +
               self.total_entries = sum(user.entry_count for user in self.users.values())

     

       3875
       3875
       +
               self.last_updated = datetime.now()

     

       3876
       3876
       +
       </file>

     

       3877
       3877
       +
       

     

       3878
       3878
       +
       <file path="src/thicket/utils/__init__.py">

     

       3879
       3879
       +
       """Utility modules for thicket."""

     

       3880
       3880
       +
       

     

       3881
       3881
       +
       # This module will contain shared utilities

     

       3882
       3882
       +
       # For now, it's empty but can be expanded with common functions

     

       3883
       3883
       +
       </file>

     

       3884
       3884
       +
       

     

       3885
       3885
       +
       <file path="src/thicket/__init__.py">

     

       3886
       3886
       +
       """Thicket: A CLI tool for persisting Atom/RSS feeds in Git repositories."""

     

       3887
       3887
       +
       

     

       3888
       3888
       +
       __version__ = "0.1.0"

     

       3889
       3889
       +
       __author__ = "thicket"

     

       3890
       3890
       +
       __email__ = "thicket@example.com"

     

       3891
       3891
       +
       </file>

     

       3892
       3892
       +
       

     

       3893
       3893
       +
       <file path="src/thicket/__main__.py">

     

       3894
       3894
       +
       """Entry point for running thicket as a module."""

     

       3895
       3895
       +
       

     

       3896
       3896
       +
       from .cli.main import app

     

       3897
       3897
       +
       

     

       3898
       3898
       +
       if __name__ == "__main__":

     

       3899
       3899
       +
           app()

     

       3900
       3900
       +
       </file>

     

       3901
       3901
       +
       

     

       3902
       3902
       +
       <file path=".gitignore">

     

       3903
       3903
       +
       # Byte-compiled / optimized / DLL files

     

       3904
       3904
       +
       __pycache__/

     

       3905
       3905
       +
       *.py[codz]

     

       3906
       3906
       +
       *$py.class

     

       3907
       3907
       +
       

     

       3908
       3908
       +
       # C extensions

     

       3909
       3909
       +
       *.so

     

       3910
       3910
       +
       

     

       3911
       3911
       +
       # Distribution / packaging

     

       3912
       3912
       +
       .Python

     

       3913
       3913
       +
       build/

     

       3914
       3914
       +
       develop-eggs/

     

       3915
       3915
       +
       dist/

     

       3916
       3916
       +
       downloads/

     

       3917
       3917
       +
       eggs/

     

       3918
       3918
       +
       .eggs/

     

       3919
       3919
       +
       lib/

     

       3920
       3920
       +
       lib64/

     

       3921
       3921
       +
       parts/

     

       3922
       3922
       +
       sdist/

     

       3923
       3923
       +
       var/

     

       3924
       3924
       +
       wheels/

     

       3925
       3925
       +
       share/python-wheels/

     

       3926
       3926
       +
       *.egg-info/

     

       3927
       3927
       +
       .installed.cfg

     

       3928
       3928
       +
       *.egg

     

       3929
       3929
       +
       MANIFEST

     

       3930
       3930
       +
       

     

       3931
       3931
       +
       # PyInstaller

     

       3932
       3932
       +
       #  Usually these files are written by a python script from a template

     

       3933
       3933
       +
       #  before PyInstaller builds the exe, so as to inject date/other infos into it.

     

       3934
       3934
       +
       *.manifest

     

       3935
       3935
       +
       *.spec

     

       3936
       3936
       +
       

     

       3937
       3937
       +
       # Installer logs

     

       3938
       3938
       +
       pip-log.txt

     

       3939
       3939
       +
       pip-delete-this-directory.txt

     

       3940
       3940
       +
       

     

       3941
       3941
       +
       # Unit test / coverage reports

     

       3942
       3942
       +
       htmlcov/

     

       3943
       3943
       +
       .tox/

     

       3944
       3944
       +
       .nox/

     

       3945
       3945
       +
       .coverage

     

       3946
       3946
       +
       .coverage.*

     

       3947
       3947
       +
       .cache

     

       3948
       3948
       +
       nosetests.xml

     

       3949
       3949
       +
       coverage.xml

     

       3950
       3950
       +
       *.cover

     

       3951
       3951
       +
       *.py.cover

     

       3952
       3952
       +
       .hypothesis/

     

       3953
       3953
       +
       .pytest_cache/

     

       3954
       3954
       +
       cover/

     

       3955
       3955
       +
       

     

       3956
       3956
       +
       # Translations

     

       3957
       3957
       +
       *.mo

     

       3958
       3958
       +
       *.pot

     

       3959
       3959
       +
       

     

       3960
       3960
       +
       # Django stuff:

     

       3961
       3961
       +
       *.log

     

       3962
       3962
       +
       local_settings.py

     

       3963
       3963
       +
       db.sqlite3

     

       3964
       3964
       +
       db.sqlite3-journal

     

       3965
       3965
       +
       

     

       3966
       3966
       +
       # Flask stuff:

     

       3967
       3967
       +
       instance/

     

       3968
       3968
       +
       .webassets-cache

     

       3969
       3969
       +
       

     

       3970
       3970
       +
       # Scrapy stuff:

     

       3971
       3971
       +
       .scrapy

     

       3972
       3972
       +
       

     

       3973
       3973
       +
       # Sphinx documentation

     

       3974
       3974
       +
       docs/_build/

     

       3975
       3975
       +
       

     

       3976
       3976
       +
       # PyBuilder

     

       3977
       3977
       +
       .pybuilder/

     

       3978
       3978
       +
       target/

     

       3979
       3979
       +
       

     

       3980
       3980
       +
       # Jupyter Notebook

     

       3981
       3981
       +
       .ipynb_checkpoints

     

       3982
       3982
       +
       

     

       3983
       3983
       +
       # IPython

     

       3984
       3984
       +
       profile_default/

     

       3985
       3985
       +
       ipython_config.py

     

       3986
       3986
       +
       

     

       3987
       3987
       +
       # pyenv

     

       3988
       3988
       +
       #   For a library or package, you might want to ignore these files since the code is

     

       3989
       3989
       +
       #   intended to run in multiple environments; otherwise, check them in:

     

       3990
       3990
       +
       # .python-version

     

       3991
       3991
       +
       

     

       3992
       3992
       +
       # pipenv

     

       3993
       3993
       +
       #   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.

     

       3994
       3994
       +
       #   However, in case of collaboration, if having platform-specific dependencies or dependencies

     

       3995
       3995
       +
       #   having no cross-platform support, pipenv may install dependencies that don't work, or not

     

       3996
       3996
       +
       #   install all needed dependencies.

     

       3997
       3997
       +
       #Pipfile.lock

     

       3998
       3998
       +
       

     

       3999
       3999
       +
       # UV

     

       4000
       4000
       +
       #   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.

     

       4001
       4001
       +
       #   This is especially recommended for binary packages to ensure reproducibility, and is more

     

       4002
       4002
       +
       #   commonly ignored for libraries.

     

       4003
       4003
       +
       #uv.lock

     

       4004
       4004
       +
       

     

       4005
       4005
       +
       # poetry

     

       4006
       4006
       +
       #   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.

     

       4007
       4007
       +
       #   This is especially recommended for binary packages to ensure reproducibility, and is more

     

       4008
       4008
       +
       #   commonly ignored for libraries.

     

       4009
       4009
       +
       #   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control

     

       4010
       4010
       +
       #poetry.lock

     

       4011
       4011
       +
       #poetry.toml

     

       4012
       4012
       +
       

     

       4013
       4013
       +
       # pdm

     

       4014
       4014
       +
       #   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.

     

       4015
       4015
       +
       #   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.

     

       4016
       4016
       +
       #   https://pdm-project.org/en/latest/usage/project/#working-with-version-control

     

       4017
       4017
       +
       #pdm.lock

     

       4018
       4018
       +
       #pdm.toml

     

       4019
       4019
       +
       .pdm-python

     

       4020
       4020
       +
       .pdm-build/

     

       4021
       4021
       +
       

     

       4022
       4022
       +
       # pixi

     

       4023
       4023
       +
       #   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.

     

       4024
       4024
       +
       #pixi.lock

     

       4025
       4025
       +
       #   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one

     

       4026
       4026
       +
       #   in the .venv directory. It is recommended not to include this directory in version control.

     

       4027
       4027
       +
       .pixi

     

       4028
       4028
       +
       

     

       4029
       4029
       +
       # PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm

     

       4030
       4030
       +
       __pypackages__/

     

       4031
       4031
       +
       

     

       4032
       4032
       +
       # Celery stuff

     

       4033
       4033
       +
       celerybeat-schedule

     

       4034
       4034
       +
       celerybeat.pid

     

       4035
       4035
       +
       

     

       4036
       4036
       +
       # SageMath parsed files

     

       4037
       4037
       +
       *.sage.py

     

       4038
       4038
       +
       

     

       4039
       4039
       +
       # Environments

     

       4040
       4040
       +
       .env

     

       4041
       4041
       +
       .envrc

     

       4042
       4042
       +
       .venv

     

       4043
       4043
       +
       env/

     

       4044
       4044
       +
       venv/

     

       4045
       4045
       +
       ENV/

     

       4046
       4046
       +
       env.bak/

     

       4047
       4047
       +
       venv.bak/

     

       4048
       4048
       +
       

     

       4049
       4049
       +
       # Spyder project settings

     

       4050
       4050
       +
       .spyderproject

     

       4051
       4051
       +
       .spyproject

     

       4052
       4052
       +
       

     

       4053
       4053
       +
       # Rope project settings

     

       4054
       4054
       +
       .ropeproject

     

       4055
       4055
       +
       

     

       4056
       4056
       +
       # mkdocs documentation

     

       4057
       4057
       +
       /site

     

       4058
       4058
       +
       

     

       4059
       4059
       +
       # mypy

     

       4060
       4060
       +
       .mypy_cache/

     

       4061
       4061
       +
       .dmypy.json

     

       4062
       4062
       +
       dmypy.json

     

       4063
       4063
       +
       

     

       4064
       4064
       +
       # Pyre type checker

     

       4065
       4065
       +
       .pyre/

     

       4066
       4066
       +
       

     

       4067
       4067
       +
       # pytype static type analyzer

     

       4068
       4068
       +
       .pytype/

     

       4069
       4069
       +
       

     

       4070
       4070
       +
       # Cython debug symbols

     

       4071
       4071
       +
       cython_debug/

     

       4072
       4072
       +
       

     

       4073
       4073
       +
       # PyCharm

     

       4074
       4074
       +
       #  JetBrains specific template is maintained in a separate JetBrains.gitignore that can

     

       4075
       4075
       +
       #  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore

     

       4076
       4076
       +
       #  and can be added to the global gitignore or merged into this file.  For a more nuclear

     

       4077
       4077
       +
       #  option (not recommended) you can uncomment the following to ignore the entire idea folder.

     

       4078
       4078
       +
       #.idea/

     

       4079
       4079
       +
       

     

       4080
       4080
       +
       # Abstra

     

       4081
       4081
       +
       # Abstra is an AI-powered process automation framework.

     

       4082
       4082
       +
       # Ignore directories containing user credentials, local state, and settings.

     

       4083
       4083
       +
       # Learn more at https://abstra.io/docs

     

       4084
       4084
       +
       .abstra/

     

       4085
       4085
       +
       

     

       4086
       4086
       +
       # Visual Studio Code

     

       4087
       4087
       +
       #  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 

     

       4088
       4088
       +
       #  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore

     

       4089
       4089
       +
       #  and can be added to the global gitignore or merged into this file. However, if you prefer, 

     

       4090
       4090
       +
       #  you could uncomment the following to ignore the entire vscode folder

     

       4091
       4091
       +
       # .vscode/

     

       4092
       4092
       +
       

     

       4093
       4093
       +
       # Ruff stuff:

     

       4094
       4094
       +
       .ruff_cache/

     

       4095
       4095
       +
       

     

       4096
       4096
       +
       # PyPI configuration file

     

       4097
       4097
       +
       .pypirc

     

       4098
       4098
       +
       

     

       4099
       4099
       +
       # Marimo

     

       4100
       4100
       +
       marimo/_static/

     

       4101
       4101
       +
       marimo/_lsp/

     

       4102
       4102
       +
       __marimo__/

     

       4103
       4103
       +
       

     

       4104
       4104
       +
       # Streamlit

     

       4105
       4105
       +
       .streamlit/secrets.toml

     

       4106
       4106
       +
       

     

       4107
       4107
       +
       thicket.yaml

     

       4108
       4108
       +
       </file>

     

       4109
       4109
       +
       

     

       4110
       4110
       +
       <file path="CLAUDE.md">

     

       4111
       4111
       +
       My goal is to build a CLI tool called thicket in Python that maintains a Git repository within which Atom feeds can be persisted, including their contents.

     

       4112
       4112
       +
       

     

       4113
       4113
       +
       # Python Environment and Package Management

     

       4114
       4114
       +
       

     

       4115
       4115
       +
       This project uses `uv` for Python package management and virtual environment handling.

     

       4116
       4116
       +
       

     

       4117
       4117
       +
       ## Running Commands

     

       4118
       4118
       +
       

     

       4119
       4119
       +
       ALWAYS use `uv run` to execute Python commands:

     

       4120
       4120
       +
       

     

       4121
       4121
       +
       - Run the CLI: `uv run -m thicket`

     

       4122
       4122
       +
       - Run tests: `uv run pytest`

     

       4123
       4123
       +
       - Type checking: `uv run mypy src/`

     

       4124
       4124
       +
       - Linting: `uv run ruff check src/`

     

       4125
       4125
       +
       - Format code: `uv run ruff format src/`

     

       4126
       4126
       +
       - Compile check: `uv run python -m py_compile <file>`

     

       4127
       4127
       +
       

     

       4128
       4128
       +
       ## Package Management

     

       4129
       4129
       +
       

     

       4130
       4130
       +
       - Add dependencies: `uv add <package>`

     

       4131
       4131
       +
       - Add dev dependencies: `uv add --dev <package>`

     

       4132
       4132
       +
       - Install dependencies: `uv sync`

     

       4133
       4133
       +
       - Update dependencies: `uv lock --upgrade`

     

       4134
       4134
       +
       

     

       4135
       4135
       +
       # Project Structure

     

       4136
       4136
       +
       

     

       4137
       4137
       +
       The configuration file specifies:

     

       4138
       4138
       +
       - the location of a git store

     

       4139
       4139
       +
       - a list of usernames and target Atom/RSS feed(s) and optional metadata about the username such as their email, homepage, icon and display name

     

       4140
       4140
       +
       - a cache directory to store temporary results such as feed downloads and their last modification date that speed up operations across runs of the tool

     

       4141
       4141
       +
       

     

       4142
       4142
       +
       The Git data store should:

     

       4143
       4143
       +
       - have a subdirectory per user

     

       4144
       4144
       +
       - within that directory, an entry per Atom entry indexed by the Atom id for that entry. The id should be sanitised consistently to be a safe filename. RSS feed should be normalized to Atom before storing it.

     

       4145
       4145
       +
       - within each entry file, the metadata of the Atom feed converted into a JSON format that preserves as much metadata as possible.

     

       4146
       4146
       +
       - have a JSON file in the Git repository that indexes the users, their associated directories within the Git repository, and any other metadata about that user from the config file

     

       4147
       4147
       +
       The CLI should be modern and use cool progress bars and any otfrom ecosystem libraries.

     

       4148
       4148
       +
       

     

       4149
       4149
       +
       The intention behind the Git repository is that it can be queried by other websites in order to build a webblog structure of comments that link to other blogs.

     

       4150
       4150
       +
       </file>

     

       4151
       4151
       +
       

     

       4152
       4152
       +
       <file path="pyproject.toml">

     

       4153
       4153
       +
       [build-system]

     

       4154
       4154
       +
       requires = ["hatchling"]

     

       4155
       4155
       +
       build-backend = "hatchling.build"

     

       4156
       4156
       +
       

     

       4157
       4157
       +
       [project]

     

       4158
       4158
       +
       name = "thicket"

     

       4159
       4159
       +
       dynamic = ["version"]

     

       4160
       4160
       +
       description = "A CLI tool for persisting Atom/RSS feeds in Git repositories"

     

       4161
       4161
       +
       readme = "README.md"

     

       4162
       4162
       +
       license = "MIT"

     

       4163
       4163
       +
       requires-python = ">=3.9"

     

       4164
       4164
       +
       authors = [

     

       4165
       4165
       +
           {name = "thicket", email = "thicket@example.com"},

     

       4166
       4166
       +
       ]

     

       4167
       4167
       +
       classifiers = [

     

       4168
       4168
       +
           "Development Status :: 3 - Alpha",

     

       4169
       4169
       +
           "Intended Audience :: Developers",

     

       4170
       4170
       +
           "License :: OSI Approved :: MIT License",

     

       4171
       4171
       +
           "Operating System :: OS Independent",

     

       4172
       4172
       +
           "Programming Language :: Python :: 3",

     

       4173
       4173
       +
           "Programming Language :: Python :: 3.9",

     

       4174
       4174
       +
           "Programming Language :: Python :: 3.10",

     

       4175
       4175
       +
           "Programming Language :: Python :: 3.11",

     

       4176
       4176
       +
           "Programming Language :: Python :: 3.12",

     

       4177
       4177
       +
           "Programming Language :: Python :: 3.13",

     

       4178
       4178
       +
           "Topic :: Internet :: WWW/HTTP :: Dynamic Content :: News/Diary",

     

       4179
       4179
       +
           "Topic :: Software Development :: Version Control :: Git",

     

       4180
       4180
       +
           "Topic :: Text Processing :: Markup :: XML",

     

       4181
       4181
       +
       ]

     

       4182
       4182
       +
       dependencies = [

     

       4183
       4183
       +
           "typer>=0.15.0",

     

       4184
       4184
       +
           "rich>=13.0.0",

     

       4185
       4185
       +
           "GitPython>=3.1.40",

     

       4186
       4186
       +
           "feedparser>=6.0.11",

     

       4187
       4187
       +
           "pydantic>=2.11.0",

     

       4188
       4188
       +
           "pydantic-settings>=2.10.0",

     

       4189
       4189
       +
           "httpx>=0.28.0",

     

       4190
       4190
       +
           "pendulum>=3.0.0",

     

       4191
       4191
       +
           "bleach>=6.0.0",

     

       4192
       4192
       +
           "platformdirs>=4.0.0",

     

       4193
       4193
       +
           "pyyaml>=6.0.0",

     

       4194
       4194
       +
           "email_validator",

     

       4195
       4195
       +
           "jinja2>=3.1.6",

     

       4196
       4196
       +
       ]

     

       4197
       4197
       +
       

     

       4198
       4198
       +
       [project.optional-dependencies]

     

       4199
       4199
       +
       dev = [

     

       4200
       4200
       +
           "pytest>=8.0.0",

     

       4201
       4201
       +
           "pytest-asyncio>=0.24.0",

     

       4202
       4202
       +
           "pytest-cov>=6.0.0",

     

       4203
       4203
       +
           "black>=24.0.0",

     

       4204
       4204
       +
           "ruff>=0.8.0",

     

       4205
       4205
       +
           "mypy>=1.13.0",

     

       4206
       4206
       +
           "types-PyYAML>=6.0.0",

     

       4207
       4207
       +
       ]

     

       4208
       4208
       +
       

     

       4209
       4209
       +
       [project.urls]

     

       4210
       4210
       +
       Homepage = "https://github.com/example/thicket"

     

       4211
       4211
       +
       Documentation = "https://github.com/example/thicket"

     

       4212
       4212
       +
       Repository = "https://github.com/example/thicket"

     

       4213
       4213
       +
       "Bug Tracker" = "https://github.com/example/thicket/issues"

     

       4214
       4214
       +
       

     

       4215
       4215
       +
       [project.scripts]

     

       4216
       4216
       +
       thicket = "thicket.cli.main:app"

     

       4217
       4217
       +
       

     

       4218
       4218
       +
       [tool.hatch.version]

     

       4219
       4219
       +
       path = "src/thicket/__init__.py"

     

       4220
       4220
       +
       

     

       4221
       4221
       +
       [tool.hatch.build.targets.wheel]

     

       4222
       4222
       +
       packages = ["src/thicket"]

     

       4223
       4223
       +
       

     

       4224
       4224
       +
       [tool.black]

     

       4225
       4225
       +
       line-length = 88

     

       4226
       4226
       +
       target-version = ['py39']

     

       4227
       4227
       +
       include = '\.pyi?$'

     

       4228
       4228
       +
       extend-exclude = '''

     

       4229
       4229
       +
       /(

     

       4230
       4230
       +
         # directories

     

       4231
       4231
       +
         \.eggs

     

       4232
       4232
       +
         | \.git

     

       4233
       4233
       +
         | \.hg

     

       4234
       4234
       +
         | \.mypy_cache

     

       4235
       4235
       +
         | \.tox

     

       4236
       4236
       +
         | \.venv

     

       4237
       4237
       +
         | build

     

       4238
       4238
       +
         | dist

     

       4239
       4239
       +
       )/

     

       4240
       4240
       +
       '''

     

       4241
       4241
       +
       

     

       4242
       4242
       +
       [tool.ruff]

     

       4243
       4243
       +
       target-version = "py39"

     

       4244
       4244
       +
       line-length = 88

     

       4245
       4245
       +
       

     

       4246
       4246
       +
       [tool.ruff.lint]

     

       4247
       4247
       +
       select = [

     

       4248
       4248
       +
           "E",  # pycodestyle errors

     

       4249
       4249
       +
           "W",  # pycodestyle warnings

     

       4250
       4250
       +
           "F",  # pyflakes

     

       4251
       4251
       +
           "I",  # isort

     

       4252
       4252
       +
           "B",  # flake8-bugbear

     

       4253
       4253
       +
           "C4", # flake8-comprehensions

     

       4254
       4254
       +
           "UP", # pyupgrade

     

       4255
       4255
       +
       ]

     

       4256
       4256
       +
       ignore = [

     

       4257
       4257
       +
           "E501",  # line too long, handled by black

     

       4258
       4258
       +
           "B008",  # do not perform function calls in argument defaults

     

       4259
       4259
       +
           "C901",  # too complex

     

       4260
       4260
       +
       ]

     

       4261
       4261
       +
       

     

       4262
       4262
       +
       [tool.ruff.lint.per-file-ignores]

     

       4263
       4263
       +
       "__init__.py" = ["F401"]

     

       4264
       4264
       +
       

     

       4265
       4265
       +
       [tool.mypy]

     

       4266
       4266
       +
       python_version = "3.9"

     

       4267
       4267
       +
       check_untyped_defs = true

     

       4268
       4268
       +
       disallow_any_generics = true

     

       4269
       4269
       +
       disallow_incomplete_defs = true

     

       4270
       4270
       +
       disallow_untyped_defs = true

     

       4271
       4271
       +
       no_implicit_optional = true

     

       4272
       4272
       +
       warn_redundant_casts = true

     

       4273
       4273
       +
       warn_unused_ignores = true

     

       4274
       4274
       +
       warn_return_any = true

     

       4275
       4275
       +
       strict_optional = true

     

       4276
       4276
       +
       

     

       4277
       4277
       +
       [[tool.mypy.overrides]]

     

       4278
       4278
       +
       module = [

     

       4279
       4279
       +
           "feedparser",

     

       4280
       4280
       +
           "git",

     

       4281
       4281
       +
           "bleach",

     

       4282
       4282
       +
       ]

     

       4283
       4283
       +
       ignore_missing_imports = true

     

       4284
       4284
       +
       

     

       4285
       4285
       +
       [tool.pytest.ini_options]

     

       4286
       4286
       +
       testpaths = ["tests"]

     

       4287
       4287
       +
       python_files = ["test_*.py"]

     

       4288
       4288
       +
       python_classes = ["Test*"]

     

       4289
       4289
       +
       python_functions = ["test_*"]

     

       4290
       4290
       +
       addopts = [

     

       4291
       4291
       +
           "-ra",

     

       4292
       4292
       +
           "--strict-markers",

     

       4293
       4293
       +
           "--strict-config",

     

       4294
       4294
       +
           "--cov=src/thicket",

     

       4295
       4295
       +
           "--cov-report=term-missing",

     

       4296
       4296
       +
           "--cov-report=html",

     

       4297
       4297
       +
           "--cov-report=xml",

     

       4298
       4298
       +
       ]

     

       4299
       4299
       +
       filterwarnings = [

     

       4300
       4300
       +
           "error",

     

       4301
       4301
       +
           "ignore::UserWarning",

     

       4302
       4302
       +
           "ignore::DeprecationWarning",

     

       4303
       4303
       +
       ]

     

       4304
       4304
       +
       markers = [

     

       4305
       4305
       +
           "slow: marks tests as slow (deselect with '-m \"not slow\"')",

     

       4306
       4306
       +
           "integration: marks tests as integration tests",

     

       4307
       4307
       +
       ]

     

       4308
       4308
       +
       

     

       4309
       4309
       +
       [tool.coverage.run]

     

       4310
       4310
       +
       source = ["src"]

     

       4311
       4311
       +
       branch = true

     

       4312
       4312
       +
       

     

       4313
       4313
       +
       [tool.coverage.report]

     

       4314
       4314
       +
       exclude_lines = [

     

       4315
       4315
       +
           "pragma: no cover",

     

       4316
       4316
       +
           "def __repr__",

     

       4317
       4317
       +
           "if self.debug:",

     

       4318
       4318
       +
           "if settings.DEBUG",

     

       4319
       4319
       +
           "raise AssertionError",

     

       4320
       4320
       +
           "raise NotImplementedError",

     

       4321
       4321
       +
           "if 0:",

     

       4322
       4322
       +
           "if __name__ == .__main__.:",

     

       4323
       4323
       +
           "class .*\\bProtocol\\):",

     

       4324
       4324
       +
           "@(abc\\.)?abstractmethod",

     

       4325
       4325
       +
       ]

     

       4326
       4326
       +
       </file>

     

       4327
       4327
       +
       

     

       4328
       4328
       +
       <file path="src/thicket/cli/commands/__init__.py">

     

       4329
       4329
       +
       """CLI commands for thicket."""

     

       4330
       4330
       +
       

     

       4331
       4331
       +
       # Import all commands to register them with the main app

     

       4332
       4332
       +
       from . import add, duplicates, generate, index_cmd, info_cmd, init, links_cmd, list_cmd, sync

     

       4333
       4333
       +
       

     

       4334
       4334
       +
       __all__ = ["add", "duplicates", "generate", "index_cmd", "info_cmd", "init", "links_cmd", "list_cmd", "sync"]

     

       4335
       4335
       +
       </file>

     

       4336
       4336
       +
       

     

       4337
       4337
       +
       <file path="src/thicket/cli/commands/add.py">

     

       4338
       4338
       +
       """Add command for thicket."""

     

       4339
       4339
       +
       

     

       4340
       4340
       +
       import asyncio

     

       4341
       4341
       +
       from pathlib import Path

     

       4342
       4342
       +
       from typing import Optional

     

       4343
       4343
       +
       

     

       4344
       4344
       +
       import typer

     

       4345
       4345
       +
       from pydantic import HttpUrl, ValidationError

     

       4346
       4346
       +
       

     

       4347
       4347
       +
       from ...core.feed_parser import FeedParser

     

       4348
       4348
       +
       from ...core.git_store import GitStore

     

       4349
       4349
       +
       from ..main import app

     

       4350
       4350
       +
       from ..utils import (

     

       4351
       4351
       +
           create_progress,

     

       4352
       4352
       +
           load_config,

     

       4353
       4353
       +
           print_error,

     

       4354
       4354
       +
           print_info,

     

       4355
       4355
       +
           print_success,

     

       4356
       4356
       +
       )

     

       4357
       4357
       +
       

     

       4358
       4358
       +
       

     

       4359
       4359
       +
       @app.command("add")

     

       4360
       4360
       +
       def add_command(

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       4368
       4368
       +
           config_file: Optional[Path] = typer.Option(

     

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

     

       4370
       4370
       +
           ),

     

       4371
       4371
       +
           auto_discover: bool = typer.Option(

     

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

     

       4373
       4373
       +
           ),

     

       4374
       4374
       +
       ) -> None:

     

       4375
       4375
       +
           """Add a user or feed to thicket."""

     

       4376
       4376
       +
       

     

       4377
       4377
       +
           if subcommand == "user":

     

       4378
       4378
       +
               add_user(username, feed_url, email, homepage, icon, display_name, config_file, auto_discover)

     

       4379
       4379
       +
           elif subcommand == "feed":

     

       4380
       4380
       +
               add_feed(username, feed_url, config_file)

     

       4381
       4381
       +
           else:

     

       4382
       4382
       +
               print_error(f"Unknown subcommand: {subcommand}")

     

       4383
       4383
       +
               print_error("Use 'user' or 'feed'")

     

       4384
       4384
       +
               raise typer.Exit(1)

     

       4385
       4385
       +
       

     

       4386
       4386
       +
       

     

       4387
       4387
       +
       def add_user(

     

       4388
       4388
       +
           username: str,

     

       4389
       4389
       +
           feed_url: Optional[str],

     

       4390
       4390
       +
           email: Optional[str],

     

       4391
       4391
       +
           homepage: Optional[str],

     

       4392
       4392
       +
           icon: Optional[str],

     

       4393
       4393
       +
           display_name: Optional[str],

     

       4394
       4394
       +
           config_file: Path,

     

       4395
       4395
       +
           auto_discover: bool,

     

       4396
       4396
       +
       ) -> None:

     

       4397
       4397
       +
           """Add a new user with feed."""

     

       4398
       4398
       +
       

     

       4399
       4399
       +
           if not feed_url:

     

       4400
       4400
       +
               print_error("Feed URL is required when adding a user")

     

       4401
       4401
       +
               raise typer.Exit(1)

     

       4402
       4402
       +
       

     

       4403
       4403
       +
           # Validate feed URL

     

       4404
       4404
       +
           try:

     

       4405
       4405
       +
               validated_feed_url = HttpUrl(feed_url)

     

       4406
       4406
       +
           except ValidationError:

     

       4407
       4407
       +
               print_error(f"Invalid feed URL: {feed_url}")

     

       4408
       4408
       +
               raise typer.Exit(1) from None

     

       4409
       4409
       +
       

     

       4410
       4410
       +
           # Load configuration

     

       4411
       4411
       +
           config = load_config(config_file)

     

       4412
       4412
       +
       

     

       4413
       4413
       +
           # Initialize Git store

     

       4414
       4414
       +
           git_store = GitStore(config.git_store)

     

       4415
       4415
       +
       

     

       4416
       4416
       +
           # Check if user already exists

     

       4417
       4417
       +
           existing_user = git_store.get_user(username)

     

       4418
       4418
       +
           if existing_user:

     

       4419
       4419
       +
               print_error(f"User '{username}' already exists")

     

       4420
       4420
       +
               print_error("Use 'thicket add feed' to add additional feeds")

     

       4421
       4421
       +
               raise typer.Exit(1)

     

       4422
       4422
       +
       

     

       4423
       4423
       +
           # Auto-discover metadata if enabled

     

       4424
       4424
       +
           discovered_metadata = None

     

       4425
       4425
       +
           if auto_discover:

     

       4426
       4426
       +
               discovered_metadata = asyncio.run(discover_feed_metadata(validated_feed_url))

     

       4427
       4427
       +
       

     

       4428
       4428
       +
           # Prepare user data with manual overrides taking precedence

     

       4429
       4429
       +
           user_display_name = display_name or (discovered_metadata.author_name or discovered_metadata.title if discovered_metadata else None)

     

       4430
       4430
       +
           user_email = email or (discovered_metadata.author_email if discovered_metadata else None)

     

       4431
       4431
       +
           user_homepage = homepage or (str(discovered_metadata.author_uri or discovered_metadata.link) if discovered_metadata else None)

     

       4432
       4432
       +
           user_icon = icon or (str(discovered_metadata.logo or discovered_metadata.icon or discovered_metadata.image_url) if discovered_metadata else None)

     

       4433
       4433
       +
       

     

       4434
       4434
       +
           # Add user to Git store

     

       4435
       4435
       +
           git_store.add_user(

     

       4436
       4436
       +
               username=username,

     

       4437
       4437
       +
               display_name=user_display_name,

     

       4438
       4438
       +
               email=user_email,

     

       4439
       4439
       +
               homepage=user_homepage,

     

       4440
       4440
       +
               icon=user_icon,

     

       4441
       4441
       +
               feeds=[str(validated_feed_url)],

     

       4442
       4442
       +
           )

     

       4443
       4443
       +
       

     

       4444
       4444
       +
           # Commit changes

     

       4445
       4445
       +
           git_store.commit_changes(f"Add user: {username}")

     

       4446
       4446
       +
       

     

       4447
       4447
       +
           print_success(f"Added user '{username}' with feed: {feed_url}")

     

       4448
       4448
       +
       

     

       4449
       4449
       +
           if discovered_metadata and auto_discover:

     

       4450
       4450
       +
               print_info("Auto-discovered metadata:")

     

       4451
       4451
       +
               if user_display_name:

     

       4452
       4452
       +
                   print_info(f"  Display name: {user_display_name}")

     

       4453
       4453
       +
               if user_email:

     

       4454
       4454
       +
                   print_info(f"  Email: {user_email}")

     

       4455
       4455
       +
               if user_homepage:

     

       4456
       4456
       +
                   print_info(f"  Homepage: {user_homepage}")

     

       4457
       4457
       +
               if user_icon:

     

       4458
       4458
       +
                   print_info(f"  Icon: {user_icon}")

     

       4459
       4459
       +
       

     

       4460
       4460
       +
       

     

       4461
       4461
       +
       def add_feed(username: str, feed_url: Optional[str], config_file: Path) -> None:

     

       4462
       4462
       +
           """Add a feed to an existing user."""

     

       4463
       4463
       +
       

     

       4464
       4464
       +
           if not feed_url:

     

       4465
       4465
       +
               print_error("Feed URL is required")

     

       4466
       4466
       +
               raise typer.Exit(1)

     

       4467
       4467
       +
       

     

       4468
       4468
       +
           # Validate feed URL

     

       4469
       4469
       +
           try:

     

       4470
       4470
       +
               validated_feed_url = HttpUrl(feed_url)

     

       4471
       4471
       +
           except ValidationError:

     

       4472
       4472
       +
               print_error(f"Invalid feed URL: {feed_url}")

     

       4473
       4473
       +
               raise typer.Exit(1) from None

     

       4474
       4474
       +
       

     

       4475
       4475
       +
           # Load configuration

     

       4476
       4476
       +
           config = load_config(config_file)

     

       4477
       4477
       +
       

     

       4478
       4478
       +
           # Initialize Git store

     

       4479
       4479
       +
           git_store = GitStore(config.git_store)

     

       4480
       4480
       +
       

     

       4481
       4481
       +
           # Check if user exists

     

       4482
       4482
       +
           user = git_store.get_user(username)

     

       4483
       4483
       +
           if not user:

     

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

     

       4485
       4485
       +
               print_error("Use 'thicket add user' to add a new user")

     

       4486
       4486
       +
               raise typer.Exit(1)

     

       4487
       4487
       +
       

     

       4488
       4488
       +
           # Check if feed already exists

     

       4489
       4489
       +
           if str(validated_feed_url) in user.feeds:

     

       4490
       4490
       +
               print_error(f"Feed already exists for user '{username}': {feed_url}")

     

       4491
       4491
       +
               raise typer.Exit(1)

     

       4492
       4492
       +
       

     

       4493
       4493
       +
           # Add feed to user

     

       4494
       4494
       +
           updated_feeds = user.feeds + [str(validated_feed_url)]

     

       4495
       4495
       +
           if git_store.update_user(username, feeds=updated_feeds):

     

       4496
       4496
       +
               git_store.commit_changes(f"Add feed to user {username}: {feed_url}")

     

       4497
       4497
       +
               print_success(f"Added feed to user '{username}': {feed_url}")

     

       4498
       4498
       +
           else:

     

       4499
       4499
       +
               print_error(f"Failed to add feed to user '{username}'")

     

       4500
       4500
       +
               raise typer.Exit(1)

     

       4501
       4501
       +
       

     

       4502
       4502
       +
       

     

       4503
       4503
       +
       async def discover_feed_metadata(feed_url: HttpUrl):

     

       4504
       4504
       +
           """Discover metadata from a feed URL."""

     

       4505
       4505
       +
           try:

     

       4506
       4506
       +
               with create_progress() as progress:

     

       4507
       4507
       +
                   task = progress.add_task("Discovering feed metadata...", total=None)

     

       4508
       4508
       +
       

     

       4509
       4509
       +
                   parser = FeedParser()

     

       4510
       4510
       +
                   content = await parser.fetch_feed(feed_url)

     

       4511
       4511
       +
                   metadata, _ = parser.parse_feed(content, feed_url)

     

       4512
       4512
       +
       

     

       4513
       4513
       +
                   progress.update(task, completed=True)

     

       4514
       4514
       +
                   return metadata

     

       4515
       4515
       +
       

     

       4516
       4516
       +
           except Exception as e:

     

       4517
       4517
       +
               print_error(f"Failed to discover feed metadata: {e}")

     

       4518
       4518
       +
               return None

     

       4519
       4519
       +
       </file>

     

       4520
       4520
       +
       

     

       4521
       4521
       +
       <file path="src/thicket/cli/commands/duplicates.py">

     

       4522
       4522
       +
       """Duplicates command for thicket."""

     

       4523
       4523
       +
       

     

       4524
       4524
       +
       from pathlib import Path

     

       4525
       4525
       +
       from typing import Optional

     

       4526
       4526
       +
       

     

       4527
       4527
       +
       import typer

     

       4528
       4528
       +
       from rich.table import Table

     

       4529
       4529
       +
       

     

       4530
       4530
       +
       from ...core.git_store import GitStore

     

       4531
       4531
       +
       from ..main import app

     

       4532
       4532
       +
       from ..utils import (

     

       4533
       4533
       +
           console,

     

       4534
       4534
       +
           load_config,

     

       4535
       4535
       +
           print_error,

     

       4536
       4536
       +
           print_info,

     

       4537
       4537
       +
           print_success,

     

       4538
       4538
       +
           get_tsv_mode,

     

       4539
       4539
       +
       )

     

       4540
       4540
       +
       

     

       4541
       4541
       +
       

     

       4542
       4542
       +
       @app.command("duplicates")

     

       4543
       4543
       +
       def duplicates_command(

     

       4544
       4544
       +
           action: str = typer.Argument(..., help="Action: 'list', 'add', 'remove'"),

     

       4545
       4545
       +
           duplicate_id: Optional[str] = typer.Argument(None, help="Duplicate entry ID"),

     

       4546
       4546
       +
           canonical_id: Optional[str] = typer.Argument(None, help="Canonical entry ID"),

     

       4547
       4547
       +
           config_file: Optional[Path] = typer.Option(

     

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

     

       4549
       4549
       +
           ),

     

       4550
       4550
       +
       ) -> None:

     

       4551
       4551
       +
           """Manage duplicate entry mappings."""

     

       4552
       4552
       +
       

     

       4553
       4553
       +
           # Load configuration

     

       4554
       4554
       +
           config = load_config(config_file)

     

       4555
       4555
       +
       

     

       4556
       4556
       +
           # Initialize Git store

     

       4557
       4557
       +
           git_store = GitStore(config.git_store)

     

       4558
       4558
       +
       

     

       4559
       4559
       +
           if action == "list":

     

       4560
       4560
       +
               list_duplicates(git_store)

     

       4561
       4561
       +
           elif action == "add":

     

       4562
       4562
       +
               add_duplicate(git_store, duplicate_id, canonical_id)

     

       4563
       4563
       +
           elif action == "remove":

     

       4564
       4564
       +
               remove_duplicate(git_store, duplicate_id)

     

       4565
       4565
       +
           else:

     

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

     

       4567
       4567
       +
               print_error("Use 'list', 'add', or 'remove'")

     

       4568
       4568
       +
               raise typer.Exit(1)

     

       4569
       4569
       +
       

     

       4570
       4570
       +
       

     

       4571
       4571
       +
       def list_duplicates(git_store: GitStore) -> None:

     

       4572
       4572
       +
           """List all duplicate mappings."""

     

       4573
       4573
       +
           duplicates = git_store.get_duplicates()

     

       4574
       4574
       +
       

     

       4575
       4575
       +
           if not duplicates.duplicates:

     

       4576
       4576
       +
               if get_tsv_mode():

     

       4577
       4577
       +
                   print("No duplicate mappings found")

     

       4578
       4578
       +
               else:

     

       4579
       4579
       +
                   print_info("No duplicate mappings found")

     

       4580
       4580
       +
               return

     

       4581
       4581
       +
       

     

       4582
       4582
       +
           if get_tsv_mode():

     

       4583
       4583
       +
               print("Duplicate ID\tCanonical ID")

     

       4584
       4584
       +
               for duplicate_id, canonical_id in duplicates.duplicates.items():

     

       4585
       4585
       +
                   print(f"{duplicate_id}\t{canonical_id}")

     

       4586
       4586
       +
               print(f"Total duplicates: {len(duplicates.duplicates)}")

     

       4587
       4587
       +
           else:

     

       4588
       4588
       +
               table = Table(title="Duplicate Entry Mappings")

     

       4589
       4589
       +
               table.add_column("Duplicate ID", style="red")

     

       4590
       4590
       +
               table.add_column("Canonical ID", style="green")

     

       4591
       4591
       +
       

     

       4592
       4592
       +
               for duplicate_id, canonical_id in duplicates.duplicates.items():

     

       4593
       4593
       +
                   table.add_row(duplicate_id, canonical_id)

     

       4594
       4594
       +
       

     

       4595
       4595
       +
               console.print(table)

     

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

     

       4597
       4597
       +
       

     

       4598
       4598
       +
       

     

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

     

       4600
       4600
       +
           """Add a duplicate mapping."""

     

       4601
       4601
       +
           if not duplicate_id:

     

       4602
       4602
       +
               print_error("Duplicate ID is required")

     

       4603
       4603
       +
               raise typer.Exit(1)

     

       4604
       4604
       +
       

     

       4605
       4605
       +
           if not canonical_id:

     

       4606
       4606
       +
               print_error("Canonical ID is required")

     

       4607
       4607
       +
               raise typer.Exit(1)

     

       4608
       4608
       +
       

     

       4609
       4609
       +
           # Check if duplicate_id already exists

     

       4610
       4610
       +
           duplicates = git_store.get_duplicates()

     

       4611
       4611
       +
           if duplicates.is_duplicate(duplicate_id):

     

       4612
       4612
       +
               existing_canonical = duplicates.get_canonical(duplicate_id)

     

       4613
       4613
       +
               print_error(f"Duplicate ID already mapped to: {existing_canonical}")

     

       4614
       4614
       +
               print_error("Use 'remove' first to change the mapping")

     

       4615
       4615
       +
               raise typer.Exit(1)

     

       4616
       4616
       +
       

     

       4617
       4617
       +
           # Check if we're trying to make a canonical ID point to itself

     

       4618
       4618
       +
           if duplicate_id == canonical_id:

     

       4619
       4619
       +
               print_error("Duplicate ID cannot be the same as canonical ID")

     

       4620
       4620
       +
               raise typer.Exit(1)

     

       4621
       4621
       +
       

     

       4622
       4622
       +
           # Add the mapping

     

       4623
       4623
       +
           git_store.add_duplicate(duplicate_id, canonical_id)

     

       4624
       4624
       +
       

     

       4625
       4625
       +
           # Commit changes

     

       4626
       4626
       +
           git_store.commit_changes(f"Add duplicate mapping: {duplicate_id} -> {canonical_id}")

     

       4627
       4627
       +
       

     

       4628
       4628
       +
           print_success(f"Added duplicate mapping: {duplicate_id} -> {canonical_id}")

     

       4629
       4629
       +
       

     

       4630
       4630
       +
       

     

       4631
       4631
       +
       def remove_duplicate(git_store: GitStore, duplicate_id: Optional[str]) -> None:

     

       4632
       4632
       +
           """Remove a duplicate mapping."""

     

       4633
       4633
       +
           if not duplicate_id:

     

       4634
       4634
       +
               print_error("Duplicate ID is required")

     

       4635
       4635
       +
               raise typer.Exit(1)

     

       4636
       4636
       +
       

     

       4637
       4637
       +
           # Check if mapping exists

     

       4638
       4638
       +
           duplicates = git_store.get_duplicates()

     

       4639
       4639
       +
           if not duplicates.is_duplicate(duplicate_id):

     

       4640
       4640
       +
               print_error(f"No duplicate mapping found for: {duplicate_id}")

     

       4641
       4641
       +
               raise typer.Exit(1)

     

       4642
       4642
       +
       

     

       4643
       4643
       +
           canonical_id = duplicates.get_canonical(duplicate_id)

     

       4644
       4644
       +
       

     

       4645
       4645
       +
           # Remove the mapping

     

       4646
       4646
       +
           if git_store.remove_duplicate(duplicate_id):

     

       4647
       4647
       +
               # Commit changes

     

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

     

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

     

       4650
       4650
       +
           else:

     

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

     

       4652
       4652
       +
               raise typer.Exit(1)

     

       4653
       4653
       +
       </file>

     

       4654
       4654
       +
       

     

       4655
       4655
       +
       <file path="src/thicket/cli/commands/sync.py">

     

       4656
       4656
       +
       """Sync command for thicket."""

     

       4657
       4657
       +
       

     

       4658
       4658
       +
       import asyncio

     

       4659
       4659
       +
       from pathlib import Path

     

       4660
       4660
       +
       from typing import Optional

     

       4661
       4661
       +
       

     

       4662
       4662
       +
       import typer

     

       4663
       4663
       +
       from rich.progress import track

     

       4664
       4664
       +
       

     

       4665
       4665
       +
       from ...core.feed_parser import FeedParser

     

       4666
       4666
       +
       from ...core.git_store import GitStore

     

       4667
       4667
       +
       from ..main import app

     

       4668
       4668
       +
       from ..utils import (

     

       4669
       4669
       +
           load_config,

     

       4670
       4670
       +
           print_error,

     

       4671
       4671
       +
           print_info,

     

       4672
       4672
       +
           print_success,

     

       4673
       4673
       +
       )

     

       4674
       4674
       +
       

     

       4675
       4675
       +
       

     

       4676
       4676
       +
       @app.command()

     

       4677
       4677
       +
       def sync(

     

       4678
       4678
       +
           all_users: bool = typer.Option(

     

       4679
       4679
       +
               False, "--all", "-a", help="Sync all users and feeds"

     

       4680
       4680
       +
           ),

     

       4681
       4681
       +
           user: Optional[str] = typer.Option(

     

       4682
       4682
       +
               None, "--user", "-u", help="Sync specific user only"

     

       4683
       4683
       +
           ),

     

       4684
       4684
       +
           config_file: Optional[Path] = typer.Option(

     

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

     

       4686
       4686
       +
           ),

     

       4687
       4687
       +
           dry_run: bool = typer.Option(

     

       4688
       4688
       +
               False, "--dry-run", help="Show what would be synced without making changes"

     

       4689
       4689
       +
           ),

     

       4690
       4690
       +
       ) -> None:

     

       4691
       4691
       +
           """Sync feeds and store entries in Git repository."""

     

       4692
       4692
       +
       

     

       4693
       4693
       +
           # Load configuration

     

       4694
       4694
       +
           config = load_config(config_file)

     

       4695
       4695
       +
       

     

       4696
       4696
       +
           # Initialize Git store

     

       4697
       4697
       +
           git_store = GitStore(config.git_store)

     

       4698
       4698
       +
       

     

       4699
       4699
       +
           # Determine which users to sync from git repository

     

       4700
       4700
       +
           users_to_sync = []

     

       4701
       4701
       +
           if all_users:

     

       4702
       4702
       +
               index = git_store._load_index()

     

       4703
       4703
       +
               users_to_sync = list(index.users.values())

     

       4704
       4704
       +
           elif user:

     

       4705
       4705
       +
               user_metadata = git_store.get_user(user)

     

       4706
       4706
       +
               if not user_metadata:

     

       4707
       4707
       +
                   print_error(f"User '{user}' not found in git repository")

     

       4708
       4708
       +
                   raise typer.Exit(1)

     

       4709
       4709
       +
               users_to_sync = [user_metadata]

     

       4710
       4710
       +
           else:

     

       4711
       4711
       +
               print_error("Specify --all to sync all users or --user to sync a specific user")

     

       4712
       4712
       +
               raise typer.Exit(1)

     

       4713
       4713
       +
       

     

       4714
       4714
       +
           if not users_to_sync:

     

       4715
       4715
       +
               print_info("No users configured to sync")

     

       4716
       4716
       +
               return

     

       4717
       4717
       +
       

     

       4718
       4718
       +
           # Sync each user

     

       4719
       4719
       +
           total_new_entries = 0

     

       4720
       4720
       +
           total_updated_entries = 0

     

       4721
       4721
       +
       

     

       4722
       4722
       +
           for user_metadata in users_to_sync:

     

       4723
       4723
       +
               print_info(f"Syncing user: {user_metadata.username}")

     

       4724
       4724
       +
       

     

       4725
       4725
       +
               user_new_entries = 0

     

       4726
       4726
       +
               user_updated_entries = 0

     

       4727
       4727
       +
       

     

       4728
       4728
       +
               # Sync each feed for the user

     

       4729
       4729
       +
               for feed_url in track(user_metadata.feeds, description=f"Syncing {user_metadata.username}'s feeds"):

     

       4730
       4730
       +
                   try:

     

       4731
       4731
       +
                       new_entries, updated_entries = asyncio.run(

     

       4732
       4732
       +
                           sync_feed(git_store, user_metadata.username, feed_url, dry_run)

     

       4733
       4733
       +
                       )

     

       4734
       4734
       +
                       user_new_entries += new_entries

     

       4735
       4735
       +
                       user_updated_entries += updated_entries

     

       4736
       4736
       +
       

     

       4737
       4737
       +
                   except Exception as e:

     

       4738
       4738
       +
                       print_error(f"Failed to sync feed {feed_url}: {e}")

     

       4739
       4739
       +
                       continue

     

       4740
       4740
       +
       

     

       4741
       4741
       +
               print_info(f"User {user_metadata.username}: {user_new_entries} new, {user_updated_entries} updated")

     

       4742
       4742
       +
               total_new_entries += user_new_entries

     

       4743
       4743
       +
               total_updated_entries += user_updated_entries

     

       4744
       4744
       +
       

     

       4745
       4745
       +
           # Commit changes if not dry run

     

       4746
       4746
       +
           if not dry_run and (total_new_entries > 0 or total_updated_entries > 0):

     

       4747
       4747
       +
               commit_message = f"Sync feeds: {total_new_entries} new entries, {total_updated_entries} updated"

     

       4748
       4748
       +
               git_store.commit_changes(commit_message)

     

       4749
       4749
       +
               print_success(f"Committed changes: {commit_message}")

     

       4750
       4750
       +
       

     

       4751
       4751
       +
           # Summary

     

       4752
       4752
       +
           if dry_run:

     

       4753
       4753
       +
               print_info(f"Dry run complete: would sync {total_new_entries} new entries, {total_updated_entries} updated")

     

       4754
       4754
       +
           else:

     

       4755
       4755
       +
               print_success(f"Sync complete: {total_new_entries} new entries, {total_updated_entries} updated")

     

       4756
       4756
       +
       

     

       4757
       4757
       +
       

     

       4758
       4758
       +
       async def sync_feed(git_store: GitStore, username: str, feed_url, dry_run: bool) -> tuple[int, int]:

     

       4759
       4759
       +
           """Sync a single feed for a user."""

     

       4760
       4760
       +
       

     

       4761
       4761
       +
           parser = FeedParser()

     

       4762
       4762
       +
       

     

       4763
       4763
       +
           try:

     

       4764
       4764
       +
               # Fetch and parse feed

     

       4765
       4765
       +
               content = await parser.fetch_feed(feed_url)

     

       4766
       4766
       +
               metadata, entries = parser.parse_feed(content, feed_url)

     

       4767
       4767
       +
       

     

       4768
       4768
       +
               new_entries = 0

     

       4769
       4769
       +
               updated_entries = 0

     

       4770
       4770
       +
       

     

       4771
       4771
       +
               # Process each entry

     

       4772
       4772
       +
               for entry in entries:

     

       4773
       4773
       +
                   try:

     

       4774
       4774
       +
                       # Check if entry already exists

     

       4775
       4775
       +
                       existing_entry = git_store.get_entry(username, entry.id)

     

       4776
       4776
       +
       

     

       4777
       4777
       +
                       if existing_entry:

     

       4778
       4778
       +
                           # Check if entry has been updated

     

       4779
       4779
       +
                           if existing_entry.updated != entry.updated:

     

       4780
       4780
       +
                               if not dry_run:

     

       4781
       4781
       +
                                   git_store.store_entry(username, entry)

     

       4782
       4782
       +
                               updated_entries += 1

     

       4783
       4783
       +
                       else:

     

       4784
       4784
       +
                           # New entry

     

       4785
       4785
       +
                           if not dry_run:

     

       4786
       4786
       +
                               git_store.store_entry(username, entry)

     

       4787
       4787
       +
                           new_entries += 1

     

       4788
       4788
       +
       

     

       4789
       4789
       +
                   except Exception as e:

     

       4790
       4790
       +
                       print_error(f"Failed to process entry {entry.id}: {e}")

     

       4791
       4791
       +
                       continue

     

       4792
       4792
       +
       

     

       4793
       4793
       +
               return new_entries, updated_entries

     

       4794
       4794
       +
       

     

       4795
       4795
       +
           except Exception as e:

     

       4796
       4796
       +
               print_error(f"Failed to sync feed {feed_url}: {e}")

     

       4797
       4797
       +
               return 0, 0

     

       4798
       4798
       +
       </file>

     

       4799
       4799
       +
       

     

       4800
       4800
       +
       <file path="src/thicket/models/config.py">

     

       4801
       4801
       +
       """Configuration models for thicket."""

     

       4802
       4802
       +
       

     

       4803
       4803
       +
       from pathlib import Path

     

       4804
       4804
       +
       from typing import Optional

     

       4805
       4805
       +
       

     

       4806
       4806
       +
       from pydantic import BaseModel, EmailStr, HttpUrl

     

       4807
       4807
       +
       from pydantic_settings import BaseSettings, SettingsConfigDict

     

       4808
       4808
       +
       

     

       4809
       4809
       +
       

     

       4810
       4810
       +
       class UserConfig(BaseModel):

     

       4811
       4811
       +
           """Configuration for a single user and their feeds."""

     

       4812
       4812
       +
       

     

       4813
       4813
       +
           username: str

     

       4814
       4814
       +
           feeds: list[HttpUrl]

     

       4815
       4815
       +
           email: Optional[EmailStr] = None

     

       4816
       4816
       +
           homepage: Optional[HttpUrl] = None

     

       4817
       4817
       +
           icon: Optional[HttpUrl] = None

     

       4818
       4818
       +
           display_name: Optional[str] = None

     

       4819
       4819
       +
       

     

       4820
       4820
       +
       

     

       4821
       4821
       +
       class ThicketConfig(BaseSettings):

     

       4822
       4822
       +
           """Main configuration for thicket."""

     

       4823
       4823
       +
       

     

       4824
       4824
       +
           model_config = SettingsConfigDict(

     

       4825
       4825
       +
               env_prefix="THICKET_",

     

       4826
       4826
       +
               env_file=".env",

     

       4827
       4827
       +
               yaml_file="thicket.yaml",

     

       4828
       4828
       +
               case_sensitive=False,

     

       4829
       4829
       +
           )

     

       4830
       4830
       +
       

     

       4831
       4831
       +
           git_store: Path

     

       4832
       4832
       +
           cache_dir: Path

     

       4833
       4833
       +
           users: list[UserConfig] = []

     

       4834
       4834
       +
       </file>

     

       4835
       4835
       +
       

     

       4836
       4836
       +
       <file path="src/thicket/cli/commands/links_cmd.py">

     

       4837
       4837
       +
       """CLI command for extracting and categorizing all outbound links from blog entries."""

     

       4838
       4838
       +
       

     

       4839
       4839
       +
       import json

     

       4840
       4840
       +
       import re

     

       4841
       4841
       +
       from pathlib import Path

     

       4842
       4842
       +
       from typing import Dict, List, Optional, Set

     

       4843
       4843
       +
       from urllib.parse import urljoin, urlparse

     

       4844
       4844
       +
       

     

       4845
       4845
       +
       import typer

     

       4846
       4846
       +
       from rich.console import Console

     

       4847
       4847
       +
       from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn

     

       4848
       4848
       +
       from rich.table import Table

     

       4849
       4849
       +
       

     

       4850
       4850
       +
       from ...core.git_store import GitStore

     

       4851
       4851
       +
       from ..main import app

     

       4852
       4852
       +
       from ..utils import load_config, get_tsv_mode

     

       4853
       4853
       +
       

     

       4854
       4854
       +
       console = Console()

     

       4855
       4855
       +
       

     

       4856
       4856
       +
       

     

       4857
       4857
       +
       class LinkData:

     

       4858
       4858
       +
           """Represents a link found in a blog entry."""

     

       4859
       4859
       +
           

     

       4860
       4860
       +
           def __init__(self, url: str, entry_id: str, username: str):

     

       4861
       4861
       +
               self.url = url

     

       4862
       4862
       +
               self.entry_id = entry_id

     

       4863
       4863
       +
               self.username = username

     

       4864
       4864
       +
           

     

       4865
       4865
       +
           def to_dict(self) -> dict:

     

       4866
       4866
       +
               """Convert to dictionary for JSON serialization."""

     

       4867
       4867
       +
               return {

     

       4868
       4868
       +
                   "url": self.url,

     

       4869
       4869
       +
                   "entry_id": self.entry_id,

     

       4870
       4870
       +
                   "username": self.username

     

       4871
       4871
       +
               }

     

       4872
       4872
       +
           

     

       4873
       4873
       +
           @classmethod

     

       4874
       4874
       +
           def from_dict(cls, data: dict) -> "LinkData":

     

       4875
       4875
       +
               """Create from dictionary."""

     

       4876
       4876
       +
               return cls(

     

       4877
       4877
       +
                   url=data["url"],

     

       4878
       4878
       +
                   entry_id=data["entry_id"],

     

       4879
       4879
       +
                   username=data["username"]

     

       4880
       4880
       +
               )

     

       4881
       4881
       +
       

     

       4882
       4882
       +
       

     

       4883
       4883
       +
       class LinkCategorizer:

     

       4884
       4884
       +
           """Categorizes links as internal, user, or unknown."""

     

       4885
       4885
       +
           

     

       4886
       4886
       +
           def __init__(self, user_domains: Dict[str, Set[str]]):

     

       4887
       4887
       +
               self.user_domains = user_domains

     

       4888
       4888
       +
               # Create reverse mapping of domain -> username

     

       4889
       4889
       +
               self.domain_to_user = {}

     

       4890
       4890
       +
               for username, domains in user_domains.items():

     

       4891
       4891
       +
                   for domain in domains:

     

       4892
       4892
       +
                       self.domain_to_user[domain] = username

     

       4893
       4893
       +
           

     

       4894
       4894
       +
           def categorize_url(self, url: str, source_username: str) -> tuple[str, Optional[str]]:

     

       4895
       4895
       +
               """

     

       4896
       4896
       +
               Categorize a URL as 'internal', 'user', or 'unknown'.

     

       4897
       4897
       +
               Returns (category, target_username).

     

       4898
       4898
       +
               """

     

       4899
       4899
       +
               try:

     

       4900
       4900
       +
                   parsed = urlparse(url)

     

       4901
       4901
       +
                   domain = parsed.netloc.lower()

     

       4902
       4902
       +
                   

     

       4903
       4903
       +
                   # Check if it's a link to the same user's domain (internal)

     

       4904
       4904
       +
                   if domain in self.user_domains.get(source_username, set()):

     

       4905
       4905
       +
                       return "internal", source_username

     

       4906
       4906
       +
                   

     

       4907
       4907
       +
                   # Check if it's a link to another user's domain

     

       4908
       4908
       +
                   if domain in self.domain_to_user:

     

       4909
       4909
       +
                       return "user", self.domain_to_user[domain]

     

       4910
       4910
       +
                   

     

       4911
       4911
       +
                   # Everything else is unknown

     

       4912
       4912
       +
                   return "unknown", None

     

       4913
       4913
       +
                   

     

       4914
       4914
       +
               except Exception:

     

       4915
       4915
       +
                   return "unknown", None

     

       4916
       4916
       +
       

     

       4917
       4917
       +
       

     

       4918
       4918
       +
       class LinkExtractor:

     

       4919
       4919
       +
           """Extracts and resolves links from blog entries."""

     

       4920
       4920
       +
           

     

       4921
       4921
       +
           def __init__(self):

     

       4922
       4922
       +
               # Pattern for extracting links from HTML

     

       4923
       4923
       +
               self.link_pattern = re.compile(r'<a[^>]+href="([^"]+)"[^>]*>(.*?)</a>', re.IGNORECASE | re.DOTALL)

     

       4924
       4924
       +
               self.url_pattern = re.compile(r'https?://[^\s<>"]+')

     

       4925
       4925
       +
           

     

       4926
       4926
       +
           def extract_links_from_html(self, html_content: str, base_url: str) -> List[tuple[str, str]]:

     

       4927
       4927
       +
               """Extract all links from HTML content and resolve them against base URL."""

     

       4928
       4928
       +
               links = []

     

       4929
       4929
       +
               

     

       4930
       4930
       +
               # Extract links from <a> tags

     

       4931
       4931
       +
               for match in self.link_pattern.finditer(html_content):

     

       4932
       4932
       +
                   url = match.group(1)

     

       4933
       4933
       +
                   text = re.sub(r'<[^>]+>', '', match.group(2)).strip()  # Remove HTML tags from link text

     

       4934
       4934
       +
                   

     

       4935
       4935
       +
                   # Resolve relative URLs against base URL

     

       4936
       4936
       +
                   resolved_url = urljoin(base_url, url)

     

       4937
       4937
       +
                   links.append((resolved_url, text))

     

       4938
       4938
       +
               

     

       4939
       4939
       +
               return links

     

       4940
       4940
       +
           

     

       4941
       4941
       +
           

     

       4942
       4942
       +
           def extract_links_from_entry(self, entry, username: str, base_url: str) -> List[LinkData]:

     

       4943
       4943
       +
               """Extract all links from a blog entry."""

     

       4944
       4944
       +
               links = []

     

       4945
       4945
       +
               

     

       4946
       4946
       +
               # Combine all text content for analysis

     

       4947
       4947
       +
               content_to_search = []

     

       4948
       4948
       +
               if entry.content:

     

       4949
       4949
       +
                   content_to_search.append(entry.content)

     

       4950
       4950
       +
               if entry.summary:

     

       4951
       4951
       +
                   content_to_search.append(entry.summary)

     

       4952
       4952
       +
               

     

       4953
       4953
       +
               for content in content_to_search:

     

       4954
       4954
       +
                   extracted_links = self.extract_links_from_html(content, base_url)

     

       4955
       4955
       +
                   

     

       4956
       4956
       +
                   for url, link_text in extracted_links:

     

       4957
       4957
       +
                       # Skip empty URLs

     

       4958
       4958
       +
                       if not url or url.startswith('#'):

     

       4959
       4959
       +
                           continue

     

       4960
       4960
       +
                       

     

       4961
       4961
       +
                       link_data = LinkData(

     

       4962
       4962
       +
                           url=url,

     

       4963
       4963
       +
                           entry_id=entry.id,

     

       4964
       4964
       +
                           username=username

     

       4965
       4965
       +
                       )

     

       4966
       4966
       +
                       

     

       4967
       4967
       +
                       links.append(link_data)

     

       4968
       4968
       +
               

     

       4969
       4969
       +
               return links

     

       4970
       4970
       +
       

     

       4971
       4971
       +
       

     

       4972
       4972
       +
       @app.command()

     

       4973
       4973
       +
       def links(

     

       4974
       4974
       +
           config_file: Optional[Path] = typer.Option(

     

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

     

       4976
       4976
       +
               "--config",

     

       4977
       4977
       +
               "-c",

     

       4978
       4978
       +
               help="Path to configuration file",

     

       4979
       4979
       +
           ),

     

       4980
       4980
       +
           output_file: Optional[Path] = typer.Option(

     

       4981
       4981
       +
               None,

     

       4982
       4982
       +
               "--output",

     

       4983
       4983
       +
               "-o",

     

       4984
       4984
       +
               help="Path to output unified links file (default: links.json in git store)",

     

       4985
       4985
       +
           ),

     

       4986
       4986
       +
           verbose: bool = typer.Option(

     

       4987
       4987
       +
               False,

     

       4988
       4988
       +
               "--verbose",

     

       4989
       4989
       +
               "-v",

     

       4990
       4990
       +
               help="Show detailed progress information",

     

       4991
       4991
       +
           ),

     

       4992
       4992
       +
       ) -> None:

     

       4993
       4993
       +
           """Extract and categorize all outbound links from blog entries.

     

       4994
       4994
       +
           

     

       4995
       4995
       +
           This command analyzes all blog entries to extract outbound links,

     

       4996
       4996
       +
           resolve them properly with respect to the feed's base URL, and

     

       4997
       4997
       +
           categorize them as internal, user, or unknown links.

     

       4998
       4998
       +
           

     

       4999
       4999
       +
           Creates a unified links.json file containing all link data.

     

       5000
       5000
       +
           """

     

       5001
       5001
       +
           try:

     

       5002
       5002
       +
               # Load configuration

     

       5003
       5003
       +
               config = load_config(config_file)

     

       5004
       5004
       +
       

     

       5005
       5005
       +
               # Initialize Git store

     

       5006
       5006
       +
               git_store = GitStore(config.git_store)

     

       5007
       5007
       +
               

     

       5008
       5008
       +
               # Build user domain mapping

     

       5009
       5009
       +
               if verbose:

     

       5010
       5010
       +
                   console.print("Building user domain mapping...")

     

       5011
       5011
       +
               

     

       5012
       5012
       +
               index = git_store._load_index()

     

       5013
       5013
       +
               user_domains = {}

     

       5014
       5014
       +
               

     

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

     

       5016
       5016
       +
                   domains = set()

     

       5017
       5017
       +
                   

     

       5018
       5018
       +
                   # Add domains from feeds

     

       5019
       5019
       +
                   for feed_url in user_metadata.feeds:

     

       5020
       5020
       +
                       domain = urlparse(feed_url).netloc.lower()

     

       5021
       5021
       +
                       if domain:

     

       5022
       5022
       +
                           domains.add(domain)

     

       5023
       5023
       +
                   

     

       5024
       5024
       +
                   # Add domain from homepage

     

       5025
       5025
       +
                   if user_metadata.homepage:

     

       5026
       5026
       +
                       domain = urlparse(str(user_metadata.homepage)).netloc.lower()

     

       5027
       5027
       +
                       if domain:

     

       5028
       5028
       +
                           domains.add(domain)

     

       5029
       5029
       +
                   

     

       5030
       5030
       +
                   user_domains[username] = domains

     

       5031
       5031
       +
               

     

       5032
       5032
       +
               if verbose:

     

       5033
       5033
       +
                   console.print(f"Found {len(user_domains)} users with {sum(len(d) for d in user_domains.values())} total domains")

     

       5034
       5034
       +
               

     

       5035
       5035
       +
               # Initialize components

     

       5036
       5036
       +
               link_extractor = LinkExtractor()

     

       5037
       5037
       +
               categorizer = LinkCategorizer(user_domains)

     

       5038
       5038
       +
               

     

       5039
       5039
       +
               # Get all users

     

       5040
       5040
       +
               users = list(index.users.keys())

     

       5041
       5041
       +
               

     

       5042
       5042
       +
               if not users:

     

       5043
       5043
       +
                   console.print("[yellow]No users found in Git store[/yellow]")

     

       5044
       5044
       +
                   raise typer.Exit(0)

     

       5045
       5045
       +
               

     

       5046
       5046
       +
               # Process all entries

     

       5047
       5047
       +
               all_links = []

     

       5048
       5048
       +
               link_categories = {"internal": [], "user": [], "unknown": []}

     

       5049
       5049
       +
               link_dict = {}  # Dictionary with link URL as key, maps to list of atom IDs

     

       5050
       5050
       +
               reverse_dict = {}  # Dictionary with atom ID as key, maps to list of URLs

     

       5051
       5051
       +
               

     

       5052
       5052
       +
               with Progress(

     

       5053
       5053
       +
                   SpinnerColumn(),

     

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

     

       5055
       5055
       +
                   BarColumn(),

     

       5056
       5056
       +
                   TaskProgressColumn(),

     

       5057
       5057
       +
                   console=console,

     

       5058
       5058
       +
               ) as progress:

     

       5059
       5059
       +
                   

     

       5060
       5060
       +
                   # Count total entries first

     

       5061
       5061
       +
                   counting_task = progress.add_task("Counting entries...", total=len(users))

     

       5062
       5062
       +
                   total_entries = 0

     

       5063
       5063
       +
                   

     

       5064
       5064
       +
                   for username in users:

     

       5065
       5065
       +
                       entries = git_store.list_entries(username)

     

       5066
       5066
       +
                       total_entries += len(entries)

     

       5067
       5067
       +
                       progress.advance(counting_task)

     

       5068
       5068
       +
                   

     

       5069
       5069
       +
                   progress.remove_task(counting_task)

     

       5070
       5070
       +
                   

     

       5071
       5071
       +
                   # Process entries

     

       5072
       5072
       +
                   processing_task = progress.add_task(

     

       5073
       5073
       +
                       f"Processing {total_entries} entries...", 

     

       5074
       5074
       +
                       total=total_entries

     

       5075
       5075
       +
                   )

     

       5076
       5076
       +
                   

     

       5077
       5077
       +
                   for username in users:

     

       5078
       5078
       +
                       entries = git_store.list_entries(username)

     

       5079
       5079
       +
                       user_metadata = index.users[username]

     

       5080
       5080
       +
                       

     

       5081
       5081
       +
                       # Get base URL for this user (use first feed URL)

     

       5082
       5082
       +
                       base_url = str(user_metadata.feeds[0]) if user_metadata.feeds else "https://example.com"

     

       5083
       5083
       +
                       

     

       5084
       5084
       +
                       for entry in entries:

     

       5085
       5085
       +
                           # Extract links from this entry

     

       5086
       5086
       +
                           entry_links = link_extractor.extract_links_from_entry(entry, username, base_url)

     

       5087
       5087
       +
                           

     

       5088
       5088
       +
                           # Track unique links per entry

     

       5089
       5089
       +
                           entry_urls_seen = set()

     

       5090
       5090
       +
                           

     

       5091
       5091
       +
                           # Categorize each link

     

       5092
       5092
       +
                           for link_data in entry_links:

     

       5093
       5093
       +
                               # Skip if we've already seen this URL in this entry

     

       5094
       5094
       +
                               if link_data.url in entry_urls_seen:

     

       5095
       5095
       +
                                   continue

     

       5096
       5096
       +
                               entry_urls_seen.add(link_data.url)

     

       5097
       5097
       +
                               

     

       5098
       5098
       +
                               category, target_username = categorizer.categorize_url(link_data.url, username)

     

       5099
       5099
       +
                               

     

       5100
       5100
       +
                               # Add to link dictionary (URL as key, maps to list of atom IDs)

     

       5101
       5101
       +
                               if link_data.url not in link_dict:

     

       5102
       5102
       +
                                   link_dict[link_data.url] = []

     

       5103
       5103
       +
                               if link_data.entry_id not in link_dict[link_data.url]:

     

       5104
       5104
       +
                                   link_dict[link_data.url].append(link_data.entry_id)

     

       5105
       5105
       +
                                   

     

       5106
       5106
       +
                                   # Also add to reverse mapping (atom ID -> list of URLs)

     

       5107
       5107
       +
                                   if link_data.entry_id not in reverse_dict:

     

       5108
       5108
       +
                                       reverse_dict[link_data.entry_id] = []

     

       5109
       5109
       +
                                   if link_data.url not in reverse_dict[link_data.entry_id]:

     

       5110
       5110
       +
                                       reverse_dict[link_data.entry_id].append(link_data.url)

     

       5111
       5111
       +
                               

     

       5112
       5112
       +
                               # Add category info to link data for categories tracking

     

       5113
       5113
       +
                               link_info = link_data.to_dict()

     

       5114
       5114
       +
                               link_info["category"] = category

     

       5115
       5115
       +
                               link_info["target_username"] = target_username

     

       5116
       5116
       +
                               

     

       5117
       5117
       +
                               all_links.append(link_info)

     

       5118
       5118
       +
                               link_categories[category].append(link_info)

     

       5119
       5119
       +
                           

     

       5120
       5120
       +
                           progress.advance(processing_task)

     

       5121
       5121
       +
                           

     

       5122
       5122
       +
                           if verbose and entry_links:

     

       5123
       5123
       +
                               console.print(f"  Found {len(entry_links)} links in {username}:{entry.title[:50]}...")

     

       5124
       5124
       +
               

     

       5125
       5125
       +
               # Determine output path

     

       5126
       5126
       +
               if output_file:

     

       5127
       5127
       +
                   output_path = output_file

     

       5128
       5128
       +
               else:

     

       5129
       5129
       +
                   output_path = config.git_store / "links.json"

     

       5130
       5130
       +
               

     

       5131
       5131
       +
               # Save all extracted links (not just filtered ones)

     

       5132
       5132
       +
               if verbose:

     

       5133
       5133
       +
                   console.print("Preparing output data...")

     

       5134
       5134
       +
               

     

       5135
       5135
       +
               # Build a set of all URLs that correspond to posts in the git database

     

       5136
       5136
       +
               registered_urls = set()

     

       5137
       5137
       +
               

     

       5138
       5138
       +
               # Get all entries from all users and build URL mappings

     

       5139
       5139
       +
               for username in users:

     

       5140
       5140
       +
                   entries = git_store.list_entries(username)

     

       5141
       5141
       +
                   user_metadata = index.users[username]

     

       5142
       5142
       +
                   

     

       5143
       5143
       +
                   for entry in entries:

     

       5144
       5144
       +
                       # Try to match entry URLs with extracted links

     

       5145
       5145
       +
                       if hasattr(entry, 'link') and entry.link:

     

       5146
       5146
       +
                           registered_urls.add(str(entry.link))

     

       5147
       5147
       +
                       

     

       5148
       5148
       +
                       # Also check entry alternate links if they exist

     

       5149
       5149
       +
                       if hasattr(entry, 'links') and entry.links:

     

       5150
       5150
       +
                           for link in entry.links:

     

       5151
       5151
       +
                               if hasattr(link, 'href') and link.href:

     

       5152
       5152
       +
                                   registered_urls.add(str(link.href))

     

       5153
       5153
       +
               

     

       5154
       5154
       +
               # Build unified structure with metadata

     

       5155
       5155
       +
               unified_links = {}

     

       5156
       5156
       +
               reverse_mapping = {}

     

       5157
       5157
       +
               

     

       5158
       5158
       +
               for url, entry_ids in link_dict.items():

     

       5159
       5159
       +
                   unified_links[url] = {

     

       5160
       5160
       +
                       "referencing_entries": entry_ids

     

       5161
       5161
       +
                   }

     

       5162
       5162
       +
                   

     

       5163
       5163
       +
                   # Find target username if this is a tracked post

     

       5164
       5164
       +
                   if url in registered_urls:

     

       5165
       5165
       +
                       for username in users:

     

       5166
       5166
       +
                           user_domains_set = {domain for domain in user_domains.get(username, [])}

     

       5167
       5167
       +
                           if any(domain in url for domain in user_domains_set):

     

       5168
       5168
       +
                               unified_links[url]["target_username"] = username

     

       5169
       5169
       +
                               break

     

       5170
       5170
       +
                   

     

       5171
       5171
       +
                   # Build reverse mapping

     

       5172
       5172
       +
                   for entry_id in entry_ids:

     

       5173
       5173
       +
                       if entry_id not in reverse_mapping:

     

       5174
       5174
       +
                           reverse_mapping[entry_id] = []

     

       5175
       5175
       +
                       if url not in reverse_mapping[entry_id]:

     

       5176
       5176
       +
                           reverse_mapping[entry_id].append(url)

     

       5177
       5177
       +
               

     

       5178
       5178
       +
               # Create unified output data

     

       5179
       5179
       +
               output_data = {

     

       5180
       5180
       +
                   "links": unified_links,

     

       5181
       5181
       +
                   "reverse_mapping": reverse_mapping,

     

       5182
       5182
       +
                   "user_domains": {k: list(v) for k, v in user_domains.items()}

     

       5183
       5183
       +
               }

     

       5184
       5184
       +
               

     

       5185
       5185
       +
               if verbose:

     

       5186
       5186
       +
                   console.print(f"Found {len(registered_urls)} registered post URLs")

     

       5187
       5187
       +
                   console.print(f"Found {len(link_dict)} total links, {sum(1 for link in unified_links.values() if 'target_username' in link)} tracked posts")

     

       5188
       5188
       +
               

     

       5189
       5189
       +
               # Save unified data

     

       5190
       5190
       +
               with open(output_path, "w") as f:

     

       5191
       5191
       +
                   json.dump(output_data, f, indent=2, default=str)

     

       5192
       5192
       +
               

     

       5193
       5193
       +
               # Show summary

     

       5194
       5194
       +
               if not get_tsv_mode():

     

       5195
       5195
       +
                   console.print("\n[green]✓ Links extraction completed successfully[/green]")

     

       5196
       5196
       +
               

     

       5197
       5197
       +
               # Create summary table or TSV output

     

       5198
       5198
       +
               if get_tsv_mode():

     

       5199
       5199
       +
                   print("Category\tCount\tDescription")

     

       5200
       5200
       +
                   print(f"Internal\t{len(link_categories['internal'])}\tLinks to same user's domain")

     

       5201
       5201
       +
                   print(f"User\t{len(link_categories['user'])}\tLinks to other tracked users")

     

       5202
       5202
       +
                   print(f"Unknown\t{len(link_categories['unknown'])}\tLinks to external sites")

     

       5203
       5203
       +
                   print(f"Total Extracted\t{len(all_links)}\tAll extracted links")

     

       5204
       5204
       +
                   print(f"Saved to Output\t{len(output_data['links'])}\tLinks saved to output file")

     

       5205
       5205
       +
                   print(f"Cross-references\t{sum(1 for link in unified_links.values() if 'target_username' in link)}\tLinks to registered posts only")

     

       5206
       5206
       +
               else:

     

       5207
       5207
       +
                   table = Table(title="Links Summary")

     

       5208
       5208
       +
                   table.add_column("Category", style="cyan")

     

       5209
       5209
       +
                   table.add_column("Count", style="green")

     

       5210
       5210
       +
                   table.add_column("Description", style="white")

     

       5211
       5211
       +
                   

     

       5212
       5212
       +
                   table.add_row("Internal", str(len(link_categories["internal"])), "Links to same user's domain")

     

       5213
       5213
       +
                   table.add_row("User", str(len(link_categories["user"])), "Links to other tracked users")

     

       5214
       5214
       +
                   table.add_row("Unknown", str(len(link_categories["unknown"])), "Links to external sites")

     

       5215
       5215
       +
                   table.add_row("Total Extracted", str(len(all_links)), "All extracted links")

     

       5216
       5216
       +
                   table.add_row("Saved to Output", str(len(output_data['links'])), "Links saved to output file")

     

       5217
       5217
       +
                   table.add_row("Cross-references", str(sum(1 for link in unified_links.values() if 'target_username' in link)), "Links to registered posts only")

     

       5218
       5218
       +
                   

     

       5219
       5219
       +
                   console.print(table)

     

       5220
       5220
       +
               

     

       5221
       5221
       +
               # Show user links if verbose

     

       5222
       5222
       +
               if verbose and link_categories["user"]:

     

       5223
       5223
       +
                   if get_tsv_mode():

     

       5224
       5224
       +
                       print("User Link Source\tUser Link Target\tLink Count")

     

       5225
       5225
       +
                       user_link_counts = {}

     

       5226
       5226
       +
                       

     

       5227
       5227
       +
                       for link in link_categories["user"]:

     

       5228
       5228
       +
                           key = f"{link['username']} -> {link['target_username']}"

     

       5229
       5229
       +
                           user_link_counts[key] = user_link_counts.get(key, 0) + 1

     

       5230
       5230
       +
                       

     

       5231
       5231
       +
                       for link_pair, count in sorted(user_link_counts.items(), key=lambda x: x[1], reverse=True)[:10]:

     

       5232
       5232
       +
                           source, target = link_pair.split(" -> ")

     

       5233
       5233
       +
                           print(f"{source}\t{target}\t{count}")

     

       5234
       5234
       +
                   else:

     

       5235
       5235
       +
                       console.print("\n[bold]User-to-user links:[/bold]")

     

       5236
       5236
       +
                       user_link_counts = {}

     

       5237
       5237
       +
                       

     

       5238
       5238
       +
                       for link in link_categories["user"]:

     

       5239
       5239
       +
                           key = f"{link['username']} -> {link['target_username']}"

     

       5240
       5240
       +
                           user_link_counts[key] = user_link_counts.get(key, 0) + 1

     

       5241
       5241
       +
                       

     

       5242
       5242
       +
                       for link_pair, count in sorted(user_link_counts.items(), key=lambda x: x[1], reverse=True)[:10]:

     

       5243
       5243
       +
                           console.print(f"  {link_pair}: {count} links")

     

       5244
       5244
       +
               

     

       5245
       5245
       +
               if not get_tsv_mode():

     

       5246
       5246
       +
                   console.print(f"\nUnified links data saved to: {output_path}")

     

       5247
       5247
       +
       

     

       5248
       5248
       +
           except Exception as e:

     

       5249
       5249
       +
               console.print(f"[red]Error extracting links: {e}[/red]")

     

       5250
       5250
       +
               if verbose:

     

       5251
       5251
       +
                   console.print_exception()

     

       5252
       5252
       +
               raise typer.Exit(1)

     

       5253
       5253
       +
       </file>

     

       5254
       5254
       +
       

     

       5255
       5255
       +
       <file path="src/thicket/cli/commands/list_cmd.py">

     

       5256
       5256
       +
       """List command for thicket."""

     

       5257
       5257
       +
       

     

       5258
       5258
       +
       import re

     

       5259
       5259
       +
       from pathlib import Path

     

       5260
       5260
       +
       from typing import Optional

     

       5261
       5261
       +
       

     

       5262
       5262
       +
       import typer

     

       5263
       5263
       +
       from rich.table import Table

     

       5264
       5264
       +
       

     

       5265
       5265
       +
       from ...core.git_store import GitStore

     

       5266
       5266
       +
       from ..main import app

     

       5267
       5267
       +
       from ..utils import (

     

       5268
       5268
       +
           console,

     

       5269
       5269
       +
           load_config,

     

       5270
       5270
       +
           print_error,

     

       5271
       5271
       +
           print_feeds_table,

     

       5272
       5272
       +
           print_feeds_table_from_git,

     

       5273
       5273
       +
           print_info,

     

       5274
       5274
       +
           print_users_table,

     

       5275
       5275
       +
           print_users_table_from_git,

     

       5276
       5276
       +
           print_entries_tsv,

     

       5277
       5277
       +
           get_tsv_mode,

     

       5278
       5278
       +
       )

     

       5279
       5279
       +
       

     

       5280
       5280
       +
       

     

       5281
       5281
       +
       @app.command("list")

     

       5282
       5282
       +
       def list_command(

     

       5283
       5283
       +
           what: str = typer.Argument(..., help="What to list: 'users', 'feeds', 'entries'"),

     

       5284
       5284
       +
           user: Optional[str] = typer.Option(

     

       5285
       5285
       +
               None, "--user", "-u", help="Filter by specific user"

     

       5286
       5286
       +
           ),

     

       5287
       5287
       +
           limit: Optional[int] = typer.Option(

     

       5288
       5288
       +
               None, "--limit", "-l", help="Limit number of results"

     

       5289
       5289
       +
           ),

     

       5290
       5290
       +
           config_file: Optional[Path] = typer.Option(

     

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

     

       5292
       5292
       +
           ),

     

       5293
       5293
       +
       ) -> None:

     

       5294
       5294
       +
           """List users, feeds, or entries."""

     

       5295
       5295
       +
       

     

       5296
       5296
       +
           # Load configuration

     

       5297
       5297
       +
           config = load_config(config_file)

     

       5298
       5298
       +
       

     

       5299
       5299
       +
           # Initialize Git store

     

       5300
       5300
       +
           git_store = GitStore(config.git_store)

     

       5301
       5301
       +
       

     

       5302
       5302
       +
           if what == "users":

     

       5303
       5303
       +
               list_users(git_store)

     

       5304
       5304
       +
           elif what == "feeds":

     

       5305
       5305
       +
               list_feeds(git_store, user)

     

       5306
       5306
       +
           elif what == "entries":

     

       5307
       5307
       +
               list_entries(git_store, user, limit)

     

       5308
       5308
       +
           else:

     

       5309
       5309
       +
               print_error(f"Unknown list type: {what}")

     

       5310
       5310
       +
               print_error("Use 'users', 'feeds', or 'entries'")

     

       5311
       5311
       +
               raise typer.Exit(1)

     

       5312
       5312
       +
       

     

       5313
       5313
       +
       

     

       5314
       5314
       +
       def list_users(git_store: GitStore) -> None:

     

       5315
       5315
       +
           """List all users."""

     

       5316
       5316
       +
           index = git_store._load_index()

     

       5317
       5317
       +
           users = list(index.users.values())

     

       5318
       5318
       +
           

     

       5319
       5319
       +
           if not users:

     

       5320
       5320
       +
               print_info("No users configured")

     

       5321
       5321
       +
               return

     

       5322
       5322
       +
       

     

       5323
       5323
       +
           print_users_table_from_git(users)

     

       5324
       5324
       +
       

     

       5325
       5325
       +
       

     

       5326
       5326
       +
       def list_feeds(git_store: GitStore, username: Optional[str] = None) -> None:

     

       5327
       5327
       +
           """List feeds, optionally filtered by user."""

     

       5328
       5328
       +
           if username:

     

       5329
       5329
       +
               user = git_store.get_user(username)

     

       5330
       5330
       +
               if not user:

     

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

     

       5332
       5332
       +
                   raise typer.Exit(1)

     

       5333
       5333
       +
       

     

       5334
       5334
       +
               if not user.feeds:

     

       5335
       5335
       +
                   print_info(f"No feeds configured for user '{username}'")

     

       5336
       5336
       +
                   return

     

       5337
       5337
       +
       

     

       5338
       5338
       +
           print_feeds_table_from_git(git_store, username)

     

       5339
       5339
       +
       

     

       5340
       5340
       +
       

     

       5341
       5341
       +
       def list_entries(git_store: GitStore, username: Optional[str] = None, limit: Optional[int] = None) -> None:

     

       5342
       5342
       +
           """List entries, optionally filtered by user."""

     

       5343
       5343
       +
       

     

       5344
       5344
       +
           if username:

     

       5345
       5345
       +
               # List entries for specific user

     

       5346
       5346
       +
               user = git_store.get_user(username)

     

       5347
       5347
       +
               if not user:

     

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

     

       5349
       5349
       +
                   raise typer.Exit(1)

     

       5350
       5350
       +
       

     

       5351
       5351
       +
               entries = git_store.list_entries(username, limit)

     

       5352
       5352
       +
               if not entries:

     

       5353
       5353
       +
                   print_info(f"No entries found for user '{username}'")

     

       5354
       5354
       +
                   return

     

       5355
       5355
       +
       

     

       5356
       5356
       +
               print_entries_table([entries], [username])

     

       5357
       5357
       +
       

     

       5358
       5358
       +
           else:

     

       5359
       5359
       +
               # List entries for all users

     

       5360
       5360
       +
               all_entries = []

     

       5361
       5361
       +
               all_usernames = []

     

       5362
       5362
       +
       

     

       5363
       5363
       +
               index = git_store._load_index()

     

       5364
       5364
       +
               for user in index.users.values():

     

       5365
       5365
       +
                   entries = git_store.list_entries(user.username, limit)

     

       5366
       5366
       +
                   if entries:

     

       5367
       5367
       +
                       all_entries.append(entries)

     

       5368
       5368
       +
                       all_usernames.append(user.username)

     

       5369
       5369
       +
       

     

       5370
       5370
       +
               if not all_entries:

     

       5371
       5371
       +
                   print_info("No entries found")

     

       5372
       5372
       +
                   return

     

       5373
       5373
       +
       

     

       5374
       5374
       +
               print_entries_table(all_entries, all_usernames)

     

       5375
       5375
       +
       

     

       5376
       5376
       +
       

     

       5377
       5377
       +
       def _clean_html_content(content: Optional[str]) -> str:

     

       5378
       5378
       +
           """Clean HTML content for display in table."""

     

       5379
       5379
       +
           if not content:

     

       5380
       5380
       +
               return ""

     

       5381
       5381
       +
           

     

       5382
       5382
       +
           # Remove HTML tags

     

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

     

       5384
       5384
       +
           # Replace multiple whitespace with single space

     

       5385
       5385
       +
           clean_text = re.sub(r'\s+', ' ', clean_text)

     

       5386
       5386
       +
           # Strip and limit length

     

       5387
       5387
       +
           clean_text = clean_text.strip()

     

       5388
       5388
       +
           if len(clean_text) > 100:

     

       5389
       5389
       +
               clean_text = clean_text[:97] + "..."

     

       5390
       5390
       +
           

     

       5391
       5391
       +
           return clean_text

     

       5392
       5392
       +
       

     

       5393
       5393
       +
       

     

       5394
       5394
       +
       def print_entries_table(entries_by_user: list[list], usernames: list[str]) -> None:

     

       5395
       5395
       +
           """Print a table of entries."""

     

       5396
       5396
       +
           if get_tsv_mode():

     

       5397
       5397
       +
               print_entries_tsv(entries_by_user, usernames)

     

       5398
       5398
       +
               return

     

       5399
       5399
       +
               

     

       5400
       5400
       +
           table = Table(title="Feed Entries")

     

       5401
       5401
       +
           table.add_column("User", style="cyan", no_wrap=True)

     

       5402
       5402
       +
           table.add_column("Title", style="bold")

     

       5403
       5403
       +
           table.add_column("Updated", style="blue")

     

       5404
       5404
       +
           table.add_column("URL", style="green")

     

       5405
       5405
       +
       

     

       5406
       5406
       +
           # Combine all entries with usernames

     

       5407
       5407
       +
           all_entries = []

     

       5408
       5408
       +
           for entries, username in zip(entries_by_user, usernames):

     

       5409
       5409
       +
               for entry in entries:

     

       5410
       5410
       +
                   all_entries.append((username, entry))

     

       5411
       5411
       +
       

     

       5412
       5412
       +
           # Sort by updated time (newest first)

     

       5413
       5413
       +
           all_entries.sort(key=lambda x: x[1].updated, reverse=True)

     

       5414
       5414
       +
       

     

       5415
       5415
       +
           for username, entry in all_entries:

     

       5416
       5416
       +
               # Format updated time

     

       5417
       5417
       +
               updated_str = entry.updated.strftime("%Y-%m-%d %H:%M")

     

       5418
       5418
       +
       

     

       5419
       5419
       +
               # Truncate title if too long

     

       5420
       5420
       +
               title = entry.title

     

       5421
       5421
       +
               if len(title) > 50:

     

       5422
       5422
       +
                   title = title[:47] + "..."

     

       5423
       5423
       +
       

     

       5424
       5424
       +
               table.add_row(

     

       5425
       5425
       +
                   username,

     

       5426
       5426
       +
                   title,

     

       5427
       5427
       +
                   updated_str,

     

       5428
       5428
       +
                   str(entry.link),

     

       5429
       5429
       +
               )

     

       5430
       5430
       +
       

     

       5431
       5431
       +
           console.print(table)

     

       5432
       5432
       +
       </file>

     

       5433
       5433
       +
       

     

       5434
       5434
       +
       <file path="src/thicket/cli/main.py">

     

       5435
       5435
       +
       """Main CLI application using Typer."""

     

       5436
       5436
       +
       

     

       5437
       5437
       +
       import typer

     

       5438
       5438
       +
       from rich.console import Console

     

       5439
       5439
       +
       

     

       5440
       5440
       +
       from .. import __version__

     

       5441
       5441
       +
       

     

       5442
       5442
       +
       app = typer.Typer(

     

       5443
       5443
       +
           name="thicket",

     

       5444
       5444
       +
           help="A CLI tool for persisting Atom/RSS feeds in Git repositories",

     

       5445
       5445
       +
           no_args_is_help=True,

     

       5446
       5446
       +
           rich_markup_mode="rich",

     

       5447
       5447
       +
       )

     

       5448
       5448
       +
       

     

       5449
       5449
       +
       console = Console()

     

       5450
       5450
       +
       

     

       5451
       5451
       +
       # Global state for TSV output mode

     

       5452
       5452
       +
       tsv_mode = False

     

       5453
       5453
       +
       

     

       5454
       5454
       +
       

     

       5455
       5455
       +
       def version_callback(value: bool) -> None:

     

       5456
       5456
       +
           """Show version and exit."""

     

       5457
       5457
       +
           if value:

     

       5458
       5458
       +
               console.print(f"thicket version {__version__}")

     

       5459
       5459
       +
               raise typer.Exit()

     

       5460
       5460
       +
       

     

       5461
       5461
       +
       

     

       5462
       5462
       +
       @app.callback()

     

       5463
       5463
       +
       def main(

     

       5464
       5464
       +
           version: bool = typer.Option(

     

       5465
       5465
       +
               None,

     

       5466
       5466
       +
               "--version",

     

       5467
       5467
       +
               "-v",

     

       5468
       5468
       +
               help="Show the version and exit",

     

       5469
       5469
       +
               callback=version_callback,

     

       5470
       5470
       +
               is_eager=True,

     

       5471
       5471
       +
           ),

     

       5472
       5472
       +
           tsv: bool = typer.Option(

     

       5473
       5473
       +
               False,

     

       5474
       5474
       +
               "--tsv",

     

       5475
       5475
       +
               help="Output in tab-separated values format without truncation",

     

       5476
       5476
       +
           ),

     

       5477
       5477
       +
       ) -> None:

     

       5478
       5478
       +
           """Thicket: A CLI tool for persisting Atom/RSS feeds in Git repositories."""

     

       5479
       5479
       +
           global tsv_mode

     

       5480
       5480
       +
           tsv_mode = tsv

     

       5481
       5481
       +
       

     

       5482
       5482
       +
       

     

       5483
       5483
       +
       # Import commands to register them

     

       5484
       5484
       +
       from .commands import add, duplicates, generate, index_cmd, info_cmd, init, links_cmd, list_cmd, sync

     

       5485
       5485
       +
       

     

       5486
       5486
       +
       if __name__ == "__main__":

     

       5487
       5487
       +
           app()

     

       5488
       5488
       +
       </file>

     

       5489
       5489
       +
       

     

       5490
       5490
       +
       <file path="src/thicket/core/git_store.py">

     

       5491
       5491
       +
       """Git repository operations for thicket."""

     

       5492
       5492
       +
       

     

       5493
       5493
       +
       import json

     

       5494
       5494
       +
       from datetime import datetime

     

       5495
       5495
       +
       from pathlib import Path

     

       5496
       5496
       +
       from typing import Optional

     

       5497
       5497
       +
       

     

       5498
       5498
       +
       import git

     

       5499
       5499
       +
       from git import Repo

     

       5500
       5500
       +
       

     

       5501
       5501
       +
       from ..models import AtomEntry, DuplicateMap, GitStoreIndex, UserMetadata

     

       5502
       5502
       +
       

     

       5503
       5503
       +
       

     

       5504
       5504
       +
       class GitStore:

     

       5505
       5505
       +
           """Manages the Git repository for storing feed entries."""

     

       5506
       5506
       +
       

     

       5507
       5507
       +
           def __init__(self, repo_path: Path):

     

       5508
       5508
       +
               """Initialize the Git store."""

     

       5509
       5509
       +
               self.repo_path = repo_path

     

       5510
       5510
       +
               self.repo: Optional[Repo] = None

     

       5511
       5511
       +
               self._ensure_repo()

     

       5512
       5512
       +
       

     

       5513
       5513
       +
           def _ensure_repo(self) -> None:

     

       5514
       5514
       +
               """Ensure the Git repository exists and is initialized."""

     

       5515
       5515
       +
               if not self.repo_path.exists():

     

       5516
       5516
       +
                   self.repo_path.mkdir(parents=True, exist_ok=True)

     

       5517
       5517
       +
       

     

       5518
       5518
       +
               try:

     

       5519
       5519
       +
                   self.repo = Repo(self.repo_path)

     

       5520
       5520
       +
               except git.InvalidGitRepositoryError:

     

       5521
       5521
       +
                   # Initialize new repository

     

       5522
       5522
       +
                   self.repo = Repo.init(self.repo_path)

     

       5523
       5523
       +
                   self._create_initial_structure()

     

       5524
       5524
       +
       

     

       5525
       5525
       +
           def _create_initial_structure(self) -> None:

     

       5526
       5526
       +
               """Create initial Git store structure."""

     

       5527
       5527
       +
               # Create index.json

     

       5528
       5528
       +
               index = GitStoreIndex(

     

       5529
       5529
       +
                   created=datetime.now(),

     

       5530
       5530
       +
                   last_updated=datetime.now(),

     

       5531
       5531
       +
               )

     

       5532
       5532
       +
               self._save_index(index)

     

       5533
       5533
       +
       

     

       5534
       5534
       +
               # Create duplicates.json

     

       5535
       5535
       +
               duplicates = DuplicateMap()

     

       5536
       5536
       +
               self._save_duplicates(duplicates)

     

       5537
       5537
       +
       

     

       5538
       5538
       +
               # Create initial commit

     

       5539
       5539
       +
               self.repo.index.add(["index.json", "duplicates.json"])

     

       5540
       5540
       +
               self.repo.index.commit("Initial thicket repository structure")

     

       5541
       5541
       +
       

     

       5542
       5542
       +
           def _save_index(self, index: GitStoreIndex) -> None:

     

       5543
       5543
       +
               """Save the index to index.json."""

     

       5544
       5544
       +
               index_path = self.repo_path / "index.json"

     

       5545
       5545
       +
               with open(index_path, "w") as f:

     

       5546
       5546
       +
                   json.dump(index.model_dump(mode="json", exclude_none=True), f, indent=2, default=str)

     

       5547
       5547
       +
       

     

       5548
       5548
       +
           def _load_index(self) -> GitStoreIndex:

     

       5549
       5549
       +
               """Load the index from index.json."""

     

       5550
       5550
       +
               index_path = self.repo_path / "index.json"

     

       5551
       5551
       +
               if not index_path.exists():

     

       5552
       5552
       +
                   return GitStoreIndex(

     

       5553
       5553
       +
                       created=datetime.now(),

     

       5554
       5554
       +
                       last_updated=datetime.now(),

     

       5555
       5555
       +
                   )

     

       5556
       5556
       +
       

     

       5557
       5557
       +
               with open(index_path) as f:

     

       5558
       5558
       +
                   data = json.load(f)

     

       5559
       5559
       +
       

     

       5560
       5560
       +
               return GitStoreIndex(**data)

     

       5561
       5561
       +
       

     

       5562
       5562
       +
           def _save_duplicates(self, duplicates: DuplicateMap) -> None:

     

       5563
       5563
       +
               """Save duplicates map to duplicates.json."""

     

       5564
       5564
       +
               duplicates_path = self.repo_path / "duplicates.json"

     

       5565
       5565
       +
               with open(duplicates_path, "w") as f:

     

       5566
       5566
       +
                   json.dump(duplicates.model_dump(exclude_none=True), f, indent=2)

     

       5567
       5567
       +
       

     

       5568
       5568
       +
           def _load_duplicates(self) -> DuplicateMap:

     

       5569
       5569
       +
               """Load duplicates map from duplicates.json."""

     

       5570
       5570
       +
               duplicates_path = self.repo_path / "duplicates.json"

     

       5571
       5571
       +
               if not duplicates_path.exists():

     

       5572
       5572
       +
                   return DuplicateMap()

     

       5573
       5573
       +
       

     

       5574
       5574
       +
               with open(duplicates_path) as f:

     

       5575
       5575
       +
                   data = json.load(f)

     

       5576
       5576
       +
       

     

       5577
       5577
       +
               return DuplicateMap(**data)

     

       5578
       5578
       +
       

     

       5579
       5579
       +
           def add_user(self, username: str, display_name: Optional[str] = None,

     

       5580
       5580
       +
                        email: Optional[str] = None, homepage: Optional[str] = None,

     

       5581
       5581
       +
                        icon: Optional[str] = None, feeds: Optional[list[str]] = None) -> UserMetadata:

     

       5582
       5582
       +
               """Add a new user to the Git store."""

     

       5583
       5583
       +
               index = self._load_index()

     

       5584
       5584
       +
       

     

       5585
       5585
       +
               # Create user directory

     

       5586
       5586
       +
               user_dir = self.repo_path / username

     

       5587
       5587
       +
               user_dir.mkdir(exist_ok=True)

     

       5588
       5588
       +
       

     

       5589
       5589
       +
               # Create user metadata

     

       5590
       5590
       +
               user_metadata = UserMetadata(

     

       5591
       5591
       +
                   username=username,

     

       5592
       5592
       +
                   display_name=display_name,

     

       5593
       5593
       +
                   email=email,

     

       5594
       5594
       +
                   homepage=homepage,

     

       5595
       5595
       +
                   icon=icon,

     

       5596
       5596
       +
                   feeds=feeds or [],

     

       5597
       5597
       +
                   directory=username,

     

       5598
       5598
       +
                   created=datetime.now(),

     

       5599
       5599
       +
                   last_updated=datetime.now(),

     

       5600
       5600
       +
               )

     

       5601
       5601
       +
       

     

       5602
       5602
       +
       

     

       5603
       5603
       +
               # Update index

     

       5604
       5604
       +
               index.add_user(user_metadata)

     

       5605
       5605
       +
               self._save_index(index)

     

       5606
       5606
       +
       

     

       5607
       5607
       +
               return user_metadata

     

       5608
       5608
       +
       

     

       5609
       5609
       +
           def get_user(self, username: str) -> Optional[UserMetadata]:

     

       5610
       5610
       +
               """Get user metadata by username."""

     

       5611
       5611
       +
               index = self._load_index()

     

       5612
       5612
       +
               return index.get_user(username)

     

       5613
       5613
       +
       

     

       5614
       5614
       +
           def update_user(self, username: str, **kwargs) -> bool:

     

       5615
       5615
       +
               """Update user metadata."""

     

       5616
       5616
       +
               index = self._load_index()

     

       5617
       5617
       +
               user = index.get_user(username)

     

       5618
       5618
       +
       

     

       5619
       5619
       +
               if not user:

     

       5620
       5620
       +
                   return False

     

       5621
       5621
       +
       

     

       5622
       5622
       +
               # Update user metadata

     

       5623
       5623
       +
               for key, value in kwargs.items():

     

       5624
       5624
       +
                   if hasattr(user, key) and value is not None:

     

       5625
       5625
       +
                       setattr(user, key, value)

     

       5626
       5626
       +
       

     

       5627
       5627
       +
               user.update_timestamp()

     

       5628
       5628
       +
       

     

       5629
       5629
       +
       

     

       5630
       5630
       +
               # Update index

     

       5631
       5631
       +
               index.add_user(user)

     

       5632
       5632
       +
               self._save_index(index)

     

       5633
       5633
       +
       

     

       5634
       5634
       +
               return True

     

       5635
       5635
       +
       

     

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

     

       5637
       5637
       +
               """Store an entry in the user's directory."""

     

       5638
       5638
       +
               user = self.get_user(username)

     

       5639
       5639
       +
               if not user:

     

       5640
       5640
       +
                   return False

     

       5641
       5641
       +
       

     

       5642
       5642
       +
               # Sanitize entry ID for filename

     

       5643
       5643
       +
               from .feed_parser import FeedParser

     

       5644
       5644
       +
               parser = FeedParser()

     

       5645
       5645
       +
               safe_id = parser.sanitize_entry_id(entry.id)

     

       5646
       5646
       +
       

     

       5647
       5647
       +
               # Create entry file

     

       5648
       5648
       +
               user_dir = self.repo_path / user.directory

     

       5649
       5649
       +
               entry_path = user_dir / f"{safe_id}.json"

     

       5650
       5650
       +
       

     

       5651
       5651
       +
               # Check if entry already exists

     

       5652
       5652
       +
               entry_exists = entry_path.exists()

     

       5653
       5653
       +
       

     

       5654
       5654
       +
               # Save entry

     

       5655
       5655
       +
               with open(entry_path, "w") as f:

     

       5656
       5656
       +
                   json.dump(entry.model_dump(mode="json", exclude_none=True), f, indent=2, default=str)

     

       5657
       5657
       +
       

     

       5658
       5658
       +
               # Update user metadata if new entry

     

       5659
       5659
       +
               if not entry_exists:

     

       5660
       5660
       +
                   index = self._load_index()

     

       5661
       5661
       +
                   index.update_entry_count(username, 1)

     

       5662
       5662
       +
                   self._save_index(index)

     

       5663
       5663
       +
       

     

       5664
       5664
       +
               return True

     

       5665
       5665
       +
       

     

       5666
       5666
       +
           def get_entry(self, username: str, entry_id: str) -> Optional[AtomEntry]:

     

       5667
       5667
       +
               """Get an entry by username and entry ID."""

     

       5668
       5668
       +
               user = self.get_user(username)

     

       5669
       5669
       +
               if not user:

     

       5670
       5670
       +
                   return None

     

       5671
       5671
       +
       

     

       5672
       5672
       +
               # Sanitize entry ID

     

       5673
       5673
       +
               from .feed_parser import FeedParser

     

       5674
       5674
       +
               parser = FeedParser()

     

       5675
       5675
       +
               safe_id = parser.sanitize_entry_id(entry_id)

     

       5676
       5676
       +
       

     

       5677
       5677
       +
               entry_path = self.repo_path / user.directory / f"{safe_id}.json"

     

       5678
       5678
       +
               if not entry_path.exists():

     

       5679
       5679
       +
                   return None

     

       5680
       5680
       +
       

     

       5681
       5681
       +
               with open(entry_path) as f:

     

       5682
       5682
       +
                   data = json.load(f)

     

       5683
       5683
       +
       

     

       5684
       5684
       +
               return AtomEntry(**data)

     

       5685
       5685
       +
       

     

       5686
       5686
       +
           def list_entries(self, username: str, limit: Optional[int] = None) -> list[AtomEntry]:

     

       5687
       5687
       +
               """List entries for a user."""

     

       5688
       5688
       +
               user = self.get_user(username)

     

       5689
       5689
       +
               if not user:

     

       5690
       5690
       +
                   return []

     

       5691
       5691
       +
       

     

       5692
       5692
       +
               user_dir = self.repo_path / user.directory

     

       5693
       5693
       +
               if not user_dir.exists():

     

       5694
       5694
       +
                   return []

     

       5695
       5695
       +
       

     

       5696
       5696
       +
               entries = []

     

       5697
       5697
       +
               entry_files = sorted(user_dir.glob("*.json"), key=lambda p: p.stat().st_mtime, reverse=True)

     

       5698
       5698
       +
       

     

       5699
       5699
       +
       

     

       5700
       5700
       +
               if limit:

     

       5701
       5701
       +
                   entry_files = entry_files[:limit]

     

       5702
       5702
       +
       

     

       5703
       5703
       +
               for entry_file in entry_files:

     

       5704
       5704
       +
                   try:

     

       5705
       5705
       +
                       with open(entry_file) as f:

     

       5706
       5706
       +
                           data = json.load(f)

     

       5707
       5707
       +
                       entries.append(AtomEntry(**data))

     

       5708
       5708
       +
                   except Exception:

     

       5709
       5709
       +
                       # Skip invalid entries

     

       5710
       5710
       +
                       continue

     

       5711
       5711
       +
       

     

       5712
       5712
       +
               return entries

     

       5713
       5713
       +
       

     

       5714
       5714
       +
           def get_duplicates(self) -> DuplicateMap:

     

       5715
       5715
       +
               """Get the duplicates map."""

     

       5716
       5716
       +
               return self._load_duplicates()

     

       5717
       5717
       +
       

     

       5718
       5718
       +
           def add_duplicate(self, duplicate_id: str, canonical_id: str) -> None:

     

       5719
       5719
       +
               """Add a duplicate mapping."""

     

       5720
       5720
       +
               duplicates = self._load_duplicates()

     

       5721
       5721
       +
               duplicates.add_duplicate(duplicate_id, canonical_id)

     

       5722
       5722
       +
               self._save_duplicates(duplicates)

     

       5723
       5723
       +
       

     

       5724
       5724
       +
           def remove_duplicate(self, duplicate_id: str) -> bool:

     

       5725
       5725
       +
               """Remove a duplicate mapping."""

     

       5726
       5726
       +
               duplicates = self._load_duplicates()

     

       5727
       5727
       +
               result = duplicates.remove_duplicate(duplicate_id)

     

       5728
       5728
       +
               self._save_duplicates(duplicates)

     

       5729
       5729
       +
               return result

     

       5730
       5730
       +
       

     

       5731
       5731
       +
           def commit_changes(self, message: str) -> None:

     

       5732
       5732
       +
               """Commit all changes to the Git repository."""

     

       5733
       5733
       +
               if not self.repo:

     

       5734
       5734
       +
                   return

     

       5735
       5735
       +
       

     

       5736
       5736
       +
               # Add all changes

     

       5737
       5737
       +
               self.repo.git.add(A=True)

     

       5738
       5738
       +
       

     

       5739
       5739
       +
               # Check if there are changes to commit

     

       5740
       5740
       +
               if self.repo.index.diff("HEAD"):

     

       5741
       5741
       +
                   self.repo.index.commit(message)

     

       5742
       5742
       +
       

     

       5743
       5743
       +
           def get_stats(self) -> dict:

     

       5744
       5744
       +
               """Get statistics about the Git store."""

     

       5745
       5745
       +
               index = self._load_index()

     

       5746
       5746
       +
               duplicates = self._load_duplicates()

     

       5747
       5747
       +
       

     

       5748
       5748
       +
               return {

     

       5749
       5749
       +
                   "total_users": len(index.users),

     

       5750
       5750
       +
                   "total_entries": index.total_entries,

     

       5751
       5751
       +
                   "total_duplicates": len(duplicates.duplicates),

     

       5752
       5752
       +
                   "last_updated": index.last_updated,

     

       5753
       5753
       +
                   "repository_size": sum(f.stat().st_size for f in self.repo_path.rglob("*") if f.is_file()),

     

       5754
       5754
       +
               }

     

       5755
       5755
       +
       

     

       5756
       5756
       +
           def search_entries(self, query: str, username: Optional[str] = None,

     

       5757
       5757
       +
                             limit: Optional[int] = None) -> list[tuple[str, AtomEntry]]:

     

       5758
       5758
       +
               """Search entries by content."""

     

       5759
       5759
       +
               results = []

     

       5760
       5760
       +
       

     

       5761
       5761
       +
               # Get users to search

     

       5762
       5762
       +
               index = self._load_index()

     

       5763
       5763
       +
               users = [index.get_user(username)] if username else list(index.users.values())

     

       5764
       5764
       +
               users = [u for u in users if u is not None]

     

       5765
       5765
       +
       

     

       5766
       5766
       +
               for user in users:

     

       5767
       5767
       +
                   user_dir = self.repo_path / user.directory

     

       5768
       5768
       +
                   if not user_dir.exists():

     

       5769
       5769
       +
                       continue

     

       5770
       5770
       +
       

     

       5771
       5771
       +
                   entry_files = user_dir.glob("*.json")

     

       5772
       5772
       +
       

     

       5773
       5773
       +
                   for entry_file in entry_files:

     

       5774
       5774
       +
                       try:

     

       5775
       5775
       +
                           with open(entry_file) as f:

     

       5776
       5776
       +
                               data = json.load(f)

     

       5777
       5777
       +
       

     

       5778
       5778
       +
                           entry = AtomEntry(**data)

     

       5779
       5779
       +
       

     

       5780
       5780
       +
                           # Simple text search in title, summary, and content

     

       5781
       5781
       +
                           searchable_text = " ".join(filter(None, [

     

       5782
       5782
       +
                               entry.title,

     

       5783
       5783
       +
                               entry.summary or "",

     

       5784
       5784
       +
                               entry.content or "",

     

       5785
       5785
       +
                           ])).lower()

     

       5786
       5786
       +
       

     

       5787
       5787
       +
                           if query.lower() in searchable_text:

     

       5788
       5788
       +
                               results.append((user.username, entry))

     

       5789
       5789
       +
       

     

       5790
       5790
       +
                               if limit and len(results) >= limit:

     

       5791
       5791
       +
                                   return results

     

       5792
       5792
       +
       

     

       5793
       5793
       +
                       except Exception:

     

       5794
       5794
       +
                           # Skip invalid entries

     

       5795
       5795
       +
                           continue

     

       5796
       5796
       +
       

     

       5797
       5797
       +
               # Sort by updated time (newest first)

     

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

     

       5799
       5799
       +
       

     

       5800
       5800
       +
               return results[:limit] if limit else results

     

       5801
       5801
       +
       </file>

     

       5802
       5802
       +
       

     

       5803
       5803
       +
       <file path="ARCH.md">

     

       5804
       5804
       +
       # Thicket Architecture Design

     

       5805
       5805
       +
       

     

       5806
       5806
       +
       ## Overview

     

       5807
       5807
       +
       Thicket is a modern CLI tool for persisting Atom/RSS feeds in a Git repository, designed to enable distributed webblog comment structures.

     

       5808
       5808
       +
       

     

       5809
       5809
       +
       ## Technology Stack

     

       5810
       5810
       +
       

     

       5811
       5811
       +
       ### Core Libraries

     

       5812
       5812
       +
       

     

       5813
       5813
       +
       #### CLI Framework

     

       5814
       5814
       +
       - **Typer** (0.15.x) - Modern CLI framework with type hints

     

       5815
       5815
       +
       - **Rich** (13.x) - Beautiful terminal output, progress bars, and tables

     

       5816
       5816
       +
       - **prompt-toolkit** - Interactive prompts when needed

     

       5817
       5817
       +
       

     

       5818
       5818
       +
       #### Feed Processing

     

       5819
       5819
       +
       - **feedparser** (6.0.11) - Universal feed parser supporting RSS 0.9x, RSS 1.0, RSS 2.0, CDF, Atom 0.3, and Atom 1.0

     

       5820
       5820
       +
         - Alternative: **atoma** for stricter Atom/RSS parsing with JSON feed support

     

       5821
       5821
       +
         - Alternative: **fastfeedparser** for high-performance parsing (10x faster)

     

       5822
       5822
       +
       

     

       5823
       5823
       +
       #### Git Integration

     

       5824
       5824
       +
       - **GitPython** (3.1.44) - High-level git operations, requires git CLI

     

       5825
       5825
       +
         - Alternative: **pygit2** (1.18.0) - Direct libgit2 bindings, better for authentication

     

       5826
       5826
       +
       

     

       5827
       5827
       +
       #### HTTP Client

     

       5828
       5828
       +
       - **httpx** (0.28.x) - Modern async/sync HTTP client with connection pooling

     

       5829
       5829
       +
       - **aiohttp** (3.11.x) - For async-only operations if needed

     

       5830
       5830
       +
       

     

       5831
       5831
       +
       #### Configuration & Data Models

     

       5832
       5832
       +
       - **pydantic** (2.11.x) - Data validation and settings management

     

       5833
       5833
       +
       - **pydantic-settings** (2.10.x) - Configuration file handling with env var support

     

       5834
       5834
       +
       

     

       5835
       5835
       +
       #### Utilities

     

       5836
       5836
       +
       - **pendulum** (3.x) - Better datetime handling

     

       5837
       5837
       +
       - **bleach** (6.x) - HTML sanitization for feed content

     

       5838
       5838
       +
       - **platformdirs** (4.x) - Cross-platform directory paths

     

       5839
       5839
       +
       

     

       5840
       5840
       +
       ## Project Structure

     

       5841
       5841
       +
       

     

       5842
       5842
       +
       ```

     

       5843
       5843
       +
       thicket/

     

       5844
       5844
       +
       ├── pyproject.toml          # Modern Python packaging

     

       5845
       5845
       +
       ├── README.md               # Project documentation

     

       5846
       5846
       +
       ├── ARCH.md                 # This file

     

       5847
       5847
       +
       ├── CLAUDE.md               # Project instructions

     

       5848
       5848
       +
       ├── .gitignore

     

       5849
       5849
       +
       ├── src/

     

       5850
       5850
       +
       │   └── thicket/

     

       5851
       5851
       +
       │       ├── __init__.py

     

       5852
       5852
       +
       │       ├── __main__.py     # Entry point for `python -m thicket`

     

       5853
       5853
       +
       │       ├── cli/            # CLI commands and interface

     

       5854
       5854
       +
       │       │   ├── __init__.py

     

       5855
       5855
       +
       │       │   ├── main.py     # Main CLI app with Typer

     

       5856
       5856
       +
       │       │   ├── commands/   # Subcommands

     

       5857
       5857
       +
       │       │   │   ├── __init__.py

     

       5858
       5858
       +
       │       │   │   ├── init.py      # Initialize git store

     

       5859
       5859
       +
       │       │   │   ├── add.py       # Add users and feeds

     

       5860
       5860
       +
       │       │   │   ├── sync.py      # Sync feeds

     

       5861
       5861
       +
       │       │   │   ├── list_cmd.py  # List users/feeds

     

       5862
       5862
       +
       │       │   │   ├── duplicates.py # Manage duplicate entries

     

       5863
       5863
       +
       │       │   │   ├── links_cmd.py  # Extract and categorize links

     

       5864
       5864
       +
       │       │   │   └── index_cmd.py  # Build reference index and show threads

     

       5865
       5865
       +
       │       │   └── utils.py    # CLI utilities (progress, formatting)

     

       5866
       5866
       +
       │       ├── core/           # Core business logic

     

       5867
       5867
       +
       │       │   ├── __init__.py

     

       5868
       5868
       +
       │       │   ├── feed_parser.py   # Feed parsing and normalization

     

       5869
       5869
       +
       │       │   ├── git_store.py     # Git repository operations

     

       5870
       5870
       +
       │       │   └── reference_parser.py # Link extraction and threading

     

       5871
       5871
       +
       │       ├── models/         # Pydantic data models

     

       5872
       5872
       +
       │       │   ├── __init__.py

     

       5873
       5873
       +
       │       │   ├── config.py        # Configuration models

     

       5874
       5874
       +
       │       │   ├── feed.py          # Feed/Entry models

     

       5875
       5875
       +
       │       │   └── user.py          # User metadata models

     

       5876
       5876
       +
       │       └── utils/          # Shared utilities

     

       5877
       5877
       +
       │           └── __init__.py

     

       5878
       5878
       +
       ├── tests/

     

       5879
       5879
       +
       │   ├── __init__.py

     

       5880
       5880
       +
       │   ├── conftest.py         # pytest configuration

     

       5881
       5881
       +
       │   ├── test_feed_parser.py

     

       5882
       5882
       +
       │   ├── test_git_store.py

     

       5883
       5883
       +
       │   └── fixtures/           # Test data

     

       5884
       5884
       +
       │       └── feeds/

     

       5885
       5885
       +
       └── docs/

     

       5886
       5886
       +
           └── examples/           # Example configurations

     

       5887
       5887
       +
       ```

     

       5888
       5888
       +
       

     

       5889
       5889
       +
       ## Data Models

     

       5890
       5890
       +
       

     

       5891
       5891
       +
       ### Configuration File (YAML/TOML)

     

       5892
       5892
       +
       ```python

     

       5893
       5893
       +
       class ThicketConfig(BaseSettings):

     

       5894
       5894
       +
           git_store: Path  # Git repository location

     

       5895
       5895
       +
           cache_dir: Path  # Cache directory

     

       5896
       5896
       +
           users: list[UserConfig]

     

       5897
       5897
       +
           

     

       5898
       5898
       +
           model_config = SettingsConfigDict(

     

       5899
       5899
       +
               env_prefix="THICKET_",

     

       5900
       5900
       +
               env_file=".env",

     

       5901
       5901
       +
               yaml_file="thicket.yaml"

     

       5902
       5902
       +
           )

     

       5903
       5903
       +
       

     

       5904
       5904
       +
       class UserConfig(BaseModel):

     

       5905
       5905
       +
           username: str

     

       5906
       5906
       +
           feeds: list[HttpUrl]

     

       5907
       5907
       +
           email: Optional[EmailStr] = None

     

       5908
       5908
       +
           homepage: Optional[HttpUrl] = None

     

       5909
       5909
       +
           icon: Optional[HttpUrl] = None

     

       5910
       5910
       +
           display_name: Optional[str] = None

     

       5911
       5911
       +
       ```

     

       5912
       5912
       +
       

     

       5913
       5913
       +
       ### Feed Storage Format

     

       5914
       5914
       +
       ```python

     

       5915
       5915
       +
       class AtomEntry(BaseModel):

     

       5916
       5916
       +
           id: str  # Original Atom ID

     

       5917
       5917
       +
           title: str

     

       5918
       5918
       +
           link: HttpUrl

     

       5919
       5919
       +
           updated: datetime

     

       5920
       5920
       +
           published: Optional[datetime]

     

       5921
       5921
       +
           summary: Optional[str]

     

       5922
       5922
       +
           content: Optional[str]  # Full body content from Atom entry

     

       5923
       5923
       +
           content_type: Optional[str] = "html"  # text, html, xhtml

     

       5924
       5924
       +
           author: Optional[dict]

     

       5925
       5925
       +
           categories: list[str] = []

     

       5926
       5926
       +
           rights: Optional[str] = None  # Copyright info

     

       5927
       5927
       +
           source: Optional[str] = None  # Source feed URL

     

       5928
       5928
       +
           # Additional Atom fields preserved during RSS->Atom conversion

     

       5929
       5929
       +
           

     

       5930
       5930
       +
           model_config = ConfigDict(

     

       5931
       5931
       +
               json_encoders={

     

       5932
       5932
       +
                   datetime: lambda v: v.isoformat()

     

       5933
       5933
       +
               }

     

       5934
       5934
       +
           )

     

       5935
       5935
       +
       

     

       5936
       5936
       +
       class DuplicateMap(BaseModel):

     

       5937
       5937
       +
           """Maps duplicate entry IDs to canonical entry IDs"""

     

       5938
       5938
       +
           duplicates: dict[str, str] = {}  # duplicate_id -> canonical_id

     

       5939
       5939
       +
           comment: str = "Entry IDs that map to the same canonical content"

     

       5940
       5940
       +
           

     

       5941
       5941
       +
           def add_duplicate(self, duplicate_id: str, canonical_id: str) -> None:

     

       5942
       5942
       +
               """Add a duplicate mapping"""

     

       5943
       5943
       +
               self.duplicates[duplicate_id] = canonical_id

     

       5944
       5944
       +
           

     

       5945
       5945
       +
           def remove_duplicate(self, duplicate_id: str) -> bool:

     

       5946
       5946
       +
               """Remove a duplicate mapping. Returns True if existed."""

     

       5947
       5947
       +
               return self.duplicates.pop(duplicate_id, None) is not None

     

       5948
       5948
       +
           

     

       5949
       5949
       +
           def get_canonical(self, entry_id: str) -> str:

     

       5950
       5950
       +
               """Get canonical ID for an entry (returns original if not duplicate)"""

     

       5951
       5951
       +
               return self.duplicates.get(entry_id, entry_id)

     

       5952
       5952
       +
           

     

       5953
       5953
       +
           def is_duplicate(self, entry_id: str) -> bool:

     

       5954
       5954
       +
               """Check if entry ID is marked as duplicate"""

     

       5955
       5955
       +
               return entry_id in self.duplicates

     

       5956
       5956
       +
       ```

     

       5957
       5957
       +
       

     

       5958
       5958
       +
       ## Git Repository Structure

     

       5959
       5959
       +
       ```

     

       5960
       5960
       +
       git-store/

     

       5961
       5961
       +
       ├── index.json              # User directory index

     

       5962
       5962
       +
       ├── duplicates.json         # Manual curation of duplicate entries

     

       5963
       5963
       +
       ├── links.json              # Unified links, references, and mapping data

     

       5964
       5964
       +
       ├── user1/

     

       5965
       5965
       +
       │   ├── entry_id_1.json     # Sanitized entry files

     

       5966
       5966
       +
       │   ├── entry_id_2.json

     

       5967
       5967
       +
       │   └── ...

     

       5968
       5968
       +
       └── user2/

     

       5969
       5969
       +
           └── ...

     

       5970
       5970
       +
       ```

     

       5971
       5971
       +
       

     

       5972
       5972
       +
       ## Key Design Decisions

     

       5973
       5973
       +
       

     

       5974
       5974
       +
       ### 1. Feed Normalization & Auto-Discovery

     

       5975
       5975
       +
       - All RSS feeds converted to Atom format before storage

     

       5976
       5976
       +
       - Preserves maximum metadata during conversion

     

       5977
       5977
       +
       - Sanitizes HTML content to prevent XSS

     

       5978
       5978
       +
       - **Auto-discovery**: Extracts user metadata from feed during `add user` command

     

       5979
       5979
       +
       

     

       5980
       5980
       +
       ### 2. ID Sanitization

     

       5981
       5981
       +
       - Consistent algorithm to convert Atom IDs to safe filenames

     

       5982
       5982
       +
       - Handles edge cases (very long IDs, special characters)

     

       5983
       5983
       +
       - Maintains reversibility where possible

     

       5984
       5984
       +
       

     

       5985
       5985
       +
       ### 3. Git Operations

     

       5986
       5986
       +
       - Uses GitPython for simplicity (no authentication required)

     

       5987
       5987
       +
       - Single main branch for all users and entries

     

       5988
       5988
       +
       - Atomic commits per sync operation

     

       5989
       5989
       +
       - Meaningful commit messages with feed update summaries

     

       5990
       5990
       +
       - Preserves complete history - never delete entries even if they disappear from feeds

     

       5991
       5991
       +
       

     

       5992
       5992
       +
       ### 4. Caching Strategy

     

       5993
       5993
       +
       - HTTP caching with Last-Modified/ETag support

     

       5994
       5994
       +
       - Local cache of parsed feeds with TTL

     

       5995
       5995
       +
       - Cache invalidation on configuration changes

     

       5996
       5996
       +
       - Git store serves as permanent historical archive beyond feed depth limits

     

       5997
       5997
       +
       

     

       5998
       5998
       +
       ### 5. Error Handling

     

       5999
       5999
       +
       - Graceful handling of feed parsing errors

     

       6000
       6000
       +
       - Retry logic for network failures

     

       6001
       6001
       +
       - Clear error messages with recovery suggestions

     

       6002
       6002
       +
       

     

       6003
       6003
       +
       ## CLI Command Structure

     

       6004
       6004
       +
       

     

       6005
       6005
       +
       ```bash

     

       6006
       6006
       +
       # Initialize a new git store

     

       6007
       6007
       +
       thicket init /path/to/store

     

       6008
       6008
       +
       

     

       6009
       6009
       +
       # Add a user with feeds (auto-discovers metadata from feed)

     

       6010
       6010
       +
       thicket add user "alyssa" \

     

       6011
       6011
       +
         --feed "https://example.com/feed.atom"

     

       6012
       6012
       +
         # Auto-populates: email, homepage, icon, display_name from feed metadata

     

       6013
       6013
       +
       

     

       6014
       6014
       +
       # Add a user with manual overrides

     

       6015
       6015
       +
       thicket add user "alyssa" \

     

       6016
       6016
       +
         --feed "https://example.com/feed.atom" \

     

       6017
       6017
       +
         --email "alyssa@example.com" \

     

       6018
       6018
       +
         --homepage "https://alyssa.example.com" \

     

       6019
       6019
       +
         --icon "https://example.com/avatar.png" \

     

       6020
       6020
       +
         --display-name "Alyssa P. Hacker"

     

       6021
       6021
       +
       

     

       6022
       6022
       +
       # Add additional feed to existing user

     

       6023
       6023
       +
       thicket add feed "alyssa" "https://example.com/other-feed.rss"

     

       6024
       6024
       +
       

     

       6025
       6025
       +
       # Sync all feeds (designed for cron usage)

     

       6026
       6026
       +
       thicket sync --all

     

       6027
       6027
       +
       

     

       6028
       6028
       +
       # Sync specific user

     

       6029
       6029
       +
       thicket sync --user alyssa

     

       6030
       6030
       +
       

     

       6031
       6031
       +
       # List users and their feeds

     

       6032
       6032
       +
       thicket list users

     

       6033
       6033
       +
       thicket list feeds --user alyssa

     

       6034
       6034
       +
       

     

       6035
       6035
       +
       # Manage duplicate entries

     

       6036
       6036
       +
       thicket duplicates list

     

       6037
       6037
       +
       thicket duplicates add <entry_id_1> <entry_id_2>  # Mark as duplicates

     

       6038
       6038
       +
       thicket duplicates remove <entry_id_1> <entry_id_2>  # Unmark duplicates

     

       6039
       6039
       +
       

     

       6040
       6040
       +
       # Link processing and threading

     

       6041
       6041
       +
       thicket links --verbose                 # Extract and categorize all links

     

       6042
       6042
       +
       thicket index --verbose                 # Build reference index for threading

     

       6043
       6043
       +
       thicket threads                         # Show conversation threads

     

       6044
       6044
       +
       thicket threads --username user1        # Show threads for specific user

     

       6045
       6045
       +
       thicket threads --min-size 3           # Show threads with minimum size

     

       6046
       6046
       +
       ```

     

       6047
       6047
       +
       

     

       6048
       6048
       +
       ## Performance Considerations

     

       6049
       6049
       +
       

     

       6050
       6050
       +
       1. **Concurrent Feed Fetching**: Use httpx with asyncio for parallel downloads

     

       6051
       6051
       +
       2. **Incremental Updates**: Only fetch/parse feeds that have changed

     

       6052
       6052
       +
       3. **Efficient Git Operations**: Batch commits, use shallow clones where appropriate

     

       6053
       6053
       +
       4. **Progress Feedback**: Rich progress bars for long operations

     

       6054
       6054
       +
       

     

       6055
       6055
       +
       ## Security Considerations

     

       6056
       6056
       +
       

     

       6057
       6057
       +
       1. **HTML Sanitization**: Use bleach to clean feed content

     

       6058
       6058
       +
       2. **URL Validation**: Strict validation of feed URLs

     

       6059
       6059
       +
       3. **Git Security**: No credentials stored in repository

     

       6060
       6060
       +
       4. **Path Traversal**: Careful sanitization of filenames

     

       6061
       6061
       +
       

     

       6062
       6062
       +
       ## Future Enhancements

     

       6063
       6063
       +
       

     

       6064
       6064
       +
       1. **Web Interface**: Optional web UI for browsing the git store

     

       6065
       6065
       +
       2. **Webhooks**: Notify external services on feed updates

     

       6066
       6066
       +
       3. **Feed Discovery**: Auto-discover feeds from HTML pages

     

       6067
       6067
       +
       4. **Export Formats**: Generate static sites, OPML exports

     

       6068
       6068
       +
       5. **Federation**: P2P sync between thicket instances

     

       6069
       6069
       +
       

     

       6070
       6070
       +
       ## Requirements Clarification

     

       6071
       6071
       +
       

     

       6072
       6072
       +
       **✓ Resolved Requirements:**

     

       6073
       6073
       +
       1. **Feed Update Frequency**: Designed for cron usage - no built-in scheduling needed

     

       6074
       6074
       +
       2. **Duplicate Handling**: Manual curation via `duplicates.json` file with CLI commands

     

       6075
       6075
       +
       3. **Git Branching**: Single main branch for all users and entries

     

       6076
       6076
       +
       4. **Authentication**: No feeds require authentication currently

     

       6077
       6077
       +
       5. **Content Storage**: Store complete Atom entry body content as provided

     

       6078
       6078
       +
       6. **Deleted Entries**: Preserve all entries in Git store permanently (historical archive)

     

       6079
       6079
       +
       7. **History Depth**: Git store maintains full history beyond feed depth limits

     

       6080
       6080
       +
       8. **Feed Auto-Discovery**: Extract user metadata from feed during `add user` command

     

       6081
       6081
       +
       

     

       6082
       6082
       +
       ## Duplicate Entry Management

     

       6083
       6083
       +
       

     

       6084
       6084
       +
       ### Duplicate Detection Strategy

     

       6085
       6085
       +
       - **Manual Curation**: Duplicates identified and managed manually via CLI

     

       6086
       6086
       +
       - **Storage**: `duplicates.json` file in Git root maps entry IDs to canonical entries

     

       6087
       6087
       +
       - **Structure**: `{"duplicate_id": "canonical_id", ...}`

     

       6088
       6088
       +
       - **CLI Commands**: Add/remove duplicate mappings with validation

     

       6089
       6089
       +
       - **Query Resolution**: Search/list commands resolve duplicates to canonical entries

     

       6090
       6090
       +
       

     

       6091
       6091
       +
       ### Duplicate File Format

     

       6092
       6092
       +
       ```json

     

       6093
       6093
       +
       {

     

       6094
       6094
       +
         "https://example.com/feed/entry/123": "https://canonical.com/posts/same-post",

     

       6095
       6095
       +
         "https://mirror.com/articles/456": "https://canonical.com/posts/same-post",

     

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

     

       6097
       6097
       +
       }

     

       6098
       6098
       +
       ```

     

       6099
       6099
       +
       

     

       6100
       6100
       +
       ## Feed Metadata Auto-Discovery

     

       6101
       6101
       +
       

     

       6102
       6102
       +
       ### Extraction Strategy

     

       6103
       6103
       +
       When adding a new user with `thicket add user`, the system fetches and parses the feed to extract:

     

       6104
       6104
       +
       

     

       6105
       6105
       +
       - **Display Name**: From `feed.title` or `feed.author.name`

     

       6106
       6106
       +
       - **Email**: From `feed.author.email` or `feed.managingEditor`

     

       6107
       6107
       +
       - **Homepage**: From `feed.link` or `feed.author.uri`

     

       6108
       6108
       +
       - **Icon**: From `feed.logo`, `feed.icon`, or `feed.image.url`

     

       6109
       6109
       +
       

     

       6110
       6110
       +
       ### Discovery Priority Order

     

       6111
       6111
       +
       1. **Author Information**: Prefer `feed.author.*` fields (more specific to person)

     

       6112
       6112
       +
       2. **Feed-Level**: Fall back to feed-level metadata

     

       6113
       6113
       +
       3. **Manual Override**: CLI flags always take precedence over discovered values

     

       6114
       6114
       +
       4. **Update Behavior**: Auto-discovery only runs during initial `add user`, not on sync

     

       6115
       6115
       +
       

     

       6116
       6116
       +
       ### Extracted Metadata Format

     

       6117
       6117
       +
       ```python

     

       6118
       6118
       +
       class FeedMetadata(BaseModel):

     

       6119
       6119
       +
           title: Optional[str] = None

     

       6120
       6120
       +
           author_name: Optional[str] = None

     

       6121
       6121
       +
           author_email: Optional[EmailStr] = None

     

       6122
       6122
       +
           author_uri: Optional[HttpUrl] = None

     

       6123
       6123
       +
           link: Optional[HttpUrl] = None

     

       6124
       6124
       +
           logo: Optional[HttpUrl] = None

     

       6125
       6125
       +
           icon: Optional[HttpUrl] = None

     

       6126
       6126
       +
           image_url: Optional[HttpUrl] = None

     

       6127
       6127
       +
           

     

       6128
       6128
       +
           def to_user_config(self, username: str, feed_url: HttpUrl) -> UserConfig:

     

       6129
       6129
       +
               """Convert discovered metadata to UserConfig with fallbacks"""

     

       6130
       6130
       +
               return UserConfig(

     

       6131
       6131
       +
                   username=username,

     

       6132
       6132
       +
                   feeds=[feed_url],

     

       6133
       6133
       +
                   display_name=self.author_name or self.title,

     

       6134
       6134
       +
                   email=self.author_email,

     

       6135
       6135
       +
                   homepage=self.author_uri or self.link,

     

       6136
       6136
       +
                   icon=self.logo or self.icon or self.image_url

     

       6137
       6137
       +
               )

     

       6138
       6138
       +
       ```

     

       6139
       6139
       +
       

     

       6140
       6140
       +
       ## Link Processing and Threading Architecture

     

       6141
       6141
       +
       

     

       6142
       6142
       +
       ### Overview

     

       6143
       6143
       +
       The thicket system implements a sophisticated link processing and threading system to create email-style threaded views of blog entries by tracking cross-references between different blogs.

     

       6144
       6144
       +
       

     

       6145
       6145
       +
       ### Link Processing Pipeline

     

       6146
       6146
       +
       

     

       6147
       6147
       +
       #### 1. Link Extraction (`thicket links`)

     

       6148
       6148
       +
       The `links` command systematically extracts all outbound links from blog entries and categorizes them:

     

       6149
       6149
       +
       

     

       6150
       6150
       +
       ```python

     

       6151
       6151
       +
       class LinkData(BaseModel):

     

       6152
       6152
       +
           url: str                    # Fully resolved URL

     

       6153
       6153
       +
           entry_id: str              # Source entry ID

     

       6154
       6154
       +
           username: str              # Source username

     

       6155
       6155
       +
           context: str               # Surrounding text context

     

       6156
       6156
       +
           category: str              # "internal", "user", or "unknown"

     

       6157
       6157
       +
           target_username: Optional[str]  # Target user if applicable

     

       6158
       6158
       +
       ```

     

       6159
       6159
       +
       

     

       6160
       6160
       +
       **Link Categories:**

     

       6161
       6161
       +
       - **Internal**: Links to the same user's domain (self-references)

     

       6162
       6162
       +
       - **User**: Links to other tracked users' domains

     

       6163
       6163
       +
       - **Unknown**: Links to external sites not tracked by thicket

     

       6164
       6164
       +
       

     

       6165
       6165
       +
       #### 2. URL Resolution

     

       6166
       6166
       +
       All links are properly resolved using the Atom feed's base URL to handle:

     

       6167
       6167
       +
       - Relative URLs (converted to absolute)

     

       6168
       6168
       +
       - Protocol-relative URLs

     

       6169
       6169
       +
       - Fragment identifiers

     

       6170
       6170
       +
       - Redirects and canonical URLs

     

       6171
       6171
       +
       

     

       6172
       6172
       +
       #### 3. Domain Mapping

     

       6173
       6173
       +
       The system builds a comprehensive domain mapping from user configuration:

     

       6174
       6174
       +
       - Feed URLs → domain extraction

     

       6175
       6175
       +
       - Homepage URLs → domain extraction

     

       6176
       6176
       +
       - Reverse mapping: domain → username

     

       6177
       6177
       +
       

     

       6178
       6178
       +
       ### Threading System

     

       6179
       6179
       +
       

     

       6180
       6180
       +
       #### 1. Reference Index Generation (`thicket index`)

     

       6181
       6181
       +
       Creates a bidirectional reference index from the categorized links:

     

       6182
       6182
       +
       

     

       6183
       6183
       +
       ```python

     

       6184
       6184
       +
       class BlogReference(BaseModel):

     

       6185
       6185
       +
           source_entry_id: str

     

       6186
       6186
       +
           source_username: str

     

       6187
       6187
       +
           target_url: str

     

       6188
       6188
       +
           target_username: Optional[str]

     

       6189
       6189
       +
           target_entry_id: Optional[str]

     

       6190
       6190
       +
           context: str

     

       6191
       6191
       +
       ```

     

       6192
       6192
       +
       

     

       6193
       6193
       +
       #### 2. Thread Detection Algorithm

     

       6194
       6194
       +
       Uses graph traversal to find connected blog entries:

     

       6195
       6195
       +
       - **Outbound references**: Links from an entry to other entries

     

       6196
       6196
       +
       - **Inbound references**: Links to an entry from other entries

     

       6197
       6197
       +
       - **Thread members**: All entries connected through references

     

       6198
       6198
       +
       

     

       6199
       6199
       +
       #### 3. Threading Display (`thicket threads`)

     

       6200
       6200
       +
       Creates email-style threaded views:

     

       6201
       6201
       +
       - Chronological ordering within threads

     

       6202
       6202
       +
       - Reference counts (outbound/inbound)

     

       6203
       6203
       +
       - Context preservation

     

       6204
       6204
       +
       - Filtering options (user, entry, minimum size)

     

       6205
       6205
       +
       

     

       6206
       6206
       +
       ### Data Structures

     

       6207
       6207
       +
       

     

       6208
       6208
       +
       #### links.json Format (Unified Structure)

     

       6209
       6209
       +
       ```json

     

       6210
       6210
       +
       {

     

       6211
       6211
       +
         "links": {

     

       6212
       6212
       +
           "https://example.com/post/123": {

     

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

     

       6214
       6214
       +
             "target_username": "user2"

     

       6215
       6215
       +
           },

     

       6216
       6216
       +
           "https://external-site.com/article": {

     

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

     

       6218
       6218
       +
           }

     

       6219
       6219
       +
         },

     

       6220
       6220
       +
         "reverse_mapping": {

     

       6221
       6221
       +
           "https://blog.user.com/entry/456": ["https://example.com/post/123"],

     

       6222
       6222
       +
           "https://blog.user.com/entry/789": ["https://external-site.com/article"]

     

       6223
       6223
       +
         },

     

       6224
       6224
       +
         "references": [

     

       6225
       6225
       +
           {

     

       6226
       6226
       +
             "source_entry_id": "https://blog.user.com/entry/456",

     

       6227
       6227
       +
             "source_username": "user1",

     

       6228
       6228
       +
             "target_url": "https://example.com/post/123",

     

       6229
       6229
       +
             "target_username": "user2",

     

       6230
       6230
       +
             "target_entry_id": "https://example.com/post/123",

     

       6231
       6231
       +
             "context": "As mentioned in this post..."

     

       6232
       6232
       +
           }

     

       6233
       6233
       +
         ],

     

       6234
       6234
       +
         "user_domains": {

     

       6235
       6235
       +
           "user1": ["blog.user.com"],

     

       6236
       6236
       +
           "user2": ["example.com"]

     

       6237
       6237
       +
         }

     

       6238
       6238
       +
       }

     

       6239
       6239
       +
       ```

     

       6240
       6240
       +
       

     

       6241
       6241
       +
       This unified structure eliminates duplication by:

     

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

     

       6243
       6243
       +
       - Including all link data, reference data, and mappings in one file

     

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

     

       6245
       6245
       +
       - Providing bidirectional mappings for efficient queries

     

       6246
       6246
       +
       

     

       6247
       6247
       +
       ### Unified Structure Benefits

     

       6248
       6248
       +
       

     

       6249
       6249
       +
       - **Eliminates Duplication**: Each URL appears only once with metadata

     

       6250
       6250
       +
       - **Single Source of Truth**: All link-related data in one file

     

       6251
       6251
       +
       - **Efficient Queries**: Fast lookups for both directions (URL→entries, entry→URLs)

     

       6252
       6252
       +
       - **Atomic Updates**: All link data changes together

     

       6253
       6253
       +
       - **Reduced I/O**: Fewer file operations

     

       6254
       6254
       +
       

     

       6255
       6255
       +
       ### Implementation Benefits

     

       6256
       6256
       +
       

     

       6257
       6257
       +
       1. **Systematic Link Processing**: All links are extracted and categorized consistently

     

       6258
       6258
       +
       2. **Proper URL Resolution**: Handles relative URLs and base URL resolution correctly

     

       6259
       6259
       +
       3. **Domain-based Categorization**: Automatically identifies user-to-user references

     

       6260
       6260
       +
       4. **Bidirectional Indexing**: Supports both "who links to whom" and "who is linked by whom"

     

       6261
       6261
       +
       5. **Thread Discovery**: Finds conversation threads automatically

     

       6262
       6262
       +
       6. **Rich Context**: Preserves surrounding text for each link

     

       6263
       6263
       +
       7. **Performance**: Pre-computed indexes for fast threading queries

     

       6264
       6264
       +
       

     

       6265
       6265
       +
       ### CLI Commands

     

       6266
       6266
       +
       

     

       6267
       6267
       +
       ```bash

     

       6268
       6268
       +
       # Extract and categorize all links

     

       6269
       6269
       +
       thicket links --verbose

     

       6270
       6270
       +
       

     

       6271
       6271
       +
       # Build reference index for threading

     

       6272
       6272
       +
       thicket index --verbose

     

       6273
       6273
       +
       

     

       6274
       6274
       +
       # Show all conversation threads

     

       6275
       6275
       +
       thicket threads

     

       6276
       6276
       +
       

     

       6277
       6277
       +
       # Show threads for specific user

     

       6278
       6278
       +
       thicket threads --username user1

     

       6279
       6279
       +
       

     

       6280
       6280
       +
       # Show threads with minimum size

     

       6281
       6281
       +
       thicket threads --min-size 3

     

       6282
       6282
       +
       ```

     

       6283
       6283
       +
       

     

       6284
       6284
       +
       ### Integration with Existing Commands

     

       6285
       6285
       +
       

     

       6286
       6286
       +
       The link processing system integrates seamlessly with existing thicket commands:

     

       6287
       6287
       +
       - `thicket sync` updates entries, requiring `thicket links` to be run afterward

     

       6288
       6288
       +
       - `thicket index` uses the output from `thicket links` for improved accuracy

     

       6289
       6289
       +
       - `thicket threads` provides the user-facing threading interface

     

       6290
       6290
       +
       

     

       6291
       6291
       +
       ## Current Implementation Status

     

       6292
       6292
       +
       

     

       6293
       6293
       +
       ### ✅ Completed Features

     

       6294
       6294
       +
       1. **Core Infrastructure**

     

       6295
       6295
       +
          - Modern CLI with Typer and Rich

     

       6296
       6296
       +
          - Pydantic data models for type safety

     

       6297
       6297
       +
          - Git repository operations with GitPython

     

       6298
       6298
       +
          - Feed parsing and normalization with feedparser

     

       6299
       6299
       +
       

     

       6300
       6300
       +
       2. **User and Feed Management**

     

       6301
       6301
       +
          - `thicket init` - Initialize git store

     

       6302
       6302
       +
          - `thicket add` - Add users and feeds with auto-discovery

     

       6303
       6303
       +
          - `thicket sync` - Sync feeds with progress tracking

     

       6304
       6304
       +
          - `thicket list` - List users, feeds, and entries

     

       6305
       6305
       +
          - `thicket duplicates` - Manage duplicate entries

     

       6306
       6306
       +
       

     

       6307
       6307
       +
       3. **Link Processing and Threading**

     

       6308
       6308
       +
          - `thicket links` - Extract and categorize all outbound links

     

       6309
       6309
       +
          - `thicket index` - Build reference index from links

     

       6310
       6310
       +
          - `thicket threads` - Display threaded conversation views

     

       6311
       6311
       +
          - Proper URL resolution with base URL handling

     

       6312
       6312
       +
          - Domain-based link categorization

     

       6313
       6313
       +
          - Context preservation for links

     

       6314
       6314
       +
       

     

       6315
       6315
       +
       ### 📊 System Performance

     

       6316
       6316
       +
       - **Link Extraction**: Successfully processes thousands of blog entries

     

       6317
       6317
       +
       - **Categorization**: Identifies internal, user, and unknown links

     

       6318
       6318
       +
       - **Threading**: Creates email-style threaded views of conversations

     

       6319
       6319
       +
       - **Storage**: Efficient JSON-based data structures for links and references

     

       6320
       6320
       +
       

     

       6321
       6321
       +
       ### 🔧 Current Architecture Highlights

     

       6322
       6322
       +
       - **Modular Design**: Clear separation between CLI, core logic, and models

     

       6323
       6323
       +
       - **Type Safety**: Comprehensive Pydantic models for data validation

     

       6324
       6324
       +
       - **Rich CLI**: Beautiful progress bars, tables, and error handling

     

       6325
       6325
       +
       - **Extensible**: Easy to add new commands and features

     

       6326
       6326
       +
       - **Git Integration**: All data stored in version-controlled JSON files

     

       6327
       6327
       +
       

     

       6328
       6328
       +
       ### 🎯 Proven Functionality

     

       6329
       6329
       +
       The system has been tested with real blog data and successfully:

     

       6330
       6330
       +
       - Extracted 14,396 total links from blog entries

     

       6331
       6331
       +
       - Categorized 3,994 internal links, 363 user-to-user links, and 10,039 unknown links

     

       6332
       6332
       +
       - Built comprehensive domain mappings for 16 users across 20 domains

     

       6333
       6333
       +
       - Generated threaded views showing blog conversation patterns

     

       6334
       6334
       +
       

     

       6335
       6335
       +
       ### 🚀 Ready for Use

     

       6336
       6336
       +
       The thicket system is now fully functional for:

     

       6337
       6337
       +
       - Maintaining Git repositories of blog feeds

     

       6338
       6338
       +
       - Tracking cross-references between blogs

     

       6339
       6339
       +
       - Creating threaded views of blog conversations

     

       6340
       6340
       +
       - Discovering blog interaction patterns

     

       6341
       6341
       +
       - Building distributed comment systems

     

       6342
       6342
       +
       </file>

     

       6343
       6343
       +
       

     

       6344
       6344
       +
       <file path="src/thicket/cli/utils.py">

     

       6345
       6345
       +
       """CLI utilities and helpers."""

     

       6346
       6346
       +
       

     

       6347
       6347
       +
       from pathlib import Path

     

       6348
       6348
       +
       from typing import Optional

     

       6349
       6349
       +
       

     

       6350
       6350
       +
       import typer

     

       6351
       6351
       +
       from rich.console import Console

     

       6352
       6352
       +
       from rich.progress import Progress, SpinnerColumn, TextColumn

     

       6353
       6353
       +
       from rich.table import Table

     

       6354
       6354
       +
       

     

       6355
       6355
       +
       from ..models import ThicketConfig, UserMetadata

     

       6356
       6356
       +
       from ..core.git_store import GitStore

     

       6357
       6357
       +
       

     

       6358
       6358
       +
       console = Console()

     

       6359
       6359
       +
       

     

       6360
       6360
       +
       

     

       6361
       6361
       +
       def get_tsv_mode() -> bool:

     

       6362
       6362
       +
           """Get the global TSV mode setting."""

     

       6363
       6363
       +
           from .main import tsv_mode

     

       6364
       6364
       +
           return tsv_mode

     

       6365
       6365
       +
       

     

       6366
       6366
       +
       

     

       6367
       6367
       +
       def load_config(config_path: Optional[Path] = None) -> ThicketConfig:

     

       6368
       6368
       +
           """Load thicket configuration from file or environment."""

     

       6369
       6369
       +
           if config_path and config_path.exists():

     

       6370
       6370
       +
               import yaml

     

       6371
       6371
       +
       

     

       6372
       6372
       +
               with open(config_path) as f:

     

       6373
       6373
       +
                   config_data = yaml.safe_load(f)

     

       6374
       6374
       +
       

     

       6375
       6375
       +
               # Convert to ThicketConfig

     

       6376
       6376
       +
               return ThicketConfig(**config_data)

     

       6377
       6377
       +
       

     

       6378
       6378
       +
           # Try to load from default locations or environment

     

       6379
       6379
       +
           try:

     

       6380
       6380
       +
               # First try to find thicket.yaml in current directory

     

       6381
       6381
       +
               default_config = Path("thicket.yaml")

     

       6382
       6382
       +
               if default_config.exists():

     

       6383
       6383
       +
                   import yaml

     

       6384
       6384
       +
                   with open(default_config) as f:

     

       6385
       6385
       +
                       config_data = yaml.safe_load(f)

     

       6386
       6386
       +
                   return ThicketConfig(**config_data)

     

       6387
       6387
       +
               

     

       6388
       6388
       +
               # Fall back to environment variables

     

       6389
       6389
       +
               return ThicketConfig()

     

       6390
       6390
       +
           except Exception as e:

     

       6391
       6391
       +
               console.print(f"[red]Error loading configuration: {e}[/red]")

     

       6392
       6392
       +
               console.print("[yellow]Run 'thicket init' to create a new configuration.[/yellow]")

     

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

     

       6394
       6394
       +
       

     

       6395
       6395
       +
       

     

       6396
       6396
       +
       def save_config(config: ThicketConfig, config_path: Path) -> None:

     

       6397
       6397
       +
           """Save thicket configuration to file."""

     

       6398
       6398
       +
           import yaml

     

       6399
       6399
       +
       

     

       6400
       6400
       +
           config_data = config.model_dump(mode="json", exclude_none=True)

     

       6401
       6401
       +
       

     

       6402
       6402
       +
           # Convert Path objects to strings for YAML serialization

     

       6403
       6403
       +
           config_data["git_store"] = str(config_data["git_store"])

     

       6404
       6404
       +
           config_data["cache_dir"] = str(config_data["cache_dir"])

     

       6405
       6405
       +
       

     

       6406
       6406
       +
           with open(config_path, "w") as f:

     

       6407
       6407
       +
               yaml.dump(config_data, f, default_flow_style=False, sort_keys=False)

     

       6408
       6408
       +
       

     

       6409
       6409
       +
       

     

       6410
       6410
       +
       def create_progress() -> Progress:

     

       6411
       6411
       +
           """Create a Rich progress display."""

     

       6412
       6412
       +
           return Progress(

     

       6413
       6413
       +
               SpinnerColumn(),

     

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

     

       6415
       6415
       +
               console=console,

     

       6416
       6416
       +
               transient=True,

     

       6417
       6417
       +
           )

     

       6418
       6418
       +
       

     

       6419
       6419
       +
       

     

       6420
       6420
       +
       def print_users_table(config: ThicketConfig) -> None:

     

       6421
       6421
       +
           """Print a table of users and their feeds."""

     

       6422
       6422
       +
           if get_tsv_mode():

     

       6423
       6423
       +
               print_users_tsv(config)

     

       6424
       6424
       +
               return

     

       6425
       6425
       +
               

     

       6426
       6426
       +
           table = Table(title="Users and Feeds")

     

       6427
       6427
       +
           table.add_column("Username", style="cyan", no_wrap=True)

     

       6428
       6428
       +
           table.add_column("Display Name", style="magenta")

     

       6429
       6429
       +
           table.add_column("Email", style="blue")

     

       6430
       6430
       +
           table.add_column("Homepage", style="green")

     

       6431
       6431
       +
           table.add_column("Feeds", style="yellow")

     

       6432
       6432
       +
       

     

       6433
       6433
       +
           for user in config.users:

     

       6434
       6434
       +
               feeds_str = "\n".join(str(feed) for feed in user.feeds)

     

       6435
       6435
       +
               table.add_row(

     

       6436
       6436
       +
                   user.username,

     

       6437
       6437
       +
                   user.display_name or "",

     

       6438
       6438
       +
                   user.email or "",

     

       6439
       6439
       +
                   str(user.homepage) if user.homepage else "",

     

       6440
       6440
       +
                   feeds_str,

     

       6441
       6441
       +
               )

     

       6442
       6442
       +
       

     

       6443
       6443
       +
           console.print(table)

     

       6444
       6444
       +
       

     

       6445
       6445
       +
       

     

       6446
       6446
       +
       def print_feeds_table(config: ThicketConfig, username: Optional[str] = None) -> None:

     

       6447
       6447
       +
           """Print a table of feeds, optionally filtered by username."""

     

       6448
       6448
       +
           if get_tsv_mode():

     

       6449
       6449
       +
               print_feeds_tsv(config, username)

     

       6450
       6450
       +
               return

     

       6451
       6451
       +
               

     

       6452
       6452
       +
           table = Table(title=f"Feeds{f' for {username}' if username else ''}")

     

       6453
       6453
       +
           table.add_column("Username", style="cyan", no_wrap=True)

     

       6454
       6454
       +
           table.add_column("Feed URL", style="blue")

     

       6455
       6455
       +
           table.add_column("Status", style="green")

     

       6456
       6456
       +
       

     

       6457
       6457
       +
           users = [config.find_user(username)] if username else config.users

     

       6458
       6458
       +
           users = [u for u in users if u is not None]

     

       6459
       6459
       +
       

     

       6460
       6460
       +
           for user in users:

     

       6461
       6461
       +
               for feed in user.feeds:

     

       6462
       6462
       +
                   table.add_row(

     

       6463
       6463
       +
                       user.username,

     

       6464
       6464
       +
                       str(feed),

     

       6465
       6465
       +
                       "Active",  # TODO: Add actual status checking

     

       6466
       6466
       +
                   )

     

       6467
       6467
       +
       

     

       6468
       6468
       +
           console.print(table)

     

       6469
       6469
       +
       

     

       6470
       6470
       +
       

     

       6471
       6471
       +
       def confirm_action(message: str, default: bool = False) -> bool:

     

       6472
       6472
       +
           """Prompt for confirmation."""

     

       6473
       6473
       +
           return typer.confirm(message, default=default)

     

       6474
       6474
       +
       

     

       6475
       6475
       +
       

     

       6476
       6476
       +
       def print_success(message: str) -> None:

     

       6477
       6477
       +
           """Print a success message."""

     

       6478
       6478
       +
           console.print(f"[green]✓[/green] {message}")

     

       6479
       6479
       +
       

     

       6480
       6480
       +
       

     

       6481
       6481
       +
       def print_error(message: str) -> None:

     

       6482
       6482
       +
           """Print an error message."""

     

       6483
       6483
       +
           console.print(f"[red]✗[/red] {message}")

     

       6484
       6484
       +
       

     

       6485
       6485
       +
       

     

       6486
       6486
       +
       def print_warning(message: str) -> None:

     

       6487
       6487
       +
           """Print a warning message."""

     

       6488
       6488
       +
           console.print(f"[yellow]⚠[/yellow] {message}")

     

       6489
       6489
       +
       

     

       6490
       6490
       +
       

     

       6491
       6491
       +
       def print_info(message: str) -> None:

     

       6492
       6492
       +
           """Print an info message."""

     

       6493
       6493
       +
           console.print(f"[blue]ℹ[/blue] {message}")

     

       6494
       6494
       +
       

     

       6495
       6495
       +
       

     

       6496
       6496
       +
       def print_users_table_from_git(users: list[UserMetadata]) -> None:

     

       6497
       6497
       +
           """Print a table of users from git repository."""

     

       6498
       6498
       +
           if get_tsv_mode():

     

       6499
       6499
       +
               print_users_tsv_from_git(users)

     

       6500
       6500
       +
               return

     

       6501
       6501
       +
               

     

       6502
       6502
       +
           table = Table(title="Users and Feeds")

     

       6503
       6503
       +
           table.add_column("Username", style="cyan", no_wrap=True)

     

       6504
       6504
       +
           table.add_column("Display Name", style="magenta")

     

       6505
       6505
       +
           table.add_column("Email", style="blue")

     

       6506
       6506
       +
           table.add_column("Homepage", style="green")

     

       6507
       6507
       +
           table.add_column("Feeds", style="yellow")

     

       6508
       6508
       +
       

     

       6509
       6509
       +
           for user in users:

     

       6510
       6510
       +
               feeds_str = "\n".join(user.feeds)

     

       6511
       6511
       +
               table.add_row(

     

       6512
       6512
       +
                   user.username,

     

       6513
       6513
       +
                   user.display_name or "",

     

       6514
       6514
       +
                   user.email or "",

     

       6515
       6515
       +
                   user.homepage or "",

     

       6516
       6516
       +
                   feeds_str,

     

       6517
       6517
       +
               )

     

       6518
       6518
       +
       

     

       6519
       6519
       +
           console.print(table)

     

       6520
       6520
       +
       

     

       6521
       6521
       +
       

     

       6522
       6522
       +
       def print_feeds_table_from_git(git_store: GitStore, username: Optional[str] = None) -> None:

     

       6523
       6523
       +
           """Print a table of feeds from git repository."""

     

       6524
       6524
       +
           if get_tsv_mode():

     

       6525
       6525
       +
               print_feeds_tsv_from_git(git_store, username)

     

       6526
       6526
       +
               return

     

       6527
       6527
       +
               

     

       6528
       6528
       +
           table = Table(title=f"Feeds{f' for {username}' if username else ''}")

     

       6529
       6529
       +
           table.add_column("Username", style="cyan", no_wrap=True)

     

       6530
       6530
       +
           table.add_column("Feed URL", style="blue")

     

       6531
       6531
       +
           table.add_column("Status", style="green")

     

       6532
       6532
       +
       

     

       6533
       6533
       +
           if username:

     

       6534
       6534
       +
               user = git_store.get_user(username)

     

       6535
       6535
       +
               users = [user] if user else []

     

       6536
       6536
       +
           else:

     

       6537
       6537
       +
               index = git_store._load_index()

     

       6538
       6538
       +
               users = list(index.users.values())

     

       6539
       6539
       +
       

     

       6540
       6540
       +
           for user in users:

     

       6541
       6541
       +
               for feed in user.feeds:

     

       6542
       6542
       +
                   table.add_row(

     

       6543
       6543
       +
                       user.username,

     

       6544
       6544
       +
                       feed,

     

       6545
       6545
       +
                       "Active",  # TODO: Add actual status checking

     

       6546
       6546
       +
                   )

     

       6547
       6547
       +
       

     

       6548
       6548
       +
           console.print(table)

     

       6549
       6549
       +
       

     

       6550
       6550
       +
       

     

       6551
       6551
       +
       def print_users_tsv(config: ThicketConfig) -> None:

     

       6552
       6552
       +
           """Print users in TSV format."""

     

       6553
       6553
       +
           print("Username\tDisplay Name\tEmail\tHomepage\tFeeds")

     

       6554
       6554
       +
           for user in config.users:

     

       6555
       6555
       +
               feeds_str = ",".join(str(feed) for feed in user.feeds)

     

       6556
       6556
       +
               print(f"{user.username}\t{user.display_name or ''}\t{user.email or ''}\t{user.homepage or ''}\t{feeds_str}")

     

       6557
       6557
       +
       

     

       6558
       6558
       +
       

     

       6559
       6559
       +
       def print_users_tsv_from_git(users: list[UserMetadata]) -> None:

     

       6560
       6560
       +
           """Print users from git repository in TSV format."""

     

       6561
       6561
       +
           print("Username\tDisplay Name\tEmail\tHomepage\tFeeds")

     

       6562
       6562
       +
           for user in users:

     

       6563
       6563
       +
               feeds_str = ",".join(user.feeds)

     

       6564
       6564
       +
               print(f"{user.username}\t{user.display_name or ''}\t{user.email or ''}\t{user.homepage or ''}\t{feeds_str}")

     

       6565
       6565
       +
       

     

       6566
       6566
       +
       

     

       6567
       6567
       +
       def print_feeds_tsv(config: ThicketConfig, username: Optional[str] = None) -> None:

     

       6568
       6568
       +
           """Print feeds in TSV format."""

     

       6569
       6569
       +
           print("Username\tFeed URL\tStatus")

     

       6570
       6570
       +
           users = [config.find_user(username)] if username else config.users

     

       6571
       6571
       +
           users = [u for u in users if u is not None]

     

       6572
       6572
       +
           

     

       6573
       6573
       +
           for user in users:

     

       6574
       6574
       +
               for feed in user.feeds:

     

       6575
       6575
       +
                   print(f"{user.username}\t{feed}\tActive")

     

       6576
       6576
       +
       

     

       6577
       6577
       +
       

     

       6578
       6578
       +
       def print_feeds_tsv_from_git(git_store: GitStore, username: Optional[str] = None) -> None:

     

       6579
       6579
       +
           """Print feeds from git repository in TSV format."""

     

       6580
       6580
       +
           print("Username\tFeed URL\tStatus")

     

       6581
       6581
       +
           

     

       6582
       6582
       +
           if username:

     

       6583
       6583
       +
               user = git_store.get_user(username)

     

       6584
       6584
       +
               users = [user] if user else []

     

       6585
       6585
       +
           else:

     

       6586
       6586
       +
               index = git_store._load_index()

     

       6587
       6587
       +
               users = list(index.users.values())

     

       6588
       6588
       +
           

     

       6589
       6589
       +
           for user in users:

     

       6590
       6590
       +
               for feed in user.feeds:

     

       6591
       6591
       +
                   print(f"{user.username}\t{feed}\tActive")

     

       6592
       6592
       +
       

     

       6593
       6593
       +
       

     

       6594
       6594
       +
       def print_entries_tsv(entries_by_user: list[list], usernames: list[str]) -> None:

     

       6595
       6595
       +
           """Print entries in TSV format."""

     

       6596
       6596
       +
           print("User\tAtom ID\tTitle\tUpdated\tURL")

     

       6597
       6597
       +
           

     

       6598
       6598
       +
           # Combine all entries with usernames

     

       6599
       6599
       +
           all_entries = []

     

       6600
       6600
       +
           for entries, username in zip(entries_by_user, usernames):

     

       6601
       6601
       +
               for entry in entries:

     

       6602
       6602
       +
                   all_entries.append((username, entry))

     

       6603
       6603
       +
           

     

       6604
       6604
       +
           # Sort by updated time (newest first)

     

       6605
       6605
       +
           all_entries.sort(key=lambda x: x[1].updated, reverse=True)

     

       6606
       6606
       +
           

     

       6607
       6607
       +
           for username, entry in all_entries:

     

       6608
       6608
       +
               # Format updated time

     

       6609
       6609
       +
               updated_str = entry.updated.strftime("%Y-%m-%d %H:%M")

     

       6610
       6610
       +
               

     

       6611
       6611
       +
               # Escape tabs and newlines in title to preserve TSV format

     

       6612
       6612
       +
               title = entry.title.replace('\t', ' ').replace('\n', ' ').replace('\r', ' ')

     

       6613
       6613
       +
               

     

       6614
       6614
       +
               print(f"{username}\t{entry.id}\t{title}\t{updated_str}\t{entry.link}")

     

       6615
       6615
       +
       </file>

     

       6616
       6616
       +
       

     

       6617
       6617
       +
       </files>

+6 -2

src/thicket/__init__.py

···

       1
       1
       -
       """Thicket: A CLI tool for persisting Atom/RSS feeds in Git repositories."""

     

       1
       1
       +
       """Thicket - A library for managing feed repositories and static site generation."""

     

       2
       2
        
       

     

       3
       3
       +
       from .thicket import Thicket

     

       4
       4
       +
       from .models import AtomEntry, UserConfig, ThicketConfig

     

       5
       5
       +
       

     

       6
       6
       +
       __all__ = ["Thicket", "AtomEntry", "UserConfig", "ThicketConfig"]

     

       3
       7
        
       __version__ = "0.1.0"

     

       4
       8
        
       __author__ = "thicket"

     

       5
       5
       -
       __email__ = "thicket@example.com"
     

       9
       9
       +
       __email__ = "thicket@example.com"

+1 -1

src/thicket/__main__.py

···

       3
       3
        
       from .cli.main import app

     

       4
       4
        
       

     

       5
       5
        
       if __name__ == "__main__":

     

       6
       6
       -
           app()
     

       6
       6
       +
           app()

+1 -1

src/thicket/cli/__init__.py

···

       2
       2
        
       

     

       3
       3
        
       from .main import app

     

       4
       4
        
       

     

       5
       5
       -
       __all__ = ["app"]
     

       5
       5
       +
       __all__ = ["app"]

+2 -2

src/thicket/cli/commands/__init__.py

···

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

     

       2
       2
        
       

     

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

     

       4
       4
       -
       from . import add, duplicates, init, list_cmd, sync

     

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

     

       5
       5
        
       

     

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

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

+41 -168

src/thicket/cli/commands/add.py

···

       1
       1
        
       """Add command for thicket."""

     

       2
       2
        
       

     

       3
       3
       -
       import asyncio

     

       4
       3
        
       from pathlib import Path

     

       5
       4
        
       from typing import Optional

     

       6
       5
        
       

     

       7
       6
        
       import typer

     

       8
       8
       -
       from pydantic import HttpUrl, ValidationError

     

       7
       7
       +
       from pydantic import ValidationError

     

       9
       8
        
       

     

       10
       10
       -
       from ...core.feed_parser import FeedParser

     

       11
       11
       -
       from ...core.git_store import GitStore

     

       12
       12
       -
       from ...models import UserConfig

     

       13
       13
       -
       from ..main import app

     

       14
       14
       -
       from ..utils import (

     

       15
       15
       -
           create_progress,

     

       16
       16
       -
           load_config,

     

       17
       17
       -
           print_error,

     

       18
       18
       -
           print_info,

     

       19
       19
       -
           print_success,

     

       20
       20
       -
           save_config,

     

       21
       21
       -
       )

     

       9
       9
       +
       from ..main import app, console, load_thicket

     

       22
       10
        
       

     

       23
       11
        
       

     

       24
       12
        
       @app.command("add")

     

       25
       25
       -
       def add_command(

     

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

     

       13
       13
       +
       def add_user(

     

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

     

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

     

       15
       15
       +
           feeds: list[str] = typer.Argument(..., help="Feed URLs"),

     

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

     

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

     

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

     

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

     

       33
       20
        
           config_file: Optional[Path] = typer.Option(

     

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

     

       35
       35
       -
           ),

     

       36
       36
       -
           auto_discover: bool = typer.Option(

     

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

     

       21
       21
       +
               None, "--config", help="Configuration file path"

     

       38
       22
        
           ),

     

       39
       23
        
       ) -> None:

     

       40
       40
       -
           """Add a user or feed to thicket."""

     

       24
       24
       +
           """Add a user with their feeds to thicket."""

     

       41
       25
        
           

     

       42
       42
       -
           if subcommand == "user":

     

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

     

       44
       44
       -
           elif subcommand == "feed":

     

       45
       45
       -
               add_feed(username, feed_url, config_file)

     

       46
       46
       -
           else:

     

       47
       47
       -
               print_error(f"Unknown subcommand: {subcommand}")

     

       48
       48
       -
               print_error("Use 'user' or 'feed'")

     

       49
       49
       -
               raise typer.Exit(1)

     

       50
       50
       -
       

     

       51
       51
       -
       

     

       52
       52
       -
       def add_user(

     

       53
       53
       -
           username: str,

     

       54
       54
       -
           feed_url: Optional[str],

     

       55
       55
       -
           email: Optional[str],

     

       56
       56
       -
           homepage: Optional[str],

     

       57
       57
       -
           icon: Optional[str],

     

       58
       58
       -
           display_name: Optional[str],

     

       59
       59
       -
           config_file: Path,

     

       60
       60
       -
           auto_discover: bool,

     

       61
       61
       -
       ) -> None:

     

       62
       62
       -
           """Add a new user with feed."""

     

       63
       63
       -
           

     

       64
       64
       -
           if not feed_url:

     

       65
       65
       -
               print_error("Feed URL is required when adding a user")

     

       66
       66
       -
               raise typer.Exit(1)

     

       67
       67
       -
           

     

       68
       68
       -
           # Validate feed URL

     

       69
       26
        
           try:

     

       70
       70
       -
               validated_feed_url = HttpUrl(feed_url)

     

       71
       71
       -
           except ValidationError:

     

       72
       72
       -
               print_error(f"Invalid feed URL: {feed_url}")

     

       73
       73
       -
               raise typer.Exit(1)

     

       74
       74
       -
           

     

       75
       75
       -
           # Load configuration

     

       76
       76
       -
           config = load_config(config_file)

     

       77
       77
       -
           

     

       78
       78
       -
           # Check if user already exists

     

       79
       79
       -
           existing_user = config.find_user(username)

     

       80
       80
       -
           if existing_user:

     

       81
       81
       -
               print_error(f"User '{username}' already exists")

     

       82
       82
       -
               print_error("Use 'thicket add feed' to add additional feeds")

     

       83
       83
       -
               raise typer.Exit(1)

     

       84
       84
       -
           

     

       85
       85
       -
           # Auto-discover metadata if enabled

     

       86
       86
       -
           discovered_metadata = None

     

       87
       87
       -
           if auto_discover:

     

       88
       88
       -
               discovered_metadata = asyncio.run(discover_feed_metadata(validated_feed_url))

     

       89
       89
       -
           

     

       90
       90
       -
           # Create user config with manual overrides taking precedence

     

       91
       91
       -
           user_config = UserConfig(

     

       92
       92
       -
               username=username,

     

       93
       93
       -
               feeds=[validated_feed_url],

     

       94
       94
       -
               email=email or (discovered_metadata.author_email if discovered_metadata else None),

     

       95
       95
       -
               homepage=HttpUrl(homepage) if homepage else (discovered_metadata.author_uri or discovered_metadata.link if discovered_metadata else None),

     

       96
       96
       -
               icon=HttpUrl(icon) if icon else (discovered_metadata.logo or discovered_metadata.icon or discovered_metadata.image_url if discovered_metadata else None),

     

       97
       97
       -
               display_name=display_name or (discovered_metadata.author_name or discovered_metadata.title if discovered_metadata else None),

     

       98
       98
       -
           )

     

       99
       99
       -
           

     

       100
       100
       -
           # Add user to configuration

     

       101
       101
       -
           config.add_user(user_config)

     

       102
       102
       -
           

     

       103
       103
       -
           # Save configuration

     

       104
       104
       -
           save_config(config, config_file)

     

       105
       105
       -
           

     

       106
       106
       -
           # Add user to Git store

     

       107
       107
       -
           git_store = GitStore(config.git_store)

     

       108
       108
       -
           git_store.add_user(

     

       109
       109
       -
               username=username,

     

       110
       110
       -
               display_name=user_config.display_name,

     

       111
       111
       -
               email=user_config.email,

     

       112
       112
       -
               homepage=str(user_config.homepage) if user_config.homepage else None,

     

       113
       113
       -
               icon=str(user_config.icon) if user_config.icon else None,

     

       114
       114
       -
               feeds=[str(f) for f in user_config.feeds],

     

       115
       115
       -
           )

     

       116
       116
       -
           

     

       117
       117
       -
           # Commit changes

     

       118
       118
       -
           git_store.commit_changes(f"Add user: {username}")

     

       119
       119
       -
           

     

       120
       120
       -
           print_success(f"Added user '{username}' with feed: {feed_url}")

     

       121
       121
       -
           

     

       122
       122
       -
           if discovered_metadata and auto_discover:

     

       123
       123
       -
               print_info("Auto-discovered metadata:")

     

       124
       124
       -
               if user_config.display_name:

     

       125
       125
       -
                   print_info(f"  Display name: {user_config.display_name}")

     

       126
       126
       -
               if user_config.email:

     

       127
       127
       -
                   print_info(f"  Email: {user_config.email}")

     

       128
       128
       -
               if user_config.homepage:

     

       129
       129
       -
                   print_info(f"  Homepage: {user_config.homepage}")

     

       130
       130
       -
               if user_config.icon:

     

       131
       131
       -
                   print_info(f"  Icon: {user_config.icon}")

     

       132
       132
       -
       

     

       133
       133
       -
       

     

       134
       134
       -
       def add_feed(username: str, feed_url: Optional[str], config_file: Path) -> None:

     

       135
       135
       -
           """Add a feed to an existing user."""

     

       136
       136
       -
           

     

       137
       137
       -
           if not feed_url:

     

       138
       138
       -
               print_error("Feed URL is required")

     

       139
       139
       -
               raise typer.Exit(1)

     

       140
       140
       -
           

     

       141
       141
       -
           # Validate feed URL

     

       142
       142
       -
           try:

     

       143
       143
       -
               validated_feed_url = HttpUrl(feed_url)

     

       144
       144
       -
           except ValidationError:

     

       145
       145
       -
               print_error(f"Invalid feed URL: {feed_url}")

     

       146
       146
       -
               raise typer.Exit(1)

     

       147
       147
       -
           

     

       148
       148
       -
           # Load configuration

     

       149
       149
       -
           config = load_config(config_file)

     

       150
       150
       -
           

     

       151
       151
       -
           # Check if user exists

     

       152
       152
       -
           user = config.find_user(username)

     

       153
       153
       -
           if not user:

     

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

     

       155
       155
       -
               print_error("Use 'thicket add user' to add a new user")

     

       156
       156
       -
               raise typer.Exit(1)

     

       157
       157
       -
           

     

       158
       158
       -
           # Check if feed already exists

     

       159
       159
       -
           if validated_feed_url in user.feeds:

     

       160
       160
       -
               print_error(f"Feed already exists for user '{username}': {feed_url}")

     

       161
       161
       -
               raise typer.Exit(1)

     

       162
       162
       -
           

     

       163
       163
       -
           # Add feed to user

     

       164
       164
       -
           if config.add_feed_to_user(username, validated_feed_url):

     

       165
       165
       -
               save_config(config, config_file)

     

       27
       27
       +
               # Load Thicket instance

     

       28
       28
       +
               thicket = load_thicket(config_file)

     

       29
       29
       +
               

     

       30
       30
       +
               # Prepare user data

     

       31
       31
       +
               user_data = {}

     

       32
       32
       +
               if email:

     

       33
       33
       +
                   user_data['email'] = email

     

       34
       34
       +
               if homepage:

     

       35
       35
       +
                   user_data['homepage'] = homepage

     

       36
       36
       +
               if icon:

     

       37
       37
       +
                   user_data['icon'] = icon

     

       38
       38
       +
               if display_name:

     

       39
       39
       +
                   user_data['display_name'] = display_name

     

       40
       40
       +
               

     

       41
       41
       +
               # Add the user

     

       42
       42
       +
               user_config = thicket.add_user(username, feeds, **user_data)

     

       166
       43
        
               

     

       167
       167
       -
               # Update Git store

     

       168
       168
       -
               git_store = GitStore(config.git_store)

     

       169
       169
       -
               git_store.update_user(username, feeds=[str(f) for f in user.feeds])

     

       170
       170
       -
               git_store.commit_changes(f"Add feed to user {username}: {feed_url}")

     

       44
       44
       +
               console.print(f"[green]✓[/green] Added user: {username}")

     

       45
       45
       +
               console.print(f"  • Display name: {user_config.display_name or 'None'}")

     

       46
       46
       +
               console.print(f"  • Email: {user_config.email or 'None'}")

     

       47
       47
       +
               console.print(f"  • Homepage: {user_config.homepage or 'None'}")

     

       48
       48
       +
               console.print(f"  • Feeds: {len(user_config.feeds)}")

     

       171
       49
        
               

     

       172
       172
       -
               print_success(f"Added feed to user '{username}': {feed_url}")

     

       173
       173
       -
           else:

     

       174
       174
       -
               print_error(f"Failed to add feed to user '{username}'")

     

       175
       175
       -
               raise typer.Exit(1)

     

       176
       176
       -
       

     

       177
       177
       -
       

     

       178
       178
       -
       async def discover_feed_metadata(feed_url: HttpUrl):

     

       179
       179
       -
           """Discover metadata from a feed URL."""

     

       180
       180
       -
           try:

     

       181
       181
       -
               with create_progress() as progress:

     

       182
       182
       -
                   task = progress.add_task("Discovering feed metadata...", total=None)

     

       50
       50
       +
               for feed in user_config.feeds:

     

       51
       51
       +
                   console.print(f"    - {feed}")

     

       183
       52
        
                   

     

       184
       184
       -
                   parser = FeedParser()

     

       185
       185
       -
                   content = await parser.fetch_feed(feed_url)

     

       186
       186
       -
                   metadata, _ = parser.parse_feed(content, feed_url)

     

       187
       187
       -
                   

     

       188
       188
       -
                   progress.update(task, completed=True)

     

       189
       189
       -
                   return metadata

     

       53
       53
       +
               # Commit the addition

     

       54
       54
       +
               commit_message = f"Add user {username} with {len(feeds)} feed(s)"

     

       55
       55
       +
               if thicket.commit_changes(commit_message):

     

       56
       56
       +
                   console.print(f"[green]✓[/green] Committed: {commit_message}")

     

       57
       57
       +
               else:

     

       58
       58
       +
                   console.print("[yellow]Warning:[/yellow] Failed to commit changes")

     

       190
       59
        
                   

     

       60
       60
       +
           except ValidationError as e:

     

       61
       61
       +
               console.print(f"[red]Validation Error:[/red] {str(e)}")

     

       62
       62
       +
               raise typer.Exit(1)

     

       191
       63
        
           except Exception as e:

     

       192
       192
       -
               print_error(f"Failed to discover feed metadata: {e}")

     

       193
       193
       -
               return None
     

       64
       64
       +
               console.print(f"[red]Error:[/red] {str(e)}")

     

       65
       65
       +
               raise typer.Exit(1)

     

       66
       66
       +

+35 -25

src/thicket/cli/commands/duplicates.py

···

       14
       14
        
           print_error,

     

       15
       15
        
           print_info,

     

       16
       16
        
           print_success,

     

       17
       17
       +
           get_tsv_mode,

     

       17
       18
        
       )

     

       18
       19
        
       

     

       19
       20
        
       

     
···

       27
       28
        
           ),

     

       28
       29
        
       ) -> None:

     

       29
       30
        
           """Manage duplicate entry mappings."""

     

       30
       30
       -
           

     

       31
       31
       +
       

     

       31
       32
        
           # Load configuration

     

       32
       33
        
           config = load_config(config_file)

     

       33
       33
       -
           

     

       34
       34
       +
       

     

       34
       35
        
           # Initialize Git store

     

       35
       36
        
           git_store = GitStore(config.git_store)

     

       36
       36
       -
           

     

       37
       37
       +
       

     

       37
       38
        
           if action == "list":

     

       38
       39
        
               list_duplicates(git_store)

     

       39
       40
        
           elif action == "add":

     
···

       49
       50
        
       def list_duplicates(git_store: GitStore) -> None:

     

       50
       51
        
           """List all duplicate mappings."""

     

       51
       52
        
           duplicates = git_store.get_duplicates()

     

       52
       52
       -
           

     

       53
       53
       +
       

     

       53
       54
        
           if not duplicates.duplicates:

     

       54
       54
       -
               print_info("No duplicate mappings found")

     

       55
       55
       +
               if get_tsv_mode():

     

       56
       56
       +
                   print("No duplicate mappings found")

     

       57
       57
       +
               else:

     

       58
       58
       +
                   print_info("No duplicate mappings found")

     

       55
       59
        
               return

     

       56
       56
       -
           

     

       57
       57
       -
           table = Table(title="Duplicate Entry Mappings")

     

       58
       58
       -
           table.add_column("Duplicate ID", style="red")

     

       59
       59
       -
           table.add_column("Canonical ID", style="green")

     

       60
       60
       -
           

     

       61
       61
       -
           for duplicate_id, canonical_id in duplicates.duplicates.items():

     

       62
       62
       -
               table.add_row(duplicate_id, canonical_id)

     

       63
       63
       -
           

     

       64
       64
       -
           console.print(table)

     

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

     

       60
       60
       +
       

     

       61
       61
       +
           if get_tsv_mode():

     

       62
       62
       +
               print("Duplicate ID\tCanonical ID")

     

       63
       63
       +
               for duplicate_id, canonical_id in duplicates.duplicates.items():

     

       64
       64
       +
                   print(f"{duplicate_id}\t{canonical_id}")

     

       65
       65
       +
               print(f"Total duplicates: {len(duplicates.duplicates)}")

     

       66
       66
       +
           else:

     

       67
       67
       +
               table = Table(title="Duplicate Entry Mappings")

     

       68
       68
       +
               table.add_column("Duplicate ID", style="red")

     

       69
       69
       +
               table.add_column("Canonical ID", style="green")

     

       70
       70
       +
       

     

       71
       71
       +
               for duplicate_id, canonical_id in duplicates.duplicates.items():

     

       72
       72
       +
                   table.add_row(duplicate_id, canonical_id)

     

       73
       73
       +
       

     

       74
       74
       +
               console.print(table)

     

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

     

       66
       76
        
       

     

       67
       77
        
       

     

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

     
···

       70
       80
        
           if not duplicate_id:

     

       71
       81
        
               print_error("Duplicate ID is required")

     

       72
       82
        
               raise typer.Exit(1)

     

       73
       73
       -
           

     

       83
       83
       +
       

     

       74
       84
        
           if not canonical_id:

     

       75
       85
        
               print_error("Canonical ID is required")

     

       76
       86
        
               raise typer.Exit(1)

     

       77
       77
       -
           

     

       87
       87
       +
       

     

       78
       88
        
           # Check if duplicate_id already exists

     

       79
       89
        
           duplicates = git_store.get_duplicates()

     

       80
       90
        
           if duplicates.is_duplicate(duplicate_id):

     
···

       82
       92
        
               print_error(f"Duplicate ID already mapped to: {existing_canonical}")

     

       83
       93
        
               print_error("Use 'remove' first to change the mapping")

     

       84
       94
        
               raise typer.Exit(1)

     

       85
       85
       -
           

     

       95
       95
       +
       

     

       86
       96
        
           # Check if we're trying to make a canonical ID point to itself

     

       87
       97
        
           if duplicate_id == canonical_id:

     

       88
       98
        
               print_error("Duplicate ID cannot be the same as canonical ID")

     

       89
       99
        
               raise typer.Exit(1)

     

       90
       90
       -
           

     

       100
       100
       +
       

     

       91
       101
        
           # Add the mapping

     

       92
       102
        
           git_store.add_duplicate(duplicate_id, canonical_id)

     

       93
       93
       -
           

     

       103
       103
       +
       

     

       94
       104
        
           # Commit changes

     

       95
       105
        
           git_store.commit_changes(f"Add duplicate mapping: {duplicate_id} -> {canonical_id}")

     

       96
       96
       -
           

     

       106
       106
       +
       

     

       97
       107
        
           print_success(f"Added duplicate mapping: {duplicate_id} -> {canonical_id}")

     

       98
       108
        
       

     

       99
       109
        
       

     
···

       102
       112
        
           if not duplicate_id:

     

       103
       113
        
               print_error("Duplicate ID is required")

     

       104
       114
        
               raise typer.Exit(1)

     

       105
       105
       -
           

     

       115
       115
       +
       

     

       106
       116
        
           # Check if mapping exists

     

       107
       117
        
           duplicates = git_store.get_duplicates()

     

       108
       118
        
           if not duplicates.is_duplicate(duplicate_id):

     

       109
       119
        
               print_error(f"No duplicate mapping found for: {duplicate_id}")

     

       110
       120
        
               raise typer.Exit(1)

     

       111
       111
       -
           

     

       121
       121
       +
       

     

       112
       122
        
           canonical_id = duplicates.get_canonical(duplicate_id)

     

       113
       113
       -
           

     

       123
       123
       +
       

     

       114
       124
        
           # Remove the mapping

     

       115
       125
        
           if git_store.remove_duplicate(duplicate_id):

     

       116
       126
        
               # Commit changes

     
···

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

     

       119
       129
        
           else:

     

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

     

       121
       121
       -
               raise typer.Exit(1)
     

       131
       131
       +
               raise typer.Exit(1)

+59

src/thicket/cli/commands/generate.py

···

       1
       1
       +
       """Generate static HTML website from thicket data."""

     

       2
       2
       +
       

     

       3
       3
       +
       from pathlib import Path

     

       4
       4
       +
       from typing import Optional

     

       5
       5
       +
       

     

       6
       6
       +
       import typer

     

       7
       7
       +
       

     

       8
       8
       +
       from ..main import app, console, load_thicket

     

       9
       9
       +
       

     

       10
       10
       +
       

     

       11
       11
       +
       

     

       12
       12
       +
       

     

       13
       13
       +
       @app.command()

     

       14
       14
       +
       def generate(

     

       15
       15
       +
           output: Path = typer.Option(

     

       16
       16
       +
               Path("./thicket-site"),

     

       17
       17
       +
               "--output",

     

       18
       18
       +
               "-o",

     

       19
       19
       +
               help="Output directory for the generated website",

     

       20
       20
       +
           ),

     

       21
       21
       +
           template_dir: Optional[Path] = typer.Option(

     

       22
       22
       +
               None, "--templates", help="Custom template directory"

     

       23
       23
       +
           ),

     

       24
       24
       +
           config_file: Optional[Path] = typer.Option(

     

       25
       25
       +
               None, "--config", help="Configuration file path"

     

       26
       26
       +
           ),

     

       27
       27
       +
       ) -> None:

     

       28
       28
       +
           """Generate a static HTML website from thicket data."""

     

       29
       29
       +
           

     

       30
       30
       +
           try:

     

       31
       31
       +
               # Load Thicket instance

     

       32
       32
       +
               thicket = load_thicket(config_file)

     

       33
       33
       +
               

     

       34
       34
       +
               console.print(f"[blue]Generating static site to:[/blue] {output}")

     

       35
       35
       +
               

     

       36
       36
       +
               # Generate the complete site

     

       37
       37
       +
               if thicket.generate_site(output, template_dir):

     

       38
       38
       +
                   console.print(f"[green]✓[/green] Successfully generated site at {output}")

     

       39
       39
       +
                   

     

       40
       40
       +
                   # Show what was generated

     

       41
       41
       +
                   stats = thicket.get_stats()

     

       42
       42
       +
                   console.print(f"  • {stats.get('total_entries', 0)} entries")

     

       43
       43
       +
                   console.print(f"  • {stats.get('total_users', 0)} users")

     

       44
       44
       +
                   console.print(f"  • {stats.get('unique_urls', 0)} unique links")

     

       45
       45
       +
                   

     

       46
       46
       +
                   # List generated files

     

       47
       47
       +
                   if output.exists():

     

       48
       48
       +
                       html_files = list(output.glob("*.html"))

     

       49
       49
       +
                       if html_files:

     

       50
       50
       +
                           console.print("  • Generated pages:")

     

       51
       51
       +
                           for html_file in sorted(html_files):

     

       52
       52
       +
                               console.print(f"    - {html_file.name}")

     

       53
       53
       +
               else:

     

       54
       54
       +
                   console.print("[red]✗[/red] Failed to generate site")

     

       55
       55
       +
                   raise typer.Exit(1)

     

       56
       56
       +
                   

     

       57
       57
       +
           except Exception as e:

     

       58
       58
       +
               console.print(f"[red]Error:[/red] {str(e)}")

     

       59
       59
       +
               raise typer.Exit(1)

+427

src/thicket/cli/commands/index_cmd.py

···

       1
       1
       +
       """CLI command for building reference index from blog entries."""

     

       2
       2
       +
       

     

       3
       3
       +
       import json

     

       4
       4
       +
       from pathlib import Path

     

       5
       5
       +
       from typing import Optional

     

       6
       6
       +
       

     

       7
       7
       +
       import typer

     

       8
       8
       +
       from rich.console import Console

     

       9
       9
       +
       from rich.progress import (

     

       10
       10
       +
           BarColumn,

     

       11
       11
       +
           Progress,

     

       12
       12
       +
           SpinnerColumn,

     

       13
       13
       +
           TaskProgressColumn,

     

       14
       14
       +
           TextColumn,

     

       15
       15
       +
       )

     

       16
       16
       +
       from rich.table import Table

     

       17
       17
       +
       

     

       18
       18
       +
       from ...core.git_store import GitStore

     

       19
       19
       +
       from ...core.reference_parser import ReferenceIndex, ReferenceParser

     

       20
       20
       +
       from ..main import app

     

       21
       21
       +
       from ..utils import get_tsv_mode, load_config

     

       22
       22
       +
       

     

       23
       23
       +
       console = Console()

     

       24
       24
       +
       

     

       25
       25
       +
       

     

       26
       26
       +
       @app.command()

     

       27
       27
       +
       def index(

     

       28
       28
       +
           config_file: Optional[Path] = typer.Option(

     

       29
       29
       +
               None,

     

       30
       30
       +
               "--config",

     

       31
       31
       +
               "-c",

     

       32
       32
       +
               help="Path to configuration file",

     

       33
       33
       +
           ),

     

       34
       34
       +
           output_file: Optional[Path] = typer.Option(

     

       35
       35
       +
               None,

     

       36
       36
       +
               "--output",

     

       37
       37
       +
               "-o",

     

       38
       38
       +
               help="Path to output index file (default: updates links.json in git store)",

     

       39
       39
       +
           ),

     

       40
       40
       +
           verbose: bool = typer.Option(

     

       41
       41
       +
               False,

     

       42
       42
       +
               "--verbose",

     

       43
       43
       +
               "-v",

     

       44
       44
       +
               help="Show detailed progress information",

     

       45
       45
       +
           ),

     

       46
       46
       +
       ) -> None:

     

       47
       47
       +
           """Build a reference index showing which blog entries reference others.

     

       48
       48
       +
       

     

       49
       49
       +
           This command analyzes all blog entries to detect cross-references between

     

       50
       50
       +
           different blogs, creating an index that can be used to build threaded

     

       51
       51
       +
           views of related content.

     

       52
       52
       +
           

     

       53
       53
       +
           Updates the unified links.json file with reference data.

     

       54
       54
       +
           """

     

       55
       55
       +
           try:

     

       56
       56
       +
               # Load configuration

     

       57
       57
       +
               config = load_config(config_file)

     

       58
       58
       +
       

     

       59
       59
       +
               # Initialize Git store

     

       60
       60
       +
               git_store = GitStore(config.git_store)

     

       61
       61
       +
       

     

       62
       62
       +
               # Initialize reference parser

     

       63
       63
       +
               parser = ReferenceParser()

     

       64
       64
       +
       

     

       65
       65
       +
               # Build user domain mapping

     

       66
       66
       +
               if verbose:

     

       67
       67
       +
                   console.print("Building user domain mapping...")

     

       68
       68
       +
               user_domains = parser.build_user_domain_mapping(git_store)

     

       69
       69
       +
       

     

       70
       70
       +
               if verbose:

     

       71
       71
       +
                   console.print(f"Found {len(user_domains)} users with {sum(len(d) for d in user_domains.values())} total domains")

     

       72
       72
       +
       

     

       73
       73
       +
               # Initialize reference index

     

       74
       74
       +
               ref_index = ReferenceIndex()

     

       75
       75
       +
               ref_index.user_domains = user_domains

     

       76
       76
       +
       

     

       77
       77
       +
               # Get all users

     

       78
       78
       +
               index = git_store._load_index()

     

       79
       79
       +
               users = list(index.users.keys())

     

       80
       80
       +
       

     

       81
       81
       +
               if not users:

     

       82
       82
       +
                   console.print("[yellow]No users found in Git store[/yellow]")

     

       83
       83
       +
                   raise typer.Exit(0)

     

       84
       84
       +
       

     

       85
       85
       +
               # Process all entries

     

       86
       86
       +
               total_entries = 0

     

       87
       87
       +
               total_references = 0

     

       88
       88
       +
               all_references = []

     

       89
       89
       +
       

     

       90
       90
       +
               with Progress(

     

       91
       91
       +
                   SpinnerColumn(),

     

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

     

       93
       93
       +
                   BarColumn(),

     

       94
       94
       +
                   TaskProgressColumn(),

     

       95
       95
       +
                   console=console,

     

       96
       96
       +
               ) as progress:

     

       97
       97
       +
       

     

       98
       98
       +
                   # Count total entries first

     

       99
       99
       +
                   counting_task = progress.add_task("Counting entries...", total=len(users))

     

       100
       100
       +
                   entry_counts = {}

     

       101
       101
       +
                   for username in users:

     

       102
       102
       +
                       entries = git_store.list_entries(username)

     

       103
       103
       +
                       entry_counts[username] = len(entries)

     

       104
       104
       +
                       total_entries += len(entries)

     

       105
       105
       +
                       progress.advance(counting_task)

     

       106
       106
       +
       

     

       107
       107
       +
                   progress.remove_task(counting_task)

     

       108
       108
       +
       

     

       109
       109
       +
                   # Process entries - extract references

     

       110
       110
       +
                   processing_task = progress.add_task(

     

       111
       111
       +
                       f"Extracting references from {total_entries} entries...",

     

       112
       112
       +
                       total=total_entries

     

       113
       113
       +
                   )

     

       114
       114
       +
       

     

       115
       115
       +
                   for username in users:

     

       116
       116
       +
                       entries = git_store.list_entries(username)

     

       117
       117
       +
       

     

       118
       118
       +
                       for entry in entries:

     

       119
       119
       +
                           # Extract references from this entry

     

       120
       120
       +
                           references = parser.extract_references(entry, username, user_domains)

     

       121
       121
       +
                           all_references.extend(references)

     

       122
       122
       +
       

     

       123
       123
       +
                           progress.advance(processing_task)

     

       124
       124
       +
       

     

       125
       125
       +
                           if verbose and references:

     

       126
       126
       +
                               console.print(f"  Found {len(references)} references in {username}:{entry.title[:50]}...")

     

       127
       127
       +
       

     

       128
       128
       +
                   progress.remove_task(processing_task)

     

       129
       129
       +
       

     

       130
       130
       +
                   # Resolve target_entry_ids for references

     

       131
       131
       +
                   if all_references:

     

       132
       132
       +
                       resolve_task = progress.add_task(

     

       133
       133
       +
                           f"Resolving {len(all_references)} references...",

     

       134
       134
       +
                           total=len(all_references)

     

       135
       135
       +
                       )

     

       136
       136
       +
       

     

       137
       137
       +
                       if verbose:

     

       138
       138
       +
                           console.print(f"Resolving target entry IDs for {len(all_references)} references...")

     

       139
       139
       +
       

     

       140
       140
       +
                       resolved_references = parser.resolve_target_entry_ids(all_references, git_store)

     

       141
       141
       +
       

     

       142
       142
       +
                       # Count resolved references

     

       143
       143
       +
                       resolved_count = sum(1 for ref in resolved_references if ref.target_entry_id is not None)

     

       144
       144
       +
                       if verbose:

     

       145
       145
       +
                           console.print(f"Resolved {resolved_count} out of {len(all_references)} references")

     

       146
       146
       +
       

     

       147
       147
       +
                       # Add resolved references to index

     

       148
       148
       +
                       for ref in resolved_references:

     

       149
       149
       +
                           ref_index.add_reference(ref)

     

       150
       150
       +
                           total_references += 1

     

       151
       151
       +
                           progress.advance(resolve_task)

     

       152
       152
       +
       

     

       153
       153
       +
                       progress.remove_task(resolve_task)

     

       154
       154
       +
       

     

       155
       155
       +
               # Determine output path

     

       156
       156
       +
               if output_file:

     

       157
       157
       +
                   output_path = output_file

     

       158
       158
       +
               else:

     

       159
       159
       +
                   output_path = config.git_store / "links.json"

     

       160
       160
       +
       

     

       161
       161
       +
               # Load existing links data or create new structure

     

       162
       162
       +
               if output_path.exists() and not output_file:

     

       163
       163
       +
                   # Load existing unified structure

     

       164
       164
       +
                   with open(output_path) as f:

     

       165
       165
       +
                       existing_data = json.load(f)

     

       166
       166
       +
               else:

     

       167
       167
       +
                   # Create new structure

     

       168
       168
       +
                   existing_data = {

     

       169
       169
       +
                       "links": {},

     

       170
       170
       +
                       "reverse_mapping": {},

     

       171
       171
       +
                       "user_domains": {}

     

       172
       172
       +
                   }

     

       173
       173
       +
               

     

       174
       174
       +
               # Update with reference data

     

       175
       175
       +
               existing_data["references"] = ref_index.to_dict()["references"]

     

       176
       176
       +
               existing_data["user_domains"] = {k: list(v) for k, v in user_domains.items()}

     

       177
       177
       +
       

     

       178
       178
       +
               # Save updated structure

     

       179
       179
       +
               with open(output_path, "w") as f:

     

       180
       180
       +
                   json.dump(existing_data, f, indent=2, default=str)

     

       181
       181
       +
       

     

       182
       182
       +
               # Show summary

     

       183
       183
       +
               if not get_tsv_mode():

     

       184
       184
       +
                   console.print("\n[green]✓ Reference index built successfully[/green]")

     

       185
       185
       +
       

     

       186
       186
       +
               # Create summary table or TSV output

     

       187
       187
       +
               if get_tsv_mode():

     

       188
       188
       +
                   print("Metric\tCount")

     

       189
       189
       +
                   print(f"Total Users\t{len(users)}")

     

       190
       190
       +
                   print(f"Total Entries\t{total_entries}")

     

       191
       191
       +
                   print(f"Total References\t{total_references}")

     

       192
       192
       +
                   print(f"Outbound Refs\t{len(ref_index.outbound_refs)}")

     

       193
       193
       +
                   print(f"Inbound Refs\t{len(ref_index.inbound_refs)}")

     

       194
       194
       +
                   print(f"Output File\t{output_path}")

     

       195
       195
       +
               else:

     

       196
       196
       +
                   table = Table(title="Reference Index Summary")

     

       197
       197
       +
                   table.add_column("Metric", style="cyan")

     

       198
       198
       +
                   table.add_column("Count", style="green")

     

       199
       199
       +
       

     

       200
       200
       +
                   table.add_row("Total Users", str(len(users)))

     

       201
       201
       +
                   table.add_row("Total Entries", str(total_entries))

     

       202
       202
       +
                   table.add_row("Total References", str(total_references))

     

       203
       203
       +
                   table.add_row("Outbound Refs", str(len(ref_index.outbound_refs)))

     

       204
       204
       +
                   table.add_row("Inbound Refs", str(len(ref_index.inbound_refs)))

     

       205
       205
       +
                   table.add_row("Output File", str(output_path))

     

       206
       206
       +
       

     

       207
       207
       +
                   console.print(table)

     

       208
       208
       +
       

     

       209
       209
       +
               # Show some interesting statistics

     

       210
       210
       +
               if total_references > 0:

     

       211
       211
       +
                   if not get_tsv_mode():

     

       212
       212
       +
                       console.print("\n[bold]Reference Statistics:[/bold]")

     

       213
       213
       +
       

     

       214
       214
       +
                   # Most referenced users

     

       215
       215
       +
                   target_counts = {}

     

       216
       216
       +
                   unresolved_domains = set()

     

       217
       217
       +
       

     

       218
       218
       +
                   for ref in ref_index.references:

     

       219
       219
       +
                       if ref.target_username:

     

       220
       220
       +
                           target_counts[ref.target_username] = target_counts.get(ref.target_username, 0) + 1

     

       221
       221
       +
                       else:

     

       222
       222
       +
                           # Track unresolved domains

     

       223
       223
       +
                           from urllib.parse import urlparse

     

       224
       224
       +
                           domain = urlparse(ref.target_url).netloc.lower()

     

       225
       225
       +
                           unresolved_domains.add(domain)

     

       226
       226
       +
       

     

       227
       227
       +
                   if target_counts:

     

       228
       228
       +
                       if get_tsv_mode():

     

       229
       229
       +
                           print("Referenced User\tReference Count")

     

       230
       230
       +
                           for username, count in sorted(target_counts.items(), key=lambda x: x[1], reverse=True)[:5]:

     

       231
       231
       +
                               print(f"{username}\t{count}")

     

       232
       232
       +
                       else:

     

       233
       233
       +
                           console.print("\nMost referenced users:")

     

       234
       234
       +
                           for username, count in sorted(target_counts.items(), key=lambda x: x[1], reverse=True)[:5]:

     

       235
       235
       +
                               console.print(f"  {username}: {count} references")

     

       236
       236
       +
       

     

       237
       237
       +
                   if unresolved_domains and verbose:

     

       238
       238
       +
                       if get_tsv_mode():

     

       239
       239
       +
                           print("Unresolved Domain\tCount")

     

       240
       240
       +
                           for domain in sorted(list(unresolved_domains)[:10]):

     

       241
       241
       +
                               print(f"{domain}\t1")

     

       242
       242
       +
                           if len(unresolved_domains) > 10:

     

       243
       243
       +
                               print(f"... and {len(unresolved_domains) - 10} more\t...")

     

       244
       244
       +
                       else:

     

       245
       245
       +
                           console.print(f"\nUnresolved domains: {len(unresolved_domains)}")

     

       246
       246
       +
                           for domain in sorted(list(unresolved_domains)[:10]):

     

       247
       247
       +
                               console.print(f"  {domain}")

     

       248
       248
       +
                           if len(unresolved_domains) > 10:

     

       249
       249
       +
                               console.print(f"  ... and {len(unresolved_domains) - 10} more")

     

       250
       250
       +
       

     

       251
       251
       +
           except Exception as e:

     

       252
       252
       +
               console.print(f"[red]Error building reference index: {e}[/red]")

     

       253
       253
       +
               if verbose:

     

       254
       254
       +
                   console.print_exception()

     

       255
       255
       +
               raise typer.Exit(1)

     

       256
       256
       +
       

     

       257
       257
       +
       

     

       258
       258
       +
       @app.command()

     

       259
       259
       +
       def threads(

     

       260
       260
       +
           config_file: Optional[Path] = typer.Option(

     

       261
       261
       +
               None,

     

       262
       262
       +
               "--config",

     

       263
       263
       +
               "-c",

     

       264
       264
       +
               help="Path to configuration file",

     

       265
       265
       +
           ),

     

       266
       266
       +
           index_file: Optional[Path] = typer.Option(

     

       267
       267
       +
               None,

     

       268
       268
       +
               "--index",

     

       269
       269
       +
               "-i",

     

       270
       270
       +
               help="Path to reference index file (default: links.json in git store)",

     

       271
       271
       +
           ),

     

       272
       272
       +
           username: Optional[str] = typer.Option(

     

       273
       273
       +
               None,

     

       274
       274
       +
               "--username",

     

       275
       275
       +
               "-u",

     

       276
       276
       +
               help="Show threads for specific username only",

     

       277
       277
       +
           ),

     

       278
       278
       +
           entry_id: Optional[str] = typer.Option(

     

       279
       279
       +
               None,

     

       280
       280
       +
               "--entry",

     

       281
       281
       +
               "-e",

     

       282
       282
       +
               help="Show thread for specific entry ID",

     

       283
       283
       +
           ),

     

       284
       284
       +
           min_size: int = typer.Option(

     

       285
       285
       +
               2,

     

       286
       286
       +
               "--min-size",

     

       287
       287
       +
               "-m",

     

       288
       288
       +
               help="Minimum thread size to display",

     

       289
       289
       +
           ),

     

       290
       290
       +
       ) -> None:

     

       291
       291
       +
           """Show threaded view of related blog entries.

     

       292
       292
       +
       

     

       293
       293
       +
           This command uses the reference index to show which blog entries

     

       294
       294
       +
           are connected through cross-references, creating an email-style

     

       295
       295
       +
           threaded view of the conversation.

     

       296
       296
       +
           

     

       297
       297
       +
           Reads reference data from the unified links.json file.

     

       298
       298
       +
           """

     

       299
       299
       +
           try:

     

       300
       300
       +
               # Load configuration

     

       301
       301
       +
               config = load_config(config_file)

     

       302
       302
       +
       

     

       303
       303
       +
               # Determine index file path

     

       304
       304
       +
               if index_file:

     

       305
       305
       +
                   index_path = index_file

     

       306
       306
       +
               else:

     

       307
       307
       +
                   index_path = config.git_store / "links.json"

     

       308
       308
       +
       

     

       309
       309
       +
               if not index_path.exists():

     

       310
       310
       +
                   console.print(f"[red]Links file not found: {index_path}[/red]")

     

       311
       311
       +
                   console.print("Run 'thicket links' and 'thicket index' first to build the reference index")

     

       312
       312
       +
                   raise typer.Exit(1)

     

       313
       313
       +
       

     

       314
       314
       +
               # Load unified data

     

       315
       315
       +
               with open(index_path) as f:

     

       316
       316
       +
                   unified_data = json.load(f)

     

       317
       317
       +
       

     

       318
       318
       +
               # Check if references exist in the unified structure

     

       319
       319
       +
               if "references" not in unified_data:

     

       320
       320
       +
                   console.print(f"[red]No references found in {index_path}[/red]")

     

       321
       321
       +
                   console.print("Run 'thicket index' first to build the reference index")

     

       322
       322
       +
                   raise typer.Exit(1)

     

       323
       323
       +
       

     

       324
       324
       +
               # Extract reference data and reconstruct ReferenceIndex

     

       325
       325
       +
               ref_index = ReferenceIndex.from_dict({

     

       326
       326
       +
                   "references": unified_data["references"],

     

       327
       327
       +
                   "user_domains": unified_data.get("user_domains", {})

     

       328
       328
       +
               })

     

       329
       329
       +
       

     

       330
       330
       +
               # Initialize Git store to get entry details

     

       331
       331
       +
               git_store = GitStore(config.git_store)

     

       332
       332
       +
       

     

       333
       333
       +
               if entry_id and username:

     

       334
       334
       +
                   # Show specific thread

     

       335
       335
       +
                   thread_members = ref_index.get_thread_members(username, entry_id)

     

       336
       336
       +
                   _display_thread(thread_members, ref_index, git_store, f"Thread for {username}:{entry_id}")

     

       337
       337
       +
       

     

       338
       338
       +
               elif username:

     

       339
       339
       +
                   # Show all threads involving this user

     

       340
       340
       +
                   user_index = git_store._load_index()

     

       341
       341
       +
                   user = user_index.get_user(username)

     

       342
       342
       +
                   if not user:

     

       343
       343
       +
                       console.print(f"[red]User not found: {username}[/red]")

     

       344
       344
       +
                       raise typer.Exit(1)

     

       345
       345
       +
       

     

       346
       346
       +
                   entries = git_store.list_entries(username)

     

       347
       347
       +
                   threads_found = set()

     

       348
       348
       +
       

     

       349
       349
       +
                   console.print(f"[bold]Threads involving {username}:[/bold]\n")

     

       350
       350
       +
       

     

       351
       351
       +
                   for entry in entries:

     

       352
       352
       +
                       thread_members = ref_index.get_thread_members(username, entry.id)

     

       353
       353
       +
                       if len(thread_members) >= min_size:

     

       354
       354
       +
                           thread_key = tuple(sorted(thread_members))

     

       355
       355
       +
                           if thread_key not in threads_found:

     

       356
       356
       +
                               threads_found.add(thread_key)

     

       357
       357
       +
                               _display_thread(thread_members, ref_index, git_store, f"Thread #{len(threads_found)}")

     

       358
       358
       +
       

     

       359
       359
       +
               else:

     

       360
       360
       +
                   # Show all threads

     

       361
       361
       +
                   console.print("[bold]All conversation threads:[/bold]\n")

     

       362
       362
       +
       

     

       363
       363
       +
                   all_threads = set()

     

       364
       364
       +
                   processed_entries = set()

     

       365
       365
       +
       

     

       366
       366
       +
                   # Get all entries

     

       367
       367
       +
                   user_index = git_store._load_index()

     

       368
       368
       +
                   for username in user_index.users.keys():

     

       369
       369
       +
                       entries = git_store.list_entries(username)

     

       370
       370
       +
                       for entry in entries:

     

       371
       371
       +
                           entry_key = (username, entry.id)

     

       372
       372
       +
                           if entry_key in processed_entries:

     

       373
       373
       +
                               continue

     

       374
       374
       +
       

     

       375
       375
       +
                           thread_members = ref_index.get_thread_members(username, entry.id)

     

       376
       376
       +
                           if len(thread_members) >= min_size:

     

       377
       377
       +
                               thread_key = tuple(sorted(thread_members))

     

       378
       378
       +
                               if thread_key not in all_threads:

     

       379
       379
       +
                                   all_threads.add(thread_key)

     

       380
       380
       +
                                   _display_thread(thread_members, ref_index, git_store, f"Thread #{len(all_threads)}")

     

       381
       381
       +
       

     

       382
       382
       +
                                   # Mark all members as processed

     

       383
       383
       +
                                   for member in thread_members:

     

       384
       384
       +
                                       processed_entries.add(member)

     

       385
       385
       +
       

     

       386
       386
       +
                   if not all_threads:

     

       387
       387
       +
                       console.print("[yellow]No conversation threads found[/yellow]")

     

       388
       388
       +
                       console.print(f"(minimum thread size: {min_size})")

     

       389
       389
       +
       

     

       390
       390
       +
           except Exception as e:

     

       391
       391
       +
               console.print(f"[red]Error showing threads: {e}[/red]")

     

       392
       392
       +
               raise typer.Exit(1)

     

       393
       393
       +
       

     

       394
       394
       +
       

     

       395
       395
       +
       def _display_thread(thread_members, ref_index, git_store, title):

     

       396
       396
       +
           """Display a single conversation thread."""

     

       397
       397
       +
           console.print(f"[bold cyan]{title}[/bold cyan]")

     

       398
       398
       +
           console.print(f"Thread size: {len(thread_members)} entries")

     

       399
       399
       +
       

     

       400
       400
       +
           # Get entry details for each member

     

       401
       401
       +
           thread_entries = []

     

       402
       402
       +
           for username, entry_id in thread_members:

     

       403
       403
       +
               entry = git_store.get_entry(username, entry_id)

     

       404
       404
       +
               if entry:

     

       405
       405
       +
                   thread_entries.append((username, entry))

     

       406
       406
       +
       

     

       407
       407
       +
           # Sort by publication date

     

       408
       408
       +
           thread_entries.sort(key=lambda x: x[1].published or x[1].updated)

     

       409
       409
       +
       

     

       410
       410
       +
           # Display entries

     

       411
       411
       +
           for i, (username, entry) in enumerate(thread_entries):

     

       412
       412
       +
               prefix = "├─" if i < len(thread_entries) - 1 else "└─"

     

       413
       413
       +
       

     

       414
       414
       +
               # Get references for this entry

     

       415
       415
       +
               outbound = ref_index.get_outbound_refs(username, entry.id)

     

       416
       416
       +
               inbound = ref_index.get_inbound_refs(username, entry.id)

     

       417
       417
       +
       

     

       418
       418
       +
               ref_info = ""

     

       419
       419
       +
               if outbound or inbound:

     

       420
       420
       +
                   ref_info = f" ({len(outbound)} out, {len(inbound)} in)"

     

       421
       421
       +
       

     

       422
       422
       +
               console.print(f"  {prefix} [{username}] {entry.title[:60]}...{ref_info}")

     

       423
       423
       +
       

     

       424
       424
       +
               if entry.published:

     

       425
       425
       +
                   console.print(f"    Published: {entry.published.strftime('%Y-%m-%d')}")

     

       426
       426
       +
       

     

       427
       427
       +
           console.print()  # Empty line after each thread

+311

src/thicket/cli/commands/info_cmd.py

···

       1
       1
       +
       """CLI command for displaying detailed information about a specific atom entry."""

     

       2
       2
       +
       

     

       3
       3
       +
       import json

     

       4
       4
       +
       from pathlib import Path

     

       5
       5
       +
       from typing import Optional

     

       6
       6
       +
       

     

       7
       7
       +
       import typer

     

       8
       8
       +
       from rich.console import Console

     

       9
       9
       +
       from rich.panel import Panel

     

       10
       10
       +
       from rich.table import Table

     

       11
       11
       +
       from rich.text import Text

     

       12
       12
       +
       

     

       13
       13
       +
       from ...core.git_store import GitStore

     

       14
       14
       +
       from ...core.reference_parser import ReferenceIndex

     

       15
       15
       +
       from ..main import app

     

       16
       16
       +
       from ..utils import load_config, get_tsv_mode

     

       17
       17
       +
       

     

       18
       18
       +
       console = Console()

     

       19
       19
       +
       

     

       20
       20
       +
       

     

       21
       21
       +
       @app.command()

     

       22
       22
       +
       def info(

     

       23
       23
       +
           identifier: str = typer.Argument(

     

       24
       24
       +
               ...,

     

       25
       25
       +
               help="The atom ID or URL of the entry to display information about"

     

       26
       26
       +
           ),

     

       27
       27
       +
           username: Optional[str] = typer.Option(

     

       28
       28
       +
               None,

     

       29
       29
       +
               "--username",

     

       30
       30
       +
               "-u",

     

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

     

       32
       32
       +
           ),

     

       33
       33
       +
           config_file: Optional[Path] = typer.Option(

     

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

     

       35
       35
       +
               "--config",

     

       36
       36
       +
               "-c",

     

       37
       37
       +
               help="Path to configuration file",

     

       38
       38
       +
           ),

     

       39
       39
       +
           show_content: bool = typer.Option(

     

       40
       40
       +
               False,

     

       41
       41
       +
               "--content",

     

       42
       42
       +
               help="Include the full content of the entry in the output"

     

       43
       43
       +
           ),

     

       44
       44
       +
       ) -> None:

     

       45
       45
       +
           """Display detailed information about a specific atom entry.

     

       46
       46
       +
           

     

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

     

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

     

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

     

       50
       50
       +
           """

     

       51
       51
       +
           try:

     

       52
       52
       +
               # Load configuration

     

       53
       53
       +
               config = load_config(config_file)

     

       54
       54
       +
               

     

       55
       55
       +
               # Initialize Git store

     

       56
       56
       +
               git_store = GitStore(config.git_store)

     

       57
       57
       +
               

     

       58
       58
       +
               # Find the entry

     

       59
       59
       +
               entry = None

     

       60
       60
       +
               found_username = None

     

       61
       61
       +
               

     

       62
       62
       +
               # Check if identifier looks like a URL

     

       63
       63
       +
               is_url = identifier.startswith(('http://', 'https://'))

     

       64
       64
       +
               

     

       65
       65
       +
               if username:

     

       66
       66
       +
                   # Search specific username

     

       67
       67
       +
                   if is_url:

     

       68
       68
       +
                       # Search by URL

     

       69
       69
       +
                       entries = git_store.list_entries(username)

     

       70
       70
       +
                       for e in entries:

     

       71
       71
       +
                           if str(e.link) == identifier:

     

       72
       72
       +
                               entry = e

     

       73
       73
       +
                               found_username = username

     

       74
       74
       +
                               break

     

       75
       75
       +
                   else:

     

       76
       76
       +
                       # Search by atom ID

     

       77
       77
       +
                       entry = git_store.get_entry(username, identifier)

     

       78
       78
       +
                       if entry:

     

       79
       79
       +
                           found_username = username

     

       80
       80
       +
               else:

     

       81
       81
       +
                   # Search all users

     

       82
       82
       +
                   index = git_store._load_index()

     

       83
       83
       +
                   for user in index.users.keys():

     

       84
       84
       +
                       if is_url:

     

       85
       85
       +
                           # Search by URL

     

       86
       86
       +
                           entries = git_store.list_entries(user)

     

       87
       87
       +
                           for e in entries:

     

       88
       88
       +
                               if str(e.link) == identifier:

     

       89
       89
       +
                                   entry = e

     

       90
       90
       +
                                   found_username = user

     

       91
       91
       +
                                   break

     

       92
       92
       +
                           if entry:

     

       93
       93
       +
                               break

     

       94
       94
       +
                       else:

     

       95
       95
       +
                           # Search by atom ID

     

       96
       96
       +
                           entry = git_store.get_entry(user, identifier)

     

       97
       97
       +
                           if entry:

     

       98
       98
       +
                               found_username = user

     

       99
       99
       +
                               break

     

       100
       100
       +
               

     

       101
       101
       +
               if not entry or not found_username:

     

       102
       102
       +
                   if username:

     

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

     

       104
       104
       +
                   else:

     

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

     

       106
       106
       +
                   raise typer.Exit(1)

     

       107
       107
       +
               

     

       108
       108
       +
               # Load reference index if available

     

       109
       109
       +
               links_path = config.git_store / "links.json"

     

       110
       110
       +
               ref_index = None

     

       111
       111
       +
               if links_path.exists():

     

       112
       112
       +
                   with open(links_path) as f:

     

       113
       113
       +
                       unified_data = json.load(f)

     

       114
       114
       +
                   

     

       115
       115
       +
                   # Check if references exist in the unified structure

     

       116
       116
       +
                   if "references" in unified_data:

     

       117
       117
       +
                       ref_index = ReferenceIndex.from_dict({

     

       118
       118
       +
                           "references": unified_data["references"],

     

       119
       119
       +
                           "user_domains": unified_data.get("user_domains", {})

     

       120
       120
       +
                       })

     

       121
       121
       +
               

     

       122
       122
       +
               # Display information

     

       123
       123
       +
               if get_tsv_mode():

     

       124
       124
       +
                   _display_entry_info_tsv(entry, found_username, ref_index, show_content)

     

       125
       125
       +
               else:

     

       126
       126
       +
                   _display_entry_info(entry, found_username)

     

       127
       127
       +
                   

     

       128
       128
       +
                   if ref_index:

     

       129
       129
       +
                       _display_link_info(entry, found_username, ref_index)

     

       130
       130
       +
                   else:

     

       131
       131
       +
                       console.print("\n[yellow]No reference index found. Run 'thicket links' and 'thicket index' to build cross-reference data.[/yellow]")

     

       132
       132
       +
                   

     

       133
       133
       +
                   # Optionally display content

     

       134
       134
       +
                   if show_content and entry.content:

     

       135
       135
       +
                       _display_content(entry.content)

     

       136
       136
       +
                   

     

       137
       137
       +
           except Exception as e:

     

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

     

       139
       139
       +
               raise typer.Exit(1)

     

       140
       140
       +
       

     

       141
       141
       +
       

     

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

     

       143
       143
       +
           """Display basic entry information in a structured format."""

     

       144
       144
       +
           

     

       145
       145
       +
           # Create main info panel

     

       146
       146
       +
           info_table = Table.grid(padding=(0, 2))

     

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

     

       148
       148
       +
           info_table.add_column("Value", style="white")

     

       149
       149
       +
           

     

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

     

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

     

       152
       152
       +
           info_table.add_row("Title", entry.title)

     

       153
       153
       +
           info_table.add_row("Link", str(entry.link))

     

       154
       154
       +
           

     

       155
       155
       +
           if entry.published:

     

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

     

       157
       157
       +
           

     

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

     

       159
       159
       +
           

     

       160
       160
       +
           if entry.summary:

     

       161
       161
       +
               # Truncate long summaries

     

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

     

       163
       163
       +
               info_table.add_row("Summary", summary)

     

       164
       164
       +
           

     

       165
       165
       +
           if entry.categories:

     

       166
       166
       +
               categories_text = ", ".join(entry.categories)

     

       167
       167
       +
               info_table.add_row("Categories", categories_text)

     

       168
       168
       +
           

     

       169
       169
       +
           if entry.author:

     

       170
       170
       +
               author_info = []

     

       171
       171
       +
               if "name" in entry.author:

     

       172
       172
       +
                   author_info.append(entry.author["name"])

     

       173
       173
       +
               if "email" in entry.author:

     

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

     

       175
       175
       +
               if author_info:

     

       176
       176
       +
                   info_table.add_row("Author", " ".join(author_info))

     

       177
       177
       +
           

     

       178
       178
       +
           if entry.content_type:

     

       179
       179
       +
               info_table.add_row("Content Type", entry.content_type)

     

       180
       180
       +
           

     

       181
       181
       +
           if entry.rights:

     

       182
       182
       +
               info_table.add_row("Rights", entry.rights)

     

       183
       183
       +
           

     

       184
       184
       +
           if entry.source:

     

       185
       185
       +
               info_table.add_row("Source Feed", entry.source)

     

       186
       186
       +
           

     

       187
       187
       +
           panel = Panel(

     

       188
       188
       +
               info_table,

     

       189
       189
       +
               title=f"[bold]Entry Information[/bold]",

     

       190
       190
       +
               border_style="blue"

     

       191
       191
       +
           )

     

       192
       192
       +
           

     

       193
       193
       +
           console.print(panel)

     

       194
       194
       +
       

     

       195
       195
       +
       

     

       196
       196
       +
       def _display_link_info(entry, username: str, ref_index: ReferenceIndex) -> None:

     

       197
       197
       +
           """Display inbound and outbound link information."""

     

       198
       198
       +
           

     

       199
       199
       +
           # Get links

     

       200
       200
       +
           outbound_refs = ref_index.get_outbound_refs(username, entry.id)

     

       201
       201
       +
           inbound_refs = ref_index.get_inbound_refs(username, entry.id)

     

       202
       202
       +
           

     

       203
       203
       +
           if not outbound_refs and not inbound_refs:

     

       204
       204
       +
               console.print("\n[dim]No cross-references found for this entry.[/dim]")

     

       205
       205
       +
               return

     

       206
       206
       +
           

     

       207
       207
       +
           # Create links table

     

       208
       208
       +
           links_table = Table(title="Cross-References")

     

       209
       209
       +
           links_table.add_column("Direction", style="cyan", width=10)

     

       210
       210
       +
           links_table.add_column("Target/Source", style="green", width=20)

     

       211
       211
       +
           links_table.add_column("URL", style="blue", width=50)

     

       212
       212
       +
           

     

       213
       213
       +
           # Add outbound references

     

       214
       214
       +
           for ref in outbound_refs:

     

       215
       215
       +
               target_info = f"{ref.target_username}:{ref.target_entry_id}" if ref.target_username and ref.target_entry_id else "External"

     

       216
       216
       +
               links_table.add_row("→ Out", target_info, ref.target_url)

     

       217
       217
       +
           

     

       218
       218
       +
           # Add inbound references

     

       219
       219
       +
           for ref in inbound_refs:

     

       220
       220
       +
               source_info = f"{ref.source_username}:{ref.source_entry_id}"

     

       221
       221
       +
               links_table.add_row("← In", source_info, ref.target_url)

     

       222
       222
       +
           

     

       223
       223
       +
           console.print()

     

       224
       224
       +
           console.print(links_table)

     

       225
       225
       +
           

     

       226
       226
       +
           # Summary

     

       227
       227
       +
           console.print(f"\n[bold]Summary:[/bold] {len(outbound_refs)} outbound, {len(inbound_refs)} inbound references")

     

       228
       228
       +
       

     

       229
       229
       +
       

     

       230
       230
       +
       def _display_content(content: str) -> None:

     

       231
       231
       +
           """Display the full content of the entry."""

     

       232
       232
       +
           

     

       233
       233
       +
           # Truncate very long content

     

       234
       234
       +
           display_content = content

     

       235
       235
       +
           if len(content) > 5000:

     

       236
       236
       +
               display_content = content[:5000] + "\n\n[... content truncated ...]"

     

       237
       237
       +
           

     

       238
       238
       +
           panel = Panel(

     

       239
       239
       +
               display_content,

     

       240
       240
       +
               title="[bold]Entry Content[/bold]",

     

       241
       241
       +
               border_style="green",

     

       242
       242
       +
               expand=False

     

       243
       243
       +
           )

     

       244
       244
       +
           

     

       245
       245
       +
           console.print()

     

       246
       246
       +
           console.print(panel)

     

       247
       247
       +
       

     

       248
       248
       +
       

     

       249
       249
       +
       def _display_entry_info_tsv(entry, username: str, ref_index: Optional[ReferenceIndex], show_content: bool) -> None:

     

       250
       250
       +
           """Display entry information in TSV format."""

     

       251
       251
       +
           

     

       252
       252
       +
           # Basic info

     

       253
       253
       +
           print("Field\tValue")

     

       254
       254
       +
           print(f"User\t{username}")

     

       255
       255
       +
           print(f"Atom ID\t{entry.id}")

     

       256
       256
       +
           print(f"Title\t{entry.title.replace(chr(9), ' ').replace(chr(10), ' ').replace(chr(13), ' ')}")

     

       257
       257
       +
           print(f"Link\t{entry.link}")

     

       258
       258
       +
           

     

       259
       259
       +
           if entry.published:

     

       260
       260
       +
               print(f"Published\t{entry.published.strftime('%Y-%m-%d %H:%M:%S UTC')}")

     

       261
       261
       +
           

     

       262
       262
       +
           print(f"Updated\t{entry.updated.strftime('%Y-%m-%d %H:%M:%S UTC')}")

     

       263
       263
       +
           

     

       264
       264
       +
           if entry.summary:

     

       265
       265
       +
               # Escape tabs and newlines in summary

     

       266
       266
       +
               summary = entry.summary.replace('\t', ' ').replace('\n', ' ').replace('\r', ' ')

     

       267
       267
       +
               print(f"Summary\t{summary}")

     

       268
       268
       +
           

     

       269
       269
       +
           if entry.categories:

     

       270
       270
       +
               print(f"Categories\t{', '.join(entry.categories)}")

     

       271
       271
       +
           

     

       272
       272
       +
           if entry.author:

     

       273
       273
       +
               author_info = []

     

       274
       274
       +
               if "name" in entry.author:

     

       275
       275
       +
                   author_info.append(entry.author["name"])

     

       276
       276
       +
               if "email" in entry.author:

     

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

     

       278
       278
       +
               if author_info:

     

       279
       279
       +
                   print(f"Author\t{' '.join(author_info)}")

     

       280
       280
       +
           

     

       281
       281
       +
           if entry.content_type:

     

       282
       282
       +
               print(f"Content Type\t{entry.content_type}")

     

       283
       283
       +
           

     

       284
       284
       +
           if entry.rights:

     

       285
       285
       +
               print(f"Rights\t{entry.rights}")

     

       286
       286
       +
           

     

       287
       287
       +
           if entry.source:

     

       288
       288
       +
               print(f"Source Feed\t{entry.source}")

     

       289
       289
       +
           

     

       290
       290
       +
           # Add reference info if available

     

       291
       291
       +
           if ref_index:

     

       292
       292
       +
               outbound_refs = ref_index.get_outbound_refs(username, entry.id)

     

       293
       293
       +
               inbound_refs = ref_index.get_inbound_refs(username, entry.id)

     

       294
       294
       +
               

     

       295
       295
       +
               print(f"Outbound References\t{len(outbound_refs)}")

     

       296
       296
       +
               print(f"Inbound References\t{len(inbound_refs)}")

     

       297
       297
       +
               

     

       298
       298
       +
               # Show each reference

     

       299
       299
       +
               for ref in outbound_refs:

     

       300
       300
       +
                   target_info = f"{ref.target_username}:{ref.target_entry_id}" if ref.target_username and ref.target_entry_id else "External"

     

       301
       301
       +
                   print(f"Outbound Reference\t{target_info}\t{ref.target_url}")

     

       302
       302
       +
               

     

       303
       303
       +
               for ref in inbound_refs:

     

       304
       304
       +
                   source_info = f"{ref.source_username}:{ref.source_entry_id}"

     

       305
       305
       +
                   print(f"Inbound Reference\t{source_info}\t{ref.target_url}")

     

       306
       306
       +
           

     

       307
       307
       +
           # Show content if requested

     

       308
       308
       +
           if show_content and entry.content:

     

       309
       309
       +
               # Escape tabs and newlines in content

     

       310
       310
       +
               content = entry.content.replace('\t', ' ').replace('\n', ' ').replace('\r', ' ')

     

       311
       311
       +
               print(f"Content\t{content}")

+54 -43

src/thicket/cli/commands/init.py

···

       1
       1
        
       """Initialize command for thicket."""

     

       2
       2
        
       

     

       3
       3
       +
       import yaml

     

       3
       4
        
       from pathlib import Path

     

       4
       5
        
       from typing import Optional

     

       5
       6
        
       

     

       6
       7
        
       import typer

     

       7
       7
       -
       from pydantic import ValidationError

     

       8
       8
        
       

     

       9
       9
       -
       from ...core.git_store import GitStore

     

       9
       9
       +
       from ..main import app, console, get_config_path

     

       10
       10
        
       from ...models import ThicketConfig

     

       11
       11
       -
       from ..main import app

     

       12
       12
       -
       from ..utils import print_error, print_success, save_config

     

       11
       11
       +
       from ... import Thicket

     

       13
       12
        
       

     

       14
       13
        
       

     

       15
       14
        
       @app.command()

     
···

       19
       18
        
               None, "--cache-dir", "-c", help="Cache directory (default: ~/.cache/thicket)"

     

       20
       19
        
           ),

     

       21
       20
        
           config_file: Optional[Path] = typer.Option(

     

       22
       22
       -
               None, "--config", help="Configuration file path (default: thicket.yaml)"

     

       21
       21
       +
               None, "--config", help="Configuration file path (default: ~/.config/thicket/config.yaml)"

     

       23
       22
        
           ),

     

       24
       23
        
           force: bool = typer.Option(

     

       25
       24
        
               False, "--force", "-f", help="Overwrite existing configuration"

     

       26
       25
        
           ),

     

       27
       26
        
       ) -> None:

     

       28
       27
        
           """Initialize a new thicket configuration and Git store."""

     

       29
       29
       -
           

     

       28
       28
       +
       

     

       30
       29
        
           # Set default paths

     

       31
       30
        
           if cache_dir is None:

     

       32
       32
       -
               from platformdirs import user_cache_dir

     

       33
       33
       -
               cache_dir = Path(user_cache_dir("thicket"))

     

       34
       34
       -
           

     

       31
       31
       +
               cache_dir = Path.home() / ".cache" / "thicket"

     

       32
       32
       +
       

     

       35
       33
        
           if config_file is None:

     

       36
       36
       -
               config_file = Path("thicket.yaml")

     

       37
       37
       -
           

     

       34
       34
       +
               config_file = get_config_path()

     

       35
       35
       +
       

     

       38
       36
        
           # Check if config already exists

     

       39
       37
        
           if config_file.exists() and not force:

     

       40
       40
       -
               print_error(f"Configuration file already exists: {config_file}")

     

       41
       41
       -
               print_error("Use --force to overwrite")

     

       38
       38
       +
               console.print(f"[red]Configuration file already exists:[/red] {config_file}")

     

       39
       39
       +
               console.print("Use --force to overwrite")

     

       42
       40
        
               raise typer.Exit(1)

     

       43
       43
       -
           

     

       44
       44
       -
           # Create cache directory

     

       45
       45
       -
           cache_dir.mkdir(parents=True, exist_ok=True)

     

       46
       46
       -
           

     

       47
       47
       -
           # Create Git store

     

       41
       41
       +
       

     

       48
       42
        
           try:

     

       49
       49
       -
               git_store_obj = GitStore(git_store)

     

       50
       50
       -
               print_success(f"Initialized Git store at: {git_store}")

     

       51
       51
       -
           except Exception as e:

     

       52
       52
       -
               print_error(f"Failed to initialize Git store: {e}")

     

       53
       53
       -
               raise typer.Exit(1)

     

       54
       54
       -
           

     

       55
       55
       -
           # Create configuration

     

       56
       56
       -
           try:

     

       57
       57
       -
               config = ThicketConfig(

     

       58
       58
       -
                   git_store=git_store,

     

       59
       59
       -
                   cache_dir=cache_dir,

     

       60
       60
       -
                   users=[]

     

       61
       61
       -
               )

     

       43
       43
       +
               # Create directories

     

       44
       44
       +
               git_store.mkdir(parents=True, exist_ok=True)

     

       45
       45
       +
               cache_dir.mkdir(parents=True, exist_ok=True)

     

       46
       46
       +
               config_file.parent.mkdir(parents=True, exist_ok=True)

     

       47
       47
       +
       

     

       48
       48
       +
               # Create Thicket instance with minimal config

     

       49
       49
       +
               thicket = Thicket.create(git_store, cache_dir)

     

       50
       50
       +
               

     

       51
       51
       +
               # Initialize the repository

     

       52
       52
       +
               if thicket.init_repository():

     

       53
       53
       +
                   console.print(f"[green]✓[/green] Initialized Git store at: {git_store}")

     

       54
       54
       +
               else:

     

       55
       55
       +
                   console.print(f"[red]✗[/red] Failed to initialize Git store")

     

       56
       56
       +
                   raise typer.Exit(1)

     

       57
       57
       +
       

     

       58
       58
       +
               # Save configuration

     

       59
       59
       +
               config_data = {

     

       60
       60
       +
                   'git_store': str(git_store),

     

       61
       61
       +
                   'cache_dir': str(cache_dir),

     

       62
       62
       +
                   'users': []

     

       63
       63
       +
               }

     

       62
       64
        
               

     

       63
       63
       -
               save_config(config, config_file)

     

       64
       64
       -
               print_success(f"Created configuration file: {config_file}")

     

       65
       65
       +
               with open(config_file, 'w') as f:

     

       66
       66
       +
                   yaml.dump(config_data, f, default_flow_style=False)

     

       65
       67
        
               

     

       66
       66
       -
           except ValidationError as e:

     

       67
       67
       -
               print_error(f"Invalid configuration: {e}")

     

       68
       68
       -
               raise typer.Exit(1)

     

       68
       68
       +
               console.print(f"[green]✓[/green] Created configuration file: {config_file}")

     

       69
       69
       +
       

     

       70
       70
       +
               # Create initial commit

     

       71
       71
       +
               if thicket.commit_changes("Initialize thicket repository"):

     

       72
       72
       +
                   console.print("[green]✓[/green] Created initial commit")

     

       73
       73
       +
       

     

       74
       74
       +
               console.print("\n[green]Thicket initialized successfully![/green]")

     

       75
       75
       +
               console.print(f"  • Git store: {git_store}")

     

       76
       76
       +
               console.print(f"  • Cache directory: {cache_dir}")

     

       77
       77
       +
               console.print(f"  • Configuration: {config_file}")

     

       78
       78
       +
               console.print("\n[blue]Next steps:[/blue]")

     

       79
       79
       +
               console.print("  1. Add your first user and feed:")

     

       80
       80
       +
               console.print(f"     [cyan]thicket add username https://example.com/feed.xml[/cyan]")

     

       81
       81
       +
               console.print("  2. Sync feeds:")

     

       82
       82
       +
               console.print(f"     [cyan]thicket sync[/cyan]")

     

       83
       83
       +
               console.print("  3. Generate a website:")

     

       84
       84
       +
               console.print(f"     [cyan]thicket generate[/cyan]")

     

       85
       85
       +
       

     

       69
       86
        
           except Exception as e:

     

       70
       70
       -
               print_error(f"Failed to create configuration: {e}")

     

       87
       87
       +
               console.print(f"[red]Error:[/red] {str(e)}")

     

       71
       88
        
               raise typer.Exit(1)

     

       72
       72
       -
           

     

       73
       73
       -
           print_success("Thicket initialized successfully!")

     

       74
       74
       -
           print_success(f"Git store: {git_store}")

     

       75
       75
       -
           print_success(f"Cache directory: {cache_dir}")

     

       76
       76
       -
           print_success(f"Configuration: {config_file}")

     

       77
       77
       -
           print_success("Run 'thicket add user' to add your first user and feed.")

+416

src/thicket/cli/commands/links_cmd.py

···

       1
       1
       +
       """CLI command for extracting and categorizing all outbound links from blog entries."""

     

       2
       2
       +
       

     

       3
       3
       +
       import json

     

       4
       4
       +
       import re

     

       5
       5
       +
       from pathlib import Path

     

       6
       6
       +
       from typing import Dict, List, Optional, Set

     

       7
       7
       +
       from urllib.parse import urljoin, urlparse

     

       8
       8
       +
       

     

       9
       9
       +
       import typer

     

       10
       10
       +
       from rich.console import Console

     

       11
       11
       +
       from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn

     

       12
       12
       +
       from rich.table import Table

     

       13
       13
       +
       

     

       14
       14
       +
       from ...core.git_store import GitStore

     

       15
       15
       +
       from ..main import app

     

       16
       16
       +
       from ..utils import load_config, get_tsv_mode

     

       17
       17
       +
       

     

       18
       18
       +
       console = Console()

     

       19
       19
       +
       

     

       20
       20
       +
       

     

       21
       21
       +
       class LinkData:

     

       22
       22
       +
           """Represents a link found in a blog entry."""

     

       23
       23
       +
           

     

       24
       24
       +
           def __init__(self, url: str, entry_id: str, username: str):

     

       25
       25
       +
               self.url = url

     

       26
       26
       +
               self.entry_id = entry_id

     

       27
       27
       +
               self.username = username

     

       28
       28
       +
           

     

       29
       29
       +
           def to_dict(self) -> dict:

     

       30
       30
       +
               """Convert to dictionary for JSON serialization."""

     

       31
       31
       +
               return {

     

       32
       32
       +
                   "url": self.url,

     

       33
       33
       +
                   "entry_id": self.entry_id,

     

       34
       34
       +
                   "username": self.username

     

       35
       35
       +
               }

     

       36
       36
       +
           

     

       37
       37
       +
           @classmethod

     

       38
       38
       +
           def from_dict(cls, data: dict) -> "LinkData":

     

       39
       39
       +
               """Create from dictionary."""

     

       40
       40
       +
               return cls(

     

       41
       41
       +
                   url=data["url"],

     

       42
       42
       +
                   entry_id=data["entry_id"],

     

       43
       43
       +
                   username=data["username"]

     

       44
       44
       +
               )

     

       45
       45
       +
       

     

       46
       46
       +
       

     

       47
       47
       +
       class LinkCategorizer:

     

       48
       48
       +
           """Categorizes links as internal, user, or unknown."""

     

       49
       49
       +
           

     

       50
       50
       +
           def __init__(self, user_domains: Dict[str, Set[str]]):

     

       51
       51
       +
               self.user_domains = user_domains

     

       52
       52
       +
               # Create reverse mapping of domain -> username

     

       53
       53
       +
               self.domain_to_user = {}

     

       54
       54
       +
               for username, domains in user_domains.items():

     

       55
       55
       +
                   for domain in domains:

     

       56
       56
       +
                       self.domain_to_user[domain] = username

     

       57
       57
       +
           

     

       58
       58
       +
           def categorize_url(self, url: str, source_username: str) -> tuple[str, Optional[str]]:

     

       59
       59
       +
               """

     

       60
       60
       +
               Categorize a URL as 'internal', 'user', or 'unknown'.

     

       61
       61
       +
               Returns (category, target_username).

     

       62
       62
       +
               """

     

       63
       63
       +
               try:

     

       64
       64
       +
                   parsed = urlparse(url)

     

       65
       65
       +
                   domain = parsed.netloc.lower()

     

       66
       66
       +
                   

     

       67
       67
       +
                   # Check if it's a link to the same user's domain (internal)

     

       68
       68
       +
                   if domain in self.user_domains.get(source_username, set()):

     

       69
       69
       +
                       return "internal", source_username

     

       70
       70
       +
                   

     

       71
       71
       +
                   # Check if it's a link to another user's domain

     

       72
       72
       +
                   if domain in self.domain_to_user:

     

       73
       73
       +
                       return "user", self.domain_to_user[domain]

     

       74
       74
       +
                   

     

       75
       75
       +
                   # Everything else is unknown

     

       76
       76
       +
                   return "unknown", None

     

       77
       77
       +
                   

     

       78
       78
       +
               except Exception:

     

       79
       79
       +
                   return "unknown", None

     

       80
       80
       +
       

     

       81
       81
       +
       

     

       82
       82
       +
       class LinkExtractor:

     

       83
       83
       +
           """Extracts and resolves links from blog entries."""

     

       84
       84
       +
           

     

       85
       85
       +
           def __init__(self):

     

       86
       86
       +
               # Pattern for extracting links from HTML

     

       87
       87
       +
               self.link_pattern = re.compile(r'<a[^>]+href="([^"]+)"[^>]*>(.*?)</a>', re.IGNORECASE | re.DOTALL)

     

       88
       88
       +
               self.url_pattern = re.compile(r'https?://[^\s<>"]+')

     

       89
       89
       +
           

     

       90
       90
       +
           def extract_links_from_html(self, html_content: str, base_url: str) -> List[tuple[str, str]]:

     

       91
       91
       +
               """Extract all links from HTML content and resolve them against base URL."""

     

       92
       92
       +
               links = []

     

       93
       93
       +
               

     

       94
       94
       +
               # Extract links from <a> tags

     

       95
       95
       +
               for match in self.link_pattern.finditer(html_content):

     

       96
       96
       +
                   url = match.group(1)

     

       97
       97
       +
                   text = re.sub(r'<[^>]+>', '', match.group(2)).strip()  # Remove HTML tags from link text

     

       98
       98
       +
                   

     

       99
       99
       +
                   # Resolve relative URLs against base URL

     

       100
       100
       +
                   resolved_url = urljoin(base_url, url)

     

       101
       101
       +
                   links.append((resolved_url, text))

     

       102
       102
       +
               

     

       103
       103
       +
               return links

     

       104
       104
       +
           

     

       105
       105
       +
           

     

       106
       106
       +
           def extract_links_from_entry(self, entry, username: str, base_url: str) -> List[LinkData]:

     

       107
       107
       +
               """Extract all links from a blog entry."""

     

       108
       108
       +
               links = []

     

       109
       109
       +
               

     

       110
       110
       +
               # Combine all text content for analysis

     

       111
       111
       +
               content_to_search = []

     

       112
       112
       +
               if entry.content:

     

       113
       113
       +
                   content_to_search.append(entry.content)

     

       114
       114
       +
               if entry.summary:

     

       115
       115
       +
                   content_to_search.append(entry.summary)

     

       116
       116
       +
               

     

       117
       117
       +
               for content in content_to_search:

     

       118
       118
       +
                   extracted_links = self.extract_links_from_html(content, base_url)

     

       119
       119
       +
                   

     

       120
       120
       +
                   for url, link_text in extracted_links:

     

       121
       121
       +
                       # Skip empty URLs

     

       122
       122
       +
                       if not url or url.startswith('#'):

     

       123
       123
       +
                           continue

     

       124
       124
       +
                       

     

       125
       125
       +
                       link_data = LinkData(

     

       126
       126
       +
                           url=url,

     

       127
       127
       +
                           entry_id=entry.id,

     

       128
       128
       +
                           username=username

     

       129
       129
       +
                       )

     

       130
       130
       +
                       

     

       131
       131
       +
                       links.append(link_data)

     

       132
       132
       +
               

     

       133
       133
       +
               return links

     

       134
       134
       +
       

     

       135
       135
       +
       

     

       136
       136
       +
       @app.command()

     

       137
       137
       +
       def links(

     

       138
       138
       +
           config_file: Optional[Path] = typer.Option(

     

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

     

       140
       140
       +
               "--config",

     

       141
       141
       +
               "-c",

     

       142
       142
       +
               help="Path to configuration file",

     

       143
       143
       +
           ),

     

       144
       144
       +
           output_file: Optional[Path] = typer.Option(

     

       145
       145
       +
               None,

     

       146
       146
       +
               "--output",

     

       147
       147
       +
               "-o",

     

       148
       148
       +
               help="Path to output unified links file (default: links.json in git store)",

     

       149
       149
       +
           ),

     

       150
       150
       +
           verbose: bool = typer.Option(

     

       151
       151
       +
               False,

     

       152
       152
       +
               "--verbose",

     

       153
       153
       +
               "-v",

     

       154
       154
       +
               help="Show detailed progress information",

     

       155
       155
       +
           ),

     

       156
       156
       +
       ) -> None:

     

       157
       157
       +
           """Extract and categorize all outbound links from blog entries.

     

       158
       158
       +
           

     

       159
       159
       +
           This command analyzes all blog entries to extract outbound links,

     

       160
       160
       +
           resolve them properly with respect to the feed's base URL, and

     

       161
       161
       +
           categorize them as internal, user, or unknown links.

     

       162
       162
       +
           

     

       163
       163
       +
           Creates a unified links.json file containing all link data.

     

       164
       164
       +
           """

     

       165
       165
       +
           try:

     

       166
       166
       +
               # Load configuration

     

       167
       167
       +
               config = load_config(config_file)

     

       168
       168
       +
       

     

       169
       169
       +
               # Initialize Git store

     

       170
       170
       +
               git_store = GitStore(config.git_store)

     

       171
       171
       +
               

     

       172
       172
       +
               # Build user domain mapping

     

       173
       173
       +
               if verbose:

     

       174
       174
       +
                   console.print("Building user domain mapping...")

     

       175
       175
       +
               

     

       176
       176
       +
               index = git_store._load_index()

     

       177
       177
       +
               user_domains = {}

     

       178
       178
       +
               

     

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

     

       180
       180
       +
                   domains = set()

     

       181
       181
       +
                   

     

       182
       182
       +
                   # Add domains from feeds

     

       183
       183
       +
                   for feed_url in user_metadata.feeds:

     

       184
       184
       +
                       domain = urlparse(feed_url).netloc.lower()

     

       185
       185
       +
                       if domain:

     

       186
       186
       +
                           domains.add(domain)

     

       187
       187
       +
                   

     

       188
       188
       +
                   # Add domain from homepage

     

       189
       189
       +
                   if user_metadata.homepage:

     

       190
       190
       +
                       domain = urlparse(str(user_metadata.homepage)).netloc.lower()

     

       191
       191
       +
                       if domain:

     

       192
       192
       +
                           domains.add(domain)

     

       193
       193
       +
                   

     

       194
       194
       +
                   user_domains[username] = domains

     

       195
       195
       +
               

     

       196
       196
       +
               if verbose:

     

       197
       197
       +
                   console.print(f"Found {len(user_domains)} users with {sum(len(d) for d in user_domains.values())} total domains")

     

       198
       198
       +
               

     

       199
       199
       +
               # Initialize components

     

       200
       200
       +
               link_extractor = LinkExtractor()

     

       201
       201
       +
               categorizer = LinkCategorizer(user_domains)

     

       202
       202
       +
               

     

       203
       203
       +
               # Get all users

     

       204
       204
       +
               users = list(index.users.keys())

     

       205
       205
       +
               

     

       206
       206
       +
               if not users:

     

       207
       207
       +
                   console.print("[yellow]No users found in Git store[/yellow]")

     

       208
       208
       +
                   raise typer.Exit(0)

     

       209
       209
       +
               

     

       210
       210
       +
               # Process all entries

     

       211
       211
       +
               all_links = []

     

       212
       212
       +
               link_categories = {"internal": [], "user": [], "unknown": []}

     

       213
       213
       +
               link_dict = {}  # Dictionary with link URL as key, maps to list of atom IDs

     

       214
       214
       +
               reverse_dict = {}  # Dictionary with atom ID as key, maps to list of URLs

     

       215
       215
       +
               

     

       216
       216
       +
               with Progress(

     

       217
       217
       +
                   SpinnerColumn(),

     

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

     

       219
       219
       +
                   BarColumn(),

     

       220
       220
       +
                   TaskProgressColumn(),

     

       221
       221
       +
                   console=console,

     

       222
       222
       +
               ) as progress:

     

       223
       223
       +
                   

     

       224
       224
       +
                   # Count total entries first

     

       225
       225
       +
                   counting_task = progress.add_task("Counting entries...", total=len(users))

     

       226
       226
       +
                   total_entries = 0

     

       227
       227
       +
                   

     

       228
       228
       +
                   for username in users:

     

       229
       229
       +
                       entries = git_store.list_entries(username)

     

       230
       230
       +
                       total_entries += len(entries)

     

       231
       231
       +
                       progress.advance(counting_task)

     

       232
       232
       +
                   

     

       233
       233
       +
                   progress.remove_task(counting_task)

     

       234
       234
       +
                   

     

       235
       235
       +
                   # Process entries

     

       236
       236
       +
                   processing_task = progress.add_task(

     

       237
       237
       +
                       f"Processing {total_entries} entries...", 

     

       238
       238
       +
                       total=total_entries

     

       239
       239
       +
                   )

     

       240
       240
       +
                   

     

       241
       241
       +
                   for username in users:

     

       242
       242
       +
                       entries = git_store.list_entries(username)

     

       243
       243
       +
                       user_metadata = index.users[username]

     

       244
       244
       +
                       

     

       245
       245
       +
                       # Get base URL for this user (use first feed URL)

     

       246
       246
       +
                       base_url = str(user_metadata.feeds[0]) if user_metadata.feeds else "https://example.com"

     

       247
       247
       +
                       

     

       248
       248
       +
                       for entry in entries:

     

       249
       249
       +
                           # Extract links from this entry

     

       250
       250
       +
                           entry_links = link_extractor.extract_links_from_entry(entry, username, base_url)

     

       251
       251
       +
                           

     

       252
       252
       +
                           # Track unique links per entry

     

       253
       253
       +
                           entry_urls_seen = set()

     

       254
       254
       +
                           

     

       255
       255
       +
                           # Categorize each link

     

       256
       256
       +
                           for link_data in entry_links:

     

       257
       257
       +
                               # Skip if we've already seen this URL in this entry

     

       258
       258
       +
                               if link_data.url in entry_urls_seen:

     

       259
       259
       +
                                   continue

     

       260
       260
       +
                               entry_urls_seen.add(link_data.url)

     

       261
       261
       +
                               

     

       262
       262
       +
                               category, target_username = categorizer.categorize_url(link_data.url, username)

     

       263
       263
       +
                               

     

       264
       264
       +
                               # Add to link dictionary (URL as key, maps to list of atom IDs)

     

       265
       265
       +
                               if link_data.url not in link_dict:

     

       266
       266
       +
                                   link_dict[link_data.url] = []

     

       267
       267
       +
                               if link_data.entry_id not in link_dict[link_data.url]:

     

       268
       268
       +
                                   link_dict[link_data.url].append(link_data.entry_id)

     

       269
       269
       +
                                   

     

       270
       270
       +
                                   # Also add to reverse mapping (atom ID -> list of URLs)

     

       271
       271
       +
                                   if link_data.entry_id not in reverse_dict:

     

       272
       272
       +
                                       reverse_dict[link_data.entry_id] = []

     

       273
       273
       +
                                   if link_data.url not in reverse_dict[link_data.entry_id]:

     

       274
       274
       +
                                       reverse_dict[link_data.entry_id].append(link_data.url)

     

       275
       275
       +
                               

     

       276
       276
       +
                               # Add category info to link data for categories tracking

     

       277
       277
       +
                               link_info = link_data.to_dict()

     

       278
       278
       +
                               link_info["category"] = category

     

       279
       279
       +
                               link_info["target_username"] = target_username

     

       280
       280
       +
                               

     

       281
       281
       +
                               all_links.append(link_info)

     

       282
       282
       +
                               link_categories[category].append(link_info)

     

       283
       283
       +
                           

     

       284
       284
       +
                           progress.advance(processing_task)

     

       285
       285
       +
                           

     

       286
       286
       +
                           if verbose and entry_links:

     

       287
       287
       +
                               console.print(f"  Found {len(entry_links)} links in {username}:{entry.title[:50]}...")

     

       288
       288
       +
               

     

       289
       289
       +
               # Determine output path

     

       290
       290
       +
               if output_file:

     

       291
       291
       +
                   output_path = output_file

     

       292
       292
       +
               else:

     

       293
       293
       +
                   output_path = config.git_store / "links.json"

     

       294
       294
       +
               

     

       295
       295
       +
               # Save all extracted links (not just filtered ones)

     

       296
       296
       +
               if verbose:

     

       297
       297
       +
                   console.print("Preparing output data...")

     

       298
       298
       +
               

     

       299
       299
       +
               # Build a set of all URLs that correspond to posts in the git database

     

       300
       300
       +
               registered_urls = set()

     

       301
       301
       +
               

     

       302
       302
       +
               # Get all entries from all users and build URL mappings

     

       303
       303
       +
               for username in users:

     

       304
       304
       +
                   entries = git_store.list_entries(username)

     

       305
       305
       +
                   user_metadata = index.users[username]

     

       306
       306
       +
                   

     

       307
       307
       +
                   for entry in entries:

     

       308
       308
       +
                       # Try to match entry URLs with extracted links

     

       309
       309
       +
                       if hasattr(entry, 'link') and entry.link:

     

       310
       310
       +
                           registered_urls.add(str(entry.link))

     

       311
       311
       +
                       

     

       312
       312
       +
                       # Also check entry alternate links if they exist

     

       313
       313
       +
                       if hasattr(entry, 'links') and entry.links:

     

       314
       314
       +
                           for link in entry.links:

     

       315
       315
       +
                               if hasattr(link, 'href') and link.href:

     

       316
       316
       +
                                   registered_urls.add(str(link.href))

     

       317
       317
       +
               

     

       318
       318
       +
               # Build unified structure with metadata

     

       319
       319
       +
               unified_links = {}

     

       320
       320
       +
               reverse_mapping = {}

     

       321
       321
       +
               

     

       322
       322
       +
               for url, entry_ids in link_dict.items():

     

       323
       323
       +
                   unified_links[url] = {

     

       324
       324
       +
                       "referencing_entries": entry_ids

     

       325
       325
       +
                   }

     

       326
       326
       +
                   

     

       327
       327
       +
                   # Find target username if this is a tracked post

     

       328
       328
       +
                   if url in registered_urls:

     

       329
       329
       +
                       for username in users:

     

       330
       330
       +
                           user_domains_set = {domain for domain in user_domains.get(username, [])}

     

       331
       331
       +
                           if any(domain in url for domain in user_domains_set):

     

       332
       332
       +
                               unified_links[url]["target_username"] = username

     

       333
       333
       +
                               break

     

       334
       334
       +
                   

     

       335
       335
       +
                   # Build reverse mapping

     

       336
       336
       +
                   for entry_id in entry_ids:

     

       337
       337
       +
                       if entry_id not in reverse_mapping:

     

       338
       338
       +
                           reverse_mapping[entry_id] = []

     

       339
       339
       +
                       if url not in reverse_mapping[entry_id]:

     

       340
       340
       +
                           reverse_mapping[entry_id].append(url)

     

       341
       341
       +
               

     

       342
       342
       +
               # Create unified output data

     

       343
       343
       +
               output_data = {

     

       344
       344
       +
                   "links": unified_links,

     

       345
       345
       +
                   "reverse_mapping": reverse_mapping,

     

       346
       346
       +
                   "user_domains": {k: list(v) for k, v in user_domains.items()}

     

       347
       347
       +
               }

     

       348
       348
       +
               

     

       349
       349
       +
               if verbose:

     

       350
       350
       +
                   console.print(f"Found {len(registered_urls)} registered post URLs")

     

       351
       351
       +
                   console.print(f"Found {len(link_dict)} total links, {sum(1 for link in unified_links.values() if 'target_username' in link)} tracked posts")

     

       352
       352
       +
               

     

       353
       353
       +
               # Save unified data

     

       354
       354
       +
               with open(output_path, "w") as f:

     

       355
       355
       +
                   json.dump(output_data, f, indent=2, default=str)

     

       356
       356
       +
               

     

       357
       357
       +
               # Show summary

     

       358
       358
       +
               if not get_tsv_mode():

     

       359
       359
       +
                   console.print("\n[green]✓ Links extraction completed successfully[/green]")

     

       360
       360
       +
               

     

       361
       361
       +
               # Create summary table or TSV output

     

       362
       362
       +
               if get_tsv_mode():

     

       363
       363
       +
                   print("Category\tCount\tDescription")

     

       364
       364
       +
                   print(f"Internal\t{len(link_categories['internal'])}\tLinks to same user's domain")

     

       365
       365
       +
                   print(f"User\t{len(link_categories['user'])}\tLinks to other tracked users")

     

       366
       366
       +
                   print(f"Unknown\t{len(link_categories['unknown'])}\tLinks to external sites")

     

       367
       367
       +
                   print(f"Total Extracted\t{len(all_links)}\tAll extracted links")

     

       368
       368
       +
                   print(f"Saved to Output\t{len(output_data['links'])}\tLinks saved to output file")

     

       369
       369
       +
                   print(f"Cross-references\t{sum(1 for link in unified_links.values() if 'target_username' in link)}\tLinks to registered posts only")

     

       370
       370
       +
               else:

     

       371
       371
       +
                   table = Table(title="Links Summary")

     

       372
       372
       +
                   table.add_column("Category", style="cyan")

     

       373
       373
       +
                   table.add_column("Count", style="green")

     

       374
       374
       +
                   table.add_column("Description", style="white")

     

       375
       375
       +
                   

     

       376
       376
       +
                   table.add_row("Internal", str(len(link_categories["internal"])), "Links to same user's domain")

     

       377
       377
       +
                   table.add_row("User", str(len(link_categories["user"])), "Links to other tracked users")

     

       378
       378
       +
                   table.add_row("Unknown", str(len(link_categories["unknown"])), "Links to external sites")

     

       379
       379
       +
                   table.add_row("Total Extracted", str(len(all_links)), "All extracted links")

     

       380
       380
       +
                   table.add_row("Saved to Output", str(len(output_data['links'])), "Links saved to output file")

     

       381
       381
       +
                   table.add_row("Cross-references", str(sum(1 for link in unified_links.values() if 'target_username' in link)), "Links to registered posts only")

     

       382
       382
       +
                   

     

       383
       383
       +
                   console.print(table)

     

       384
       384
       +
               

     

       385
       385
       +
               # Show user links if verbose

     

       386
       386
       +
               if verbose and link_categories["user"]:

     

       387
       387
       +
                   if get_tsv_mode():

     

       388
       388
       +
                       print("User Link Source\tUser Link Target\tLink Count")

     

       389
       389
       +
                       user_link_counts = {}

     

       390
       390
       +
                       

     

       391
       391
       +
                       for link in link_categories["user"]:

     

       392
       392
       +
                           key = f"{link['username']} -> {link['target_username']}"

     

       393
       393
       +
                           user_link_counts[key] = user_link_counts.get(key, 0) + 1

     

       394
       394
       +
                       

     

       395
       395
       +
                       for link_pair, count in sorted(user_link_counts.items(), key=lambda x: x[1], reverse=True)[:10]:

     

       396
       396
       +
                           source, target = link_pair.split(" -> ")

     

       397
       397
       +
                           print(f"{source}\t{target}\t{count}")

     

       398
       398
       +
                   else:

     

       399
       399
       +
                       console.print("\n[bold]User-to-user links:[/bold]")

     

       400
       400
       +
                       user_link_counts = {}

     

       401
       401
       +
                       

     

       402
       402
       +
                       for link in link_categories["user"]:

     

       403
       403
       +
                           key = f"{link['username']} -> {link['target_username']}"

     

       404
       404
       +
                           user_link_counts[key] = user_link_counts.get(key, 0) + 1

     

       405
       405
       +
                       

     

       406
       406
       +
                       for link_pair, count in sorted(user_link_counts.items(), key=lambda x: x[1], reverse=True)[:10]:

     

       407
       407
       +
                           console.print(f"  {link_pair}: {count} links")

     

       408
       408
       +
               

     

       409
       409
       +
               if not get_tsv_mode():

     

       410
       410
       +
                   console.print(f"\nUnified links data saved to: {output_path}")

     

       411
       411
       +
       

     

       412
       412
       +
           except Exception as e:

     

       413
       413
       +
               console.print(f"[red]Error extracting links: {e}[/red]")

     

       414
       414
       +
               if verbose:

     

       415
       415
       +
                   console.print_exception()

     

       416
       416
       +
               raise typer.Exit(1)

+64 -34

src/thicket/cli/commands/list_cmd.py

···

       1
       1
        
       """List command for thicket."""

     

       2
       2
        
       

     

       3
       3
       +
       import re

     

       3
       4
        
       from pathlib import Path

     

       4
       5
        
       from typing import Optional

     

       5
       6
        
       

     
···

       13
       14
        
           load_config,

     

       14
       15
        
           print_error,

     

       15
       16
        
           print_feeds_table,

     

       17
       17
       +
           print_feeds_table_from_git,

     

       16
       18
        
           print_info,

     

       17
       19
        
           print_users_table,

     

       20
       20
       +
           print_users_table_from_git,

     

       21
       21
       +
           print_entries_tsv,

     

       22
       22
       +
           get_tsv_mode,

     

       18
       23
        
       )

     

       19
       24
        
       

     

       20
       25
        
       

     
···

       32
       37
        
           ),

     

       33
       38
        
       ) -> None:

     

       34
       39
        
           """List users, feeds, or entries."""

     

       35
       35
       -
           

     

       40
       40
       +
       

     

       36
       41
        
           # Load configuration

     

       37
       42
        
           config = load_config(config_file)

     

       38
       38
       -
           

     

       43
       43
       +
       

     

       44
       44
       +
           # Initialize Git store

     

       45
       45
       +
           git_store = GitStore(config.git_store)

     

       46
       46
       +
       

     

       39
       47
        
           if what == "users":

     

       40
       40
       -
               list_users(config)

     

       48
       48
       +
               list_users(git_store)

     

       41
       49
        
           elif what == "feeds":

     

       42
       42
       -
               list_feeds(config, user)

     

       50
       50
       +
               list_feeds(git_store, user)

     

       43
       51
        
           elif what == "entries":

     

       44
       44
       -
               list_entries(config, user, limit)

     

       52
       52
       +
               list_entries(git_store, user, limit)

     

       45
       53
        
           else:

     

       46
       54
        
               print_error(f"Unknown list type: {what}")

     

       47
       55
        
               print_error("Use 'users', 'feeds', or 'entries'")

     

       48
       56
        
               raise typer.Exit(1)

     

       49
       57
        
       

     

       50
       58
        
       

     

       51
       51
       -
       def list_users(config) -> None:

     

       59
       59
       +
       def list_users(git_store: GitStore) -> None:

     

       52
       60
        
           """List all users."""

     

       53
       53
       -
           if not config.users:

     

       61
       61
       +
           index = git_store._load_index()

     

       62
       62
       +
           users = list(index.users.values())

     

       63
       63
       +
           

     

       64
       64
       +
           if not users:

     

       54
       65
        
               print_info("No users configured")

     

       55
       66
        
               return

     

       56
       56
       -
           

     

       57
       57
       -
           print_users_table(config)

     

       58
       67
        
       

     

       68
       68
       +
           print_users_table_from_git(users)

     

       59
       69
        
       

     

       60
       60
       -
       def list_feeds(config, username: Optional[str] = None) -> None:

     

       70
       70
       +
       

     

       71
       71
       +
       def list_feeds(git_store: GitStore, username: Optional[str] = None) -> None:

     

       61
       72
        
           """List feeds, optionally filtered by user."""

     

       62
       73
        
           if username:

     

       63
       63
       -
               user = config.find_user(username)

     

       74
       74
       +
               user = git_store.get_user(username)

     

       64
       75
        
               if not user:

     

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

     

       66
       77
        
                   raise typer.Exit(1)

     

       67
       67
       -
               

     

       78
       78
       +
       

     

       68
       79
        
               if not user.feeds:

     

       69
       80
        
                   print_info(f"No feeds configured for user '{username}'")

     

       70
       81
        
                   return

     

       71
       71
       -
           

     

       72
       72
       -
           print_feeds_table(config, username)

     

       82
       82
       +
       

     

       83
       83
       +
           print_feeds_table_from_git(git_store, username)

     

       73
       84
        
       

     

       74
       85
        
       

     

       75
       75
       -
       def list_entries(config, username: Optional[str] = None, limit: Optional[int] = None) -> None:

     

       86
       86
       +
       def list_entries(git_store: GitStore, username: Optional[str] = None, limit: Optional[int] = None) -> None:

     

       76
       87
        
           """List entries, optionally filtered by user."""

     

       77
       77
       -
           

     

       78
       78
       -
           # Initialize Git store

     

       79
       79
       -
           git_store = GitStore(config.git_store)

     

       80
       80
       -
           

     

       88
       88
       +
       

     

       81
       89
        
           if username:

     

       82
       90
        
               # List entries for specific user

     

       83
       83
       -
               user = config.find_user(username)

     

       91
       91
       +
               user = git_store.get_user(username)

     

       84
       92
        
               if not user:

     

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

     

       86
       94
        
                   raise typer.Exit(1)

     

       87
       87
       -
               

     

       95
       95
       +
       

     

       88
       96
        
               entries = git_store.list_entries(username, limit)

     

       89
       97
        
               if not entries:

     

       90
       98
        
                   print_info(f"No entries found for user '{username}'")

     

       91
       99
        
                   return

     

       92
       92
       -
               

     

       100
       100
       +
       

     

       93
       101
        
               print_entries_table([entries], [username])

     

       94
       94
       -
           

     

       102
       102
       +
       

     

       95
       103
        
           else:

     

       96
       104
        
               # List entries for all users

     

       97
       105
        
               all_entries = []

     

       98
       106
        
               all_usernames = []

     

       99
       99
       -
               

     

       100
       100
       -
               for user in config.users:

     

       107
       107
       +
       

     

       108
       108
       +
               index = git_store._load_index()

     

       109
       109
       +
               for user in index.users.values():

     

       101
       110
        
                   entries = git_store.list_entries(user.username, limit)

     

       102
       111
        
                   if entries:

     

       103
       112
        
                       all_entries.append(entries)

     

       104
       113
        
                       all_usernames.append(user.username)

     

       105
       105
       -
               

     

       114
       114
       +
       

     

       106
       115
        
               if not all_entries:

     

       107
       116
        
                   print_info("No entries found")

     

       108
       117
        
                   return

     

       109
       109
       -
               

     

       118
       118
       +
       

     

       110
       119
        
               print_entries_table(all_entries, all_usernames)

     

       111
       120
        
       

     

       112
       121
        
       

     

       122
       122
       +
       def _clean_html_content(content: Optional[str]) -> str:

     

       123
       123
       +
           """Clean HTML content for display in table."""

     

       124
       124
       +
           if not content:

     

       125
       125
       +
               return ""

     

       126
       126
       +
           

     

       127
       127
       +
           # Remove HTML tags

     

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

     

       129
       129
       +
           # Replace multiple whitespace with single space

     

       130
       130
       +
           clean_text = re.sub(r'\s+', ' ', clean_text)

     

       131
       131
       +
           # Strip and limit length

     

       132
       132
       +
           clean_text = clean_text.strip()

     

       133
       133
       +
           if len(clean_text) > 100:

     

       134
       134
       +
               clean_text = clean_text[:97] + "..."

     

       135
       135
       +
           

     

       136
       136
       +
           return clean_text

     

       137
       137
       +
       

     

       138
       138
       +
       

     

       113
       139
        
       def print_entries_table(entries_by_user: list[list], usernames: list[str]) -> None:

     

       114
       140
        
           """Print a table of entries."""

     

       141
       141
       +
           if get_tsv_mode():

     

       142
       142
       +
               print_entries_tsv(entries_by_user, usernames)

     

       143
       143
       +
               return

     

       144
       144
       +
               

     

       115
       145
        
           table = Table(title="Feed Entries")

     

       116
       146
        
           table.add_column("User", style="cyan", no_wrap=True)

     

       117
       147
        
           table.add_column("Title", style="bold")

     

       118
       148
        
           table.add_column("Updated", style="blue")

     

       119
       149
        
           table.add_column("URL", style="green")

     

       120
       120
       -
           

     

       150
       150
       +
       

     

       121
       151
        
           # Combine all entries with usernames

     

       122
       152
        
           all_entries = []

     

       123
       153
        
           for entries, username in zip(entries_by_user, usernames):

     

       124
       154
        
               for entry in entries:

     

       125
       155
        
                   all_entries.append((username, entry))

     

       126
       126
       -
           

     

       156
       156
       +
       

     

       127
       157
        
           # Sort by updated time (newest first)

     

       128
       158
        
           all_entries.sort(key=lambda x: x[1].updated, reverse=True)

     

       129
       129
       -
           

     

       159
       159
       +
       

     

       130
       160
        
           for username, entry in all_entries:

     

       131
       161
        
               # Format updated time

     

       132
       162
        
               updated_str = entry.updated.strftime("%Y-%m-%d %H:%M")

     

       133
       133
       -
               

     

       163
       163
       +
       

     

       134
       164
        
               # Truncate title if too long

     

       135
       165
        
               title = entry.title

     

       136
       166
        
               if len(title) > 50:

     

       137
       167
        
                   title = title[:47] + "..."

     

       138
       138
       -
               

     

       168
       168
       +
       

     

       139
       169
        
               table.add_row(

     

       140
       170
        
                   username,

     

       141
       171
        
                   title,

     

       142
       172
        
                   updated_str,

     

       143
       173
        
                   str(entry.link),

     

       144
       174
        
               )

     

       145
       145
       -
           

     

       146
       146
       -
           console.print(table)
     

       175
       175
       +
       

     

       176
       176
       +
           console.print(table)

+67 -113

src/thicket/cli/commands/sync.py

···

       5
       5
        
       from typing import Optional

     

       6
       6
        
       

     

       7
       7
        
       import typer

     

       8
       8
       -
       from rich.progress import track

     

       8
       8
       +
       from rich.progress import Progress, SpinnerColumn, TextColumn

     

       9
       9
        
       

     

       10
       10
       -
       from ...core.feed_parser import FeedParser

     

       11
       11
       -
       from ...core.git_store import GitStore

     

       12
       12
       -
       from ..main import app

     

       13
       13
       -
       from ..utils import (

     

       14
       14
       -
           create_progress,

     

       15
       15
       -
           load_config,

     

       16
       16
       -
           print_error,

     

       17
       17
       -
           print_info,

     

       18
       18
       -
           print_success,

     

       19
       19
       -
       )

     

       10
       10
       +
       from ..main import app, console, load_thicket

     

       20
       11
        
       

     

       21
       12
        
       

     

       22
       13
        
       @app.command()

     

       23
       14
        
       def sync(

     

       24
       24
       -
           all_users: bool = typer.Option(

     

       25
       25
       -
               False, "--all", "-a", help="Sync all users and feeds"

     

       26
       26
       -
           ),

     

       27
       15
        
           user: Optional[str] = typer.Option(

     

       28
       28
       -
               None, "--user", "-u", help="Sync specific user only"

     

       16
       16
       +
               None, "--user", "-u", help="Sync specific user only (default: all users)"

     

       29
       17
        
           ),

     

       30
       18
        
           config_file: Optional[Path] = typer.Option(

     

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

     

       19
       19
       +
               None, "--config", help="Configuration file path"

     

       32
       20
        
           ),

     

       33
       33
       -
           dry_run: bool = typer.Option(

     

       34
       34
       -
               False, "--dry-run", help="Show what would be synced without making changes"

     

       21
       21
       +
           commit: bool = typer.Option(

     

       22
       22
       +
               True, "--commit/--no-commit", help="Commit changes after sync"

     

       35
       23
        
           ),

     

       36
       24
        
       ) -> None:

     

       37
       25
        
           """Sync feeds and store entries in Git repository."""

     

       38
       26
        
           

     

       39
       39
       -
           # Load configuration

     

       40
       40
       -
           config = load_config(config_file)

     

       41
       41
       -
           

     

       42
       42
       -
           # Determine which users to sync

     

       43
       43
       -
           users_to_sync = []

     

       44
       44
       -
           if all_users:

     

       45
       45
       -
               users_to_sync = config.users

     

       46
       46
       -
           elif user:

     

       47
       47
       -
               user_config = config.find_user(user)

     

       48
       48
       -
               if not user_config:

     

       49
       49
       -
                   print_error(f"User '{user}' not found")

     

       50
       50
       -
                   raise typer.Exit(1)

     

       51
       51
       -
               users_to_sync = [user_config]

     

       52
       52
       -
           else:

     

       53
       53
       -
               print_error("Specify --all to sync all users or --user to sync a specific user")

     

       54
       54
       -
               raise typer.Exit(1)

     

       55
       55
       -
           

     

       56
       56
       -
           if not users_to_sync:

     

       57
       57
       -
               print_info("No users configured to sync")

     

       58
       58
       -
               return

     

       59
       59
       -
           

     

       60
       60
       -
           # Initialize Git store

     

       61
       61
       -
           git_store = GitStore(config.git_store)

     

       62
       62
       -
           

     

       63
       63
       -
           # Sync each user

     

       64
       64
       -
           total_new_entries = 0

     

       65
       65
       -
           total_updated_entries = 0

     

       66
       66
       -
           

     

       67
       67
       -
           for user_config in users_to_sync:

     

       68
       68
       -
               print_info(f"Syncing user: {user_config.username}")

     

       27
       27
       +
           try:

     

       28
       28
       +
               # Load Thicket instance

     

       29
       29
       +
               thicket = load_thicket(config_file)

     

       69
       30
        
               

     

       70
       70
       -
               user_new_entries = 0

     

       71
       71
       -
               user_updated_entries = 0

     

       31
       31
       +
               # Progress callback for tracking

     

       32
       32
       +
               current_task = None

     

       72
       33
        
               

     

       73
       73
       -
               # Sync each feed for the user

     

       74
       74
       -
               for feed_url in track(user_config.feeds, description=f"Syncing {user_config.username}'s feeds"):

     

       75
       75
       -
                   try:

     

       76
       76
       -
                       new_entries, updated_entries = asyncio.run(

     

       77
       77
       -
                           sync_feed(git_store, user_config.username, feed_url, dry_run)

     

       78
       78
       -
                       )

     

       79
       79
       -
                       user_new_entries += new_entries

     

       80
       80
       -
                       user_updated_entries += updated_entries

     

       81
       81
       -
                       

     

       82
       82
       -
                   except Exception as e:

     

       83
       83
       -
                       print_error(f"Failed to sync feed {feed_url}: {e}")

     

       84
       84
       -
                       continue

     

       34
       34
       +
               def progress_callback(message: str, current: int = 0, total: int = 0):

     

       35
       35
       +
                   nonlocal current_task

     

       36
       36
       +
                   current_task = message

     

       37
       37
       +
                   if total > 0:

     

       38
       38
       +
                       console.print(f"[blue]Progress:[/blue] {message} ({current}/{total})")

     

       39
       39
       +
                   else:

     

       40
       40
       +
                       console.print(f"[blue]Info:[/blue] {message}")

     

       85
       41
        
               

     

       86
       86
       -
               print_info(f"User {user_config.username}: {user_new_entries} new, {user_updated_entries} updated")

     

       87
       87
       -
               total_new_entries += user_new_entries

     

       88
       88
       -
               total_updated_entries += user_updated_entries

     

       89
       89
       -
           

     

       90
       90
       -
           # Commit changes if not dry run

     

       91
       91
       -
           if not dry_run and (total_new_entries > 0 or total_updated_entries > 0):

     

       92
       92
       -
               commit_message = f"Sync feeds: {total_new_entries} new entries, {total_updated_entries} updated"

     

       93
       93
       -
               git_store.commit_changes(commit_message)

     

       94
       94
       -
               print_success(f"Committed changes: {commit_message}")

     

       95
       95
       -
           

     

       96
       96
       -
           # Summary

     

       97
       97
       -
           if dry_run:

     

       98
       98
       -
               print_info(f"Dry run complete: would sync {total_new_entries} new entries, {total_updated_entries} updated")

     

       99
       99
       -
           else:

     

       100
       100
       -
               print_success(f"Sync complete: {total_new_entries} new entries, {total_updated_entries} updated")

     

       101
       101
       -
       

     

       102
       102
       -
       

     

       103
       103
       -
       async def sync_feed(git_store: GitStore, username: str, feed_url, dry_run: bool) -> tuple[int, int]:

     

       104
       104
       -
           """Sync a single feed for a user."""

     

       105
       105
       -
           

     

       106
       106
       -
           parser = FeedParser()

     

       107
       107
       -
           

     

       108
       108
       -
           try:

     

       109
       109
       -
               # Fetch and parse feed

     

       110
       110
       -
               content = await parser.fetch_feed(feed_url)

     

       111
       111
       -
               metadata, entries = parser.parse_feed(content, feed_url)

     

       42
       42
       +
               # Run sync with progress

     

       43
       43
       +
               with Progress(

     

       44
       44
       +
                   SpinnerColumn(),

     

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

     

       46
       46
       +
                   console=console,

     

       47
       47
       +
                   transient=True,

     

       48
       48
       +
               ) as progress:

     

       49
       49
       +
                   task = progress.add_task("Syncing feeds...", total=None)

     

       50
       50
       +
                   

     

       51
       51
       +
                   # Perform sync

     

       52
       52
       +
                   results = asyncio.run(thicket.sync_feeds(user, progress_callback))

     

       53
       53
       +
                   

     

       54
       54
       +
                   progress.remove_task(task)

     

       112
       55
        
               

     

       113
       113
       -
               new_entries = 0

     

       114
       114
       -
               updated_entries = 0

     

       56
       56
       +
               # Process results

     

       57
       57
       +
               total_new = 0

     

       58
       58
       +
               total_processed = 0

     

       59
       59
       +
               errors = []

     

       115
       60
        
               

     

       116
       116
       -
               # Process each entry

     

       117
       117
       -
               for entry in entries:

     

       118
       118
       -
                   try:

     

       119
       119
       -
                       # Check if entry already exists

     

       120
       120
       -
                       existing_entry = git_store.get_entry(username, entry.id)

     

       61
       61
       +
               if isinstance(results, dict):

     

       62
       62
       +
                   for username, user_results in results.items():

     

       63
       63
       +
                       if 'error' in user_results:

     

       64
       64
       +
                           errors.append(f"{username}: {user_results['error']}")

     

       65
       65
       +
                           continue

     

       121
       66
        
                       

     

       122
       122
       -
                       if existing_entry:

     

       123
       123
       -
                           # Check if entry has been updated

     

       124
       124
       -
                           if existing_entry.updated != entry.updated:

     

       125
       125
       -
                               if not dry_run:

     

       126
       126
       -
                                   git_store.store_entry(username, entry)

     

       127
       127
       -
                               updated_entries += 1

     

       128
       128
       -
                       else:

     

       129
       129
       -
                           # New entry

     

       130
       130
       -
                           if not dry_run:

     

       131
       131
       -
                               git_store.store_entry(username, entry)

     

       132
       132
       -
                           new_entries += 1

     

       133
       133
       -
                           

     

       134
       134
       -
                   except Exception as e:

     

       135
       135
       -
                       print_error(f"Failed to process entry {entry.id}: {e}")

     

       136
       136
       -
                       continue

     

       67
       67
       +
                       total_new += user_results.get('new_entries', 0)

     

       68
       68
       +
                       total_processed += user_results.get('feeds_processed', 0)

     

       69
       69
       +
                       

     

       70
       70
       +
                       console.print(f"[green]✓[/green] {username}: {user_results.get('new_entries', 0)} new entries from {user_results.get('feeds_processed', 0)} feeds")

     

       71
       71
       +
                       

     

       72
       72
       +
                       # Show any feed-specific errors

     

       73
       73
       +
                       for error in user_results.get('errors', []):

     

       74
       74
       +
                           console.print(f"  [yellow]Warning:[/yellow] {error}")

     

       75
       75
       +
               

     

       76
       76
       +
               # Show errors

     

       77
       77
       +
               for error in errors:

     

       78
       78
       +
                   console.print(f"[red]Error:[/red] {error}")

     

       137
       79
        
               

     

       138
       138
       -
               return new_entries, updated_entries

     

       80
       80
       +
               # Commit changes if requested

     

       81
       81
       +
               if commit and total_new > 0:

     

       82
       82
       +
                   commit_message = f"Sync feeds: {total_new} new entries from {total_processed} feeds"

     

       83
       83
       +
                   if thicket.commit_changes(commit_message):

     

       84
       84
       +
                       console.print(f"[green]✓[/green] Committed: {commit_message}")

     

       85
       85
       +
                   else:

     

       86
       86
       +
                       console.print("[red]✗[/red] Failed to commit changes")

     

       139
       87
        
               

     

       88
       88
       +
               # Summary

     

       89
       89
       +
               if total_new > 0:

     

       90
       90
       +
                   console.print(f"\n[green]Sync complete:[/green] {total_new} new entries processed")

     

       91
       91
       +
               else:

     

       92
       92
       +
                   console.print("\n[blue]Sync complete:[/blue] No new entries found")

     

       93
       93
       +
                   

     

       140
       94
        
           except Exception as e:

     

       141
       141
       -
               print_error(f"Failed to sync feed {feed_url}: {e}")

     

       142
       142
       -
               return 0, 0
     

       95
       95
       +
               console.print(f"[red]Error:[/red] {str(e)}")

     

       96
       96
       +
               raise typer.Exit(1)

+47 -5

src/thicket/cli/main.py

···

       1
       1
        
       """Main CLI application using Typer."""

     

       2
       2
        
       

     

       3
       3
       +
       from pathlib import Path

     

       4
       4
       +
       from typing import Optional

     

       5
       5
       +
       

     

       3
       6
        
       import typer

     

       4
       7
        
       from rich.console import Console

     

       5
       8
        
       

     

       6
       6
       -
       from .. import __version__

     

       9
       9
       +
       from .. import __version__, Thicket, ThicketConfig

     

       7
       10
        
       

     

       8
       11
        
       app = typer.Typer(

     

       9
       12
        
           name="thicket",

     
···

       14
       17
        
       

     

       15
       18
        
       console = Console()

     

       16
       19
        
       

     

       20
       20
       +
       # Global state for TSV output mode

     

       21
       21
       +
       tsv_mode = False

     

       22
       22
       +
       

     

       17
       23
        
       

     

       18
       24
        
       def version_callback(value: bool) -> None:

     

       19
       25
        
           """Show version and exit."""

     
···

       22
       28
        
               raise typer.Exit()

     

       23
       29
        
       

     

       24
       30
        
       

     

       31
       31
       +
       def load_thicket(config_path: Optional[Path] = None) -> Thicket:

     

       32
       32
       +
           """Load Thicket instance from configuration."""

     

       33
       33
       +
           if config_path and config_path.exists():

     

       34
       34
       +
               return Thicket.from_config_file(config_path)

     

       35
       35
       +
           

     

       36
       36
       +
           # Try default locations

     

       37
       37
       +
           default_paths = [

     

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

     

       39
       39
       +
               Path("thicket.yml"), 

     

       40
       40
       +
               Path("thicket.json"),

     

       41
       41
       +
               Path.home() / ".config" / "thicket" / "config.yaml",

     

       42
       42
       +
               Path.home() / ".thicket.yaml",

     

       43
       43
       +
           ]

     

       44
       44
       +
           

     

       45
       45
       +
           for path in default_paths:

     

       46
       46
       +
               if path.exists():

     

       47
       47
       +
                   return Thicket.from_config_file(path)

     

       48
       48
       +
           

     

       49
       49
       +
           # No config found

     

       50
       50
       +
           console.print("[red]Error:[/red] No configuration file found.")

     

       51
       51
       +
           console.print("Use [bold]thicket init[/bold] to create a new configuration or specify --config")

     

       52
       52
       +
           raise typer.Exit(1)

     

       53
       53
       +
       

     

       54
       54
       +
       

     

       55
       55
       +
       def get_config_path() -> Path:

     

       56
       56
       +
           """Get the default configuration path for new configs."""

     

       57
       57
       +
           config_dir = Path.home() / ".config" / "thicket"

     

       58
       58
       +
           config_dir.mkdir(parents=True, exist_ok=True)

     

       59
       59
       +
           return config_dir / "config.yaml"

     

       60
       60
       +
       

     

       61
       61
       +
       

     

       25
       62
        
       @app.callback()

     

       26
       63
        
       def main(

     

       27
       64
        
           version: bool = typer.Option(

     
···

       32
       69
        
               callback=version_callback,

     

       33
       70
        
               is_eager=True,

     

       34
       71
        
           ),

     

       72
       72
       +
           tsv: bool = typer.Option(

     

       73
       73
       +
               False,

     

       74
       74
       +
               "--tsv",

     

       75
       75
       +
               help="Output in tab-separated values format without truncation",

     

       76
       76
       +
           ),

     

       35
       77
        
       ) -> None:

     

       36
       78
        
           """Thicket: A CLI tool for persisting Atom/RSS feeds in Git repositories."""

     

       37
       37
       -
           pass

     

       79
       79
       +
           global tsv_mode

     

       80
       80
       +
           tsv_mode = tsv

     

       38
       81
        
       

     

       39
       82
        
       

     

       40
       83
        
       # Import commands to register them

     

       41
       41
       -
       from .commands import duplicates, init, add, sync, list_cmd  # noqa: E402

     

       42
       42
       -
       

     

       84
       84
       +
       from .commands import add, duplicates, generate, index_cmd, info_cmd, init, links_cmd, list_cmd, sync

     

       43
       85
        
       

     

       44
       86
        
       if __name__ == "__main__":

     

       45
       45
       -
           app()
     

       87
       87
       +
           app()

+163 -18

src/thicket/cli/utils.py

···

       8
       8
        
       from rich.progress import Progress, SpinnerColumn, TextColumn

     

       9
       9
        
       from rich.table import Table

     

       10
       10
        
       

     

       11
       11
       -
       from ..models import ThicketConfig

     

       11
       11
       +
       from ..models import ThicketConfig, UserMetadata

     

       12
       12
       +
       from ..core.git_store import GitStore

     

       12
       13
        
       

     

       13
       14
        
       console = Console()

     

       14
       15
        
       

     

       15
       16
        
       

     

       17
       17
       +
       def get_tsv_mode() -> bool:

     

       18
       18
       +
           """Get the global TSV mode setting."""

     

       19
       19
       +
           from .main import tsv_mode

     

       20
       20
       +
           return tsv_mode

     

       21
       21
       +
       

     

       22
       22
       +
       

     

       16
       23
        
       def load_config(config_path: Optional[Path] = None) -> ThicketConfig:

     

       17
       24
        
           """Load thicket configuration from file or environment."""

     

       18
       25
        
           if config_path and config_path.exists():

     

       19
       26
        
               import yaml

     

       20
       20
       -
               

     

       27
       27
       +
       

     

       21
       28
        
               with open(config_path) as f:

     

       22
       29
        
                   config_data = yaml.safe_load(f)

     

       23
       23
       -
               

     

       30
       30
       +
       

     

       24
       31
        
               # Convert to ThicketConfig

     

       25
       32
        
               return ThicketConfig(**config_data)

     

       26
       26
       -
           

     

       33
       33
       +
       

     

       27
       34
        
           # Try to load from default locations or environment

     

       28
       35
        
           try:

     

       36
       36
       +
               # First try to find thicket.yaml in current directory

     

       37
       37
       +
               default_config = Path("thicket.yaml")

     

       38
       38
       +
               if default_config.exists():

     

       39
       39
       +
                   import yaml

     

       40
       40
       +
                   with open(default_config) as f:

     

       41
       41
       +
                       config_data = yaml.safe_load(f)

     

       42
       42
       +
                   return ThicketConfig(**config_data)

     

       43
       43
       +
               

     

       44
       44
       +
               # Fall back to environment variables

     

       29
       45
        
               return ThicketConfig()

     

       30
       46
        
           except Exception as e:

     

       31
       47
        
               console.print(f"[red]Error loading configuration: {e}[/red]")

     

       32
       48
        
               console.print("[yellow]Run 'thicket init' to create a new configuration.[/yellow]")

     

       33
       33
       -
               raise typer.Exit(1)

     

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

     

       34
       50
        
       

     

       35
       51
        
       

     

       36
       52
        
       def save_config(config: ThicketConfig, config_path: Path) -> None:

     

       37
       53
        
           """Save thicket configuration to file."""

     

       38
       54
        
           import yaml

     

       39
       39
       -
           

     

       40
       40
       -
           config_data = config.model_dump(mode="json")

     

       41
       41
       -
           

     

       55
       55
       +
       

     

       56
       56
       +
           config_data = config.model_dump(mode="json", exclude_none=True)

     

       57
       57
       +
       

     

       42
       58
        
           # Convert Path objects to strings for YAML serialization

     

       43
       59
        
           config_data["git_store"] = str(config_data["git_store"])

     

       44
       60
        
           config_data["cache_dir"] = str(config_data["cache_dir"])

     

       45
       45
       -
           

     

       61
       61
       +
       

     

       46
       62
        
           with open(config_path, "w") as f:

     

       47
       63
        
               yaml.dump(config_data, f, default_flow_style=False, sort_keys=False)

     

       48
       64
        
       

     
···

       59
       75
        
       

     

       60
       76
        
       def print_users_table(config: ThicketConfig) -> None:

     

       61
       77
        
           """Print a table of users and their feeds."""

     

       78
       78
       +
           if get_tsv_mode():

     

       79
       79
       +
               print_users_tsv(config)

     

       80
       80
       +
               return

     

       81
       81
       +
               

     

       62
       82
        
           table = Table(title="Users and Feeds")

     

       63
       83
        
           table.add_column("Username", style="cyan", no_wrap=True)

     

       64
       84
        
           table.add_column("Display Name", style="magenta")

     

       65
       85
        
           table.add_column("Email", style="blue")

     

       66
       86
        
           table.add_column("Homepage", style="green")

     

       67
       87
        
           table.add_column("Feeds", style="yellow")

     

       68
       68
       -
           

     

       88
       88
       +
       

     

       69
       89
        
           for user in config.users:

     

       70
       90
        
               feeds_str = "\n".join(str(feed) for feed in user.feeds)

     

       71
       91
        
               table.add_row(

     
···

       75
       95
        
                   str(user.homepage) if user.homepage else "",

     

       76
       96
        
                   feeds_str,

     

       77
       97
        
               )

     

       78
       78
       -
           

     

       98
       98
       +
       

     

       79
       99
        
           console.print(table)

     

       80
       100
        
       

     

       81
       101
        
       

     

       82
       102
        
       def print_feeds_table(config: ThicketConfig, username: Optional[str] = None) -> None:

     

       83
       103
        
           """Print a table of feeds, optionally filtered by username."""

     

       104
       104
       +
           if get_tsv_mode():

     

       105
       105
       +
               print_feeds_tsv(config, username)

     

       106
       106
       +
               return

     

       107
       107
       +
               

     

       84
       108
        
           table = Table(title=f"Feeds{f' for {username}' if username else ''}")

     

       85
       109
        
           table.add_column("Username", style="cyan", no_wrap=True)

     

       86
       110
        
           table.add_column("Feed URL", style="blue")

     

       87
       111
        
           table.add_column("Status", style="green")

     

       88
       88
       -
           

     

       112
       112
       +
       

     

       89
       113
        
           users = [config.find_user(username)] if username else config.users

     

       90
       114
        
           users = [u for u in users if u is not None]

     

       91
       91
       -
           

     

       115
       115
       +
       

     

       92
       116
        
           for user in users:

     

       93
       117
        
               for feed in user.feeds:

     

       94
       118
        
                   table.add_row(

     
···

       96
       120
        
                       str(feed),

     

       97
       121
        
                       "Active",  # TODO: Add actual status checking

     

       98
       122
        
                   )

     

       99
       99
       -
           

     

       123
       123
       +
       

     

       100
       124
        
           console.print(table)

     

       101
       125
        
       

     

       102
       126
        
       

     
···

       107
       131
        
       

     

       108
       132
        
       def print_success(message: str) -> None:

     

       109
       133
        
           """Print a success message."""

     

       110
       110
       -
           console.print(f"[green][/green] {message}")

     

       134
       134
       +
           console.print(f"[green]✓[/green] {message}")

     

       111
       135
        
       

     

       112
       136
        
       

     

       113
       137
        
       def print_error(message: str) -> None:

     

       114
       138
        
           """Print an error message."""

     

       115
       115
       -
           console.print(f"[red][/red] {message}")

     

       139
       139
       +
           console.print(f"[red]✗[/red] {message}")

     

       116
       140
        
       

     

       117
       141
        
       

     

       118
       142
        
       def print_warning(message: str) -> None:

     

       119
       143
        
           """Print a warning message."""

     

       120
       120
       -
           console.print(f"[yellow]�[/yellow] {message}")

     

       144
       144
       +
           console.print(f"[yellow]⚠[/yellow] {message}")

     

       121
       145
        
       

     

       122
       146
        
       

     

       123
       147
        
       def print_info(message: str) -> None:

     

       124
       148
        
           """Print an info message."""

     

       125
       125
       -
           console.print(f"[blue]9[/blue] {message}")
     

       149
       149
       +
           console.print(f"[blue]ℹ[/blue] {message}")

     

       150
       150
       +
       

     

       151
       151
       +
       

     

       152
       152
       +
       def print_users_table_from_git(users: list[UserMetadata]) -> None:

     

       153
       153
       +
           """Print a table of users from git repository."""

     

       154
       154
       +
           if get_tsv_mode():

     

       155
       155
       +
               print_users_tsv_from_git(users)

     

       156
       156
       +
               return

     

       157
       157
       +
               

     

       158
       158
       +
           table = Table(title="Users and Feeds")

     

       159
       159
       +
           table.add_column("Username", style="cyan", no_wrap=True)

     

       160
       160
       +
           table.add_column("Display Name", style="magenta")

     

       161
       161
       +
           table.add_column("Email", style="blue")

     

       162
       162
       +
           table.add_column("Homepage", style="green")

     

       163
       163
       +
           table.add_column("Feeds", style="yellow")

     

       164
       164
       +
       

     

       165
       165
       +
           for user in users:

     

       166
       166
       +
               feeds_str = "\n".join(user.feeds)

     

       167
       167
       +
               table.add_row(

     

       168
       168
       +
                   user.username,

     

       169
       169
       +
                   user.display_name or "",

     

       170
       170
       +
                   user.email or "",

     

       171
       171
       +
                   user.homepage or "",

     

       172
       172
       +
                   feeds_str,

     

       173
       173
       +
               )

     

       174
       174
       +
       

     

       175
       175
       +
           console.print(table)

     

       176
       176
       +
       

     

       177
       177
       +
       

     

       178
       178
       +
       def print_feeds_table_from_git(git_store: GitStore, username: Optional[str] = None) -> None:

     

       179
       179
       +
           """Print a table of feeds from git repository."""

     

       180
       180
       +
           if get_tsv_mode():

     

       181
       181
       +
               print_feeds_tsv_from_git(git_store, username)

     

       182
       182
       +
               return

     

       183
       183
       +
               

     

       184
       184
       +
           table = Table(title=f"Feeds{f' for {username}' if username else ''}")

     

       185
       185
       +
           table.add_column("Username", style="cyan", no_wrap=True)

     

       186
       186
       +
           table.add_column("Feed URL", style="blue")

     

       187
       187
       +
           table.add_column("Status", style="green")

     

       188
       188
       +
       

     

       189
       189
       +
           if username:

     

       190
       190
       +
               user = git_store.get_user(username)

     

       191
       191
       +
               users = [user] if user else []

     

       192
       192
       +
           else:

     

       193
       193
       +
               index = git_store._load_index()

     

       194
       194
       +
               users = list(index.users.values())

     

       195
       195
       +
       

     

       196
       196
       +
           for user in users:

     

       197
       197
       +
               for feed in user.feeds:

     

       198
       198
       +
                   table.add_row(

     

       199
       199
       +
                       user.username,

     

       200
       200
       +
                       feed,

     

       201
       201
       +
                       "Active",  # TODO: Add actual status checking

     

       202
       202
       +
                   )

     

       203
       203
       +
       

     

       204
       204
       +
           console.print(table)

     

       205
       205
       +
       

     

       206
       206
       +
       

     

       207
       207
       +
       def print_users_tsv(config: ThicketConfig) -> None:

     

       208
       208
       +
           """Print users in TSV format."""

     

       209
       209
       +
           print("Username\tDisplay Name\tEmail\tHomepage\tFeeds")

     

       210
       210
       +
           for user in config.users:

     

       211
       211
       +
               feeds_str = ",".join(str(feed) for feed in user.feeds)

     

       212
       212
       +
               print(f"{user.username}\t{user.display_name or ''}\t{user.email or ''}\t{user.homepage or ''}\t{feeds_str}")

     

       213
       213
       +
       

     

       214
       214
       +
       

     

       215
       215
       +
       def print_users_tsv_from_git(users: list[UserMetadata]) -> None:

     

       216
       216
       +
           """Print users from git repository in TSV format."""

     

       217
       217
       +
           print("Username\tDisplay Name\tEmail\tHomepage\tFeeds")

     

       218
       218
       +
           for user in users:

     

       219
       219
       +
               feeds_str = ",".join(user.feeds)

     

       220
       220
       +
               print(f"{user.username}\t{user.display_name or ''}\t{user.email or ''}\t{user.homepage or ''}\t{feeds_str}")

     

       221
       221
       +
       

     

       222
       222
       +
       

     

       223
       223
       +
       def print_feeds_tsv(config: ThicketConfig, username: Optional[str] = None) -> None:

     

       224
       224
       +
           """Print feeds in TSV format."""

     

       225
       225
       +
           print("Username\tFeed URL\tStatus")

     

       226
       226
       +
           users = [config.find_user(username)] if username else config.users

     

       227
       227
       +
           users = [u for u in users if u is not None]

     

       228
       228
       +
           

     

       229
       229
       +
           for user in users:

     

       230
       230
       +
               for feed in user.feeds:

     

       231
       231
       +
                   print(f"{user.username}\t{feed}\tActive")

     

       232
       232
       +
       

     

       233
       233
       +
       

     

       234
       234
       +
       def print_feeds_tsv_from_git(git_store: GitStore, username: Optional[str] = None) -> None:

     

       235
       235
       +
           """Print feeds from git repository in TSV format."""

     

       236
       236
       +
           print("Username\tFeed URL\tStatus")

     

       237
       237
       +
           

     

       238
       238
       +
           if username:

     

       239
       239
       +
               user = git_store.get_user(username)

     

       240
       240
       +
               users = [user] if user else []

     

       241
       241
       +
           else:

     

       242
       242
       +
               index = git_store._load_index()

     

       243
       243
       +
               users = list(index.users.values())

     

       244
       244
       +
           

     

       245
       245
       +
           for user in users:

     

       246
       246
       +
               for feed in user.feeds:

     

       247
       247
       +
                   print(f"{user.username}\t{feed}\tActive")

     

       248
       248
       +
       

     

       249
       249
       +
       

     

       250
       250
       +
       def print_entries_tsv(entries_by_user: list[list], usernames: list[str]) -> None:

     

       251
       251
       +
           """Print entries in TSV format."""

     

       252
       252
       +
           print("User\tAtom ID\tTitle\tUpdated\tURL")

     

       253
       253
       +
           

     

       254
       254
       +
           # Combine all entries with usernames

     

       255
       255
       +
           all_entries = []

     

       256
       256
       +
           for entries, username in zip(entries_by_user, usernames):

     

       257
       257
       +
               for entry in entries:

     

       258
       258
       +
                   all_entries.append((username, entry))

     

       259
       259
       +
           

     

       260
       260
       +
           # Sort by updated time (newest first)

     

       261
       261
       +
           all_entries.sort(key=lambda x: x[1].updated, reverse=True)

     

       262
       262
       +
           

     

       263
       263
       +
           for username, entry in all_entries:

     

       264
       264
       +
               # Format updated time

     

       265
       265
       +
               updated_str = entry.updated.strftime("%Y-%m-%d %H:%M")

     

       266
       266
       +
               

     

       267
       267
       +
               # Escape tabs and newlines in title to preserve TSV format

     

       268
       268
       +
               title = entry.title.replace('\t', ' ').replace('\n', ' ').replace('\r', ' ')

     

       269
       269
       +
               

     

       270
       270
       +
               print(f"{username}\t{entry.id}\t{title}\t{updated_str}\t{entry.link}")

+1 -1

src/thicket/core/__init__.py

···

       3
       3
        
       from .feed_parser import FeedParser

     

       4
       4
        
       from .git_store import GitStore

     

       5
       5
        
       

     

       6
       6
       -
       __all__ = ["FeedParser", "GitStore"]
     

       6
       6
       +
       __all__ = ["FeedParser", "GitStore"]

+29 -29

src/thicket/core/feed_parser.py

···

       2
       2
        
       

     

       3
       3
        
       from datetime import datetime

     

       4
       4
        
       from typing import Optional

     

       5
       5
       -
       from urllib.parse import urljoin, urlparse

     

       5
       5
       +
       from urllib.parse import urlparse

     

       6
       6
        
       

     

       7
       7
        
       import bleach

     

       8
       8
        
       import feedparser

     
···

       46
       46
        
           def parse_feed(self, content: str, source_url: Optional[HttpUrl] = None) -> tuple[FeedMetadata, list[AtomEntry]]:

     

       47
       47
        
               """Parse feed content and return metadata and entries."""

     

       48
       48
        
               parsed = feedparser.parse(content)

     

       49
       49
       -
               

     

       49
       49
       +
       

     

       50
       50
        
               if parsed.bozo and parsed.bozo_exception:

     

       51
       51
        
                   # Try to continue with potentially malformed feed

     

       52
       52
        
                   pass

     

       53
       53
       -
               

     

       53
       53
       +
       

     

       54
       54
        
               # Extract feed metadata

     

       55
       55
        
               feed_meta = self._extract_feed_metadata(parsed.feed)

     

       56
       56
       -
               

     

       56
       56
       +
       

     

       57
       57
        
               # Extract and normalize entries

     

       58
       58
        
               entries = []

     

       59
       59
        
               for entry in parsed.entries:

     
···

       64
       64
        
                       # Log error but continue processing other entries

     

       65
       65
        
                       print(f"Error processing entry {getattr(entry, 'id', 'unknown')}: {e}")

     

       66
       66
        
                       continue

     

       67
       67
       -
               

     

       67
       67
       +
       

     

       68
       68
        
               return feed_meta, entries

     

       69
       69
        
       

     

       70
       70
        
           def _extract_feed_metadata(self, feed: feedparser.FeedParserDict) -> FeedMetadata:

     
···

       73
       73
        
               author_name = None

     

       74
       74
        
               author_email = None

     

       75
       75
        
               author_uri = None

     

       76
       76
       -
               

     

       76
       76
       +
       

     

       77
       77
        
               if hasattr(feed, 'author_detail'):

     

       78
       78
        
                   author_name = feed.author_detail.get('name')

     

       79
       79
        
                   author_email = feed.author_detail.get('email')

     

       80
       80
        
                   author_uri = feed.author_detail.get('href')

     

       81
       81
        
               elif hasattr(feed, 'author'):

     

       82
       82
        
                   author_name = feed.author

     

       83
       83
       -
               

     

       83
       83
       +
       

     

       84
       84
        
               # Parse managing editor for RSS feeds

     

       85
       85
        
               if not author_email and hasattr(feed, 'managingEditor'):

     

       86
       86
        
                   author_email = feed.managingEditor

     

       87
       87
       -
               

     

       87
       87
       +
       

     

       88
       88
        
               # Parse feed link

     

       89
       89
        
               feed_link = None

     

       90
       90
        
               if hasattr(feed, 'link'):

     
···

       92
       92
        
                       feed_link = HttpUrl(feed.link)

     

       93
       93
        
                   except ValidationError:

     

       94
       94
        
                       pass

     

       95
       95
       -
               

     

       95
       95
       +
       

     

       96
       96
        
               # Parse image/icon/logo

     

       97
       97
        
               logo = None

     

       98
       98
        
               icon = None

     

       99
       99
        
               image_url = None

     

       100
       100
       -
               

     

       100
       100
       +
       

     

       101
       101
        
               if hasattr(feed, 'image'):

     

       102
       102
        
                   try:

     

       103
       103
        
                       image_url = HttpUrl(feed.image.get('href', feed.image.get('url', '')))

     

       104
       104
        
                   except (ValidationError, AttributeError):

     

       105
       105
        
                       pass

     

       106
       106
       -
               

     

       106
       106
       +
       

     

       107
       107
        
               if hasattr(feed, 'icon'):

     

       108
       108
        
                   try:

     

       109
       109
        
                       icon = HttpUrl(feed.icon)

     

       110
       110
        
                   except ValidationError:

     

       111
       111
        
                       pass

     

       112
       112
       -
               

     

       112
       112
       +
       

     

       113
       113
        
               if hasattr(feed, 'logo'):

     

       114
       114
        
                   try:

     

       115
       115
        
                       logo = HttpUrl(feed.logo)

     

       116
       116
        
                   except ValidationError:

     

       117
       117
        
                       pass

     

       118
       118
       -
               

     

       118
       118
       +
       

     

       119
       119
        
               return FeedMetadata(

     

       120
       120
        
                   title=getattr(feed, 'title', None),

     

       121
       121
        
                   author_name=author_name,

     
···

       133
       133
        
               # Parse timestamps

     

       134
       134
        
               updated = self._parse_timestamp(entry.get('updated_parsed') or entry.get('published_parsed'))

     

       135
       135
        
               published = self._parse_timestamp(entry.get('published_parsed'))

     

       136
       136
       -
               

     

       136
       136
       +
       

     

       137
       137
        
               # Parse content

     

       138
       138
        
               content = self._extract_content(entry)

     

       139
       139
        
               content_type = self._extract_content_type(entry)

     

       140
       140
       -
               

     

       140
       140
       +
       

     

       141
       141
        
               # Parse author

     

       142
       142
        
               author = self._extract_author(entry)

     

       143
       143
       -
               

     

       143
       143
       +
       

     

       144
       144
        
               # Parse categories/tags

     

       145
       145
        
               categories = []

     

       146
       146
        
               if hasattr(entry, 'tags'):

     

       147
       147
        
                   categories = [tag.get('term', '') for tag in entry.tags if tag.get('term')]

     

       148
       148
       -
               

     

       148
       148
       +
       

     

       149
       149
        
               # Sanitize HTML content

     

       150
       150
        
               if content:

     

       151
       151
        
                   content = self._sanitize_html(content)

     

       152
       152
       -
               

     

       152
       152
       +
       

     

       153
       153
        
               summary = entry.get('summary', '')

     

       154
       154
        
               if summary:

     

       155
       155
        
                   summary = self._sanitize_html(summary)

     

       156
       156
       -
               

     

       156
       156
       +
       

     

       157
       157
        
               return AtomEntry(

     

       158
       158
        
                   id=entry.get('id', entry.get('link', '')),

     

       159
       159
        
                   title=entry.get('title', ''),

     
···

       187
       187
        
                           return content_item.get('value', '')

     

       188
       188
        
                   # Fallback to first content item

     

       189
       189
        
                   return entry.content[0].get('value', '')

     

       190
       190
       -
               

     

       190
       190
       +
       

     

       191
       191
        
               # Fallback to summary

     

       192
       192
        
               return entry.get('summary', '')

     

       193
       193
        
       

     
···

       207
       207
        
           def _extract_author(self, entry: feedparser.FeedParserDict) -> Optional[dict]:

     

       208
       208
        
               """Extract author information from entry."""

     

       209
       209
        
               author = {}

     

       210
       210
       -
               

     

       210
       210
       +
       

     

       211
       211
        
               if hasattr(entry, 'author_detail'):

     

       212
       212
        
                   author.update({

     

       213
       213
        
                       'name': entry.author_detail.get('name'),

     
···

       216
       216
        
                   })

     

       217
       217
        
               elif hasattr(entry, 'author'):

     

       218
       218
        
                   author['name'] = entry.author

     

       219
       219
       -
               

     

       219
       219
       +
       

     

       220
       220
        
               return author if author else None

     

       221
       221
        
       

     

       222
       222
        
           def _sanitize_html(self, html: str) -> str:

     
···

       232
       232
        
               """Sanitize entry ID to be a safe filename."""

     

       233
       233
        
               # Parse URL to get meaningful parts

     

       234
       234
        
               parsed = urlparse(entry_id)

     

       235
       235
       -
               

     

       235
       235
       +
       

     

       236
       236
        
               # Start with the path component

     

       237
       237
        
               if parsed.path:

     

       238
       238
        
                   # Remove leading slash and replace problematic characters

     
···

       240
       240
        
               else:

     

       241
       241
        
                   # Use the entire ID as fallback

     

       242
       242
        
                   safe_id = entry_id

     

       243
       243
       -
               

     

       243
       243
       +
       

     

       244
       244
        
               # Replace problematic characters

     

       245
       245
        
               safe_chars = []

     

       246
       246
        
               for char in safe_id:

     
···

       248
       248
        
                       safe_chars.append(char)

     

       249
       249
        
                   else:

     

       250
       250
        
                       safe_chars.append('_')

     

       251
       251
       -
               

     

       251
       251
       +
       

     

       252
       252
        
               safe_id = ''.join(safe_chars)

     

       253
       253
       -
               

     

       253
       253
       +
       

     

       254
       254
        
               # Ensure it's not too long (max 200 chars)

     

       255
       255
        
               if len(safe_id) > 200:

     

       256
       256
        
                   safe_id = safe_id[:200]

     

       257
       257
       -
               

     

       257
       257
       +
       

     

       258
       258
        
               # Ensure it's not empty

     

       259
       259
        
               if not safe_id:

     

       260
       260
        
                   safe_id = "entry"

     

       261
       261
       -
               

     

       262
       262
       -
               return safe_id
     

       261
       261
       +
       

     

       262
       262
       +
               return safe_id

+55 -66

src/thicket/core/git_store.py

···

       24
       24
        
               """Ensure the Git repository exists and is initialized."""

     

       25
       25
        
               if not self.repo_path.exists():

     

       26
       26
        
                   self.repo_path.mkdir(parents=True, exist_ok=True)

     

       27
       27
       -
               

     

       27
       27
       +
       

     

       28
       28
        
               try:

     

       29
       29
        
                   self.repo = Repo(self.repo_path)

     

       30
       30
        
               except git.InvalidGitRepositoryError:

     
···

       40
       40
        
                   last_updated=datetime.now(),

     

       41
       41
        
               )

     

       42
       42
        
               self._save_index(index)

     

       43
       43
       -
               

     

       43
       43
       +
       

     

       44
       44
        
               # Create duplicates.json

     

       45
       45
        
               duplicates = DuplicateMap()

     

       46
       46
        
               self._save_duplicates(duplicates)

     

       47
       47
       -
               

     

       47
       47
       +
       

     

       48
       48
        
               # Create initial commit

     

       49
       49
        
               self.repo.index.add(["index.json", "duplicates.json"])

     

       50
       50
        
               self.repo.index.commit("Initial thicket repository structure")

     
···

       53
       53
        
               """Save the index to index.json."""

     

       54
       54
        
               index_path = self.repo_path / "index.json"

     

       55
       55
        
               with open(index_path, "w") as f:

     

       56
       56
       -
                   json.dump(index.model_dump(mode="json"), f, indent=2, default=str)

     

       56
       56
       +
                   json.dump(index.model_dump(mode="json", exclude_none=True), f, indent=2, default=str)

     

       57
       57
        
       

     

       58
       58
        
           def _load_index(self) -> GitStoreIndex:

     

       59
       59
        
               """Load the index from index.json."""

     
···

       63
       63
        
                       created=datetime.now(),

     

       64
       64
        
                       last_updated=datetime.now(),

     

       65
       65
        
                   )

     

       66
       66
       -
               

     

       66
       66
       +
       

     

       67
       67
        
               with open(index_path) as f:

     

       68
       68
        
                   data = json.load(f)

     

       69
       69
       -
               

     

       69
       69
       +
       

     

       70
       70
        
               return GitStoreIndex(**data)

     

       71
       71
        
       

     

       72
       72
        
           def _save_duplicates(self, duplicates: DuplicateMap) -> None:

     

       73
       73
        
               """Save duplicates map to duplicates.json."""

     

       74
       74
        
               duplicates_path = self.repo_path / "duplicates.json"

     

       75
       75
        
               with open(duplicates_path, "w") as f:

     

       76
       76
       -
                   json.dump(duplicates.model_dump(), f, indent=2)

     

       76
       76
       +
                   json.dump(duplicates.model_dump(exclude_none=True), f, indent=2)

     

       77
       77
        
       

     

       78
       78
        
           def _load_duplicates(self) -> DuplicateMap:

     

       79
       79
        
               """Load duplicates map from duplicates.json."""

     

       80
       80
        
               duplicates_path = self.repo_path / "duplicates.json"

     

       81
       81
        
               if not duplicates_path.exists():

     

       82
       82
        
                   return DuplicateMap()

     

       83
       83
       -
               

     

       83
       83
       +
       

     

       84
       84
        
               with open(duplicates_path) as f:

     

       85
       85
        
                   data = json.load(f)

     

       86
       86
       -
               

     

       86
       86
       +
       

     

       87
       87
        
               return DuplicateMap(**data)

     

       88
       88
        
       

     

       89
       89
        
           def add_user(self, username: str, display_name: Optional[str] = None,

     
···

       91
       91
        
                        icon: Optional[str] = None, feeds: Optional[list[str]] = None) -> UserMetadata:

     

       92
       92
        
               """Add a new user to the Git store."""

     

       93
       93
        
               index = self._load_index()

     

       94
       94
       -
               

     

       94
       94
       +
       

     

       95
       95
        
               # Create user directory

     

       96
       96
        
               user_dir = self.repo_path / username

     

       97
       97
        
               user_dir.mkdir(exist_ok=True)

     

       98
       98
       -
               

     

       98
       98
       +
       

     

       99
       99
        
               # Create user metadata

     

       100
       100
        
               user_metadata = UserMetadata(

     

       101
       101
        
                   username=username,

     
···

       108
       108
        
                   created=datetime.now(),

     

       109
       109
        
                   last_updated=datetime.now(),

     

       110
       110
        
               )

     

       111
       111
       -
               

     

       112
       112
       -
               # Save user metadata

     

       113
       113
       -
               metadata_path = user_dir / "metadata.json"

     

       114
       114
       -
               with open(metadata_path, "w") as f:

     

       115
       115
       -
                   json.dump(user_metadata.model_dump(mode="json"), f, indent=2, default=str)

     

       116
       116
       -
               

     

       111
       111
       +
       

     

       112
       112
       +
       

     

       117
       113
        
               # Update index

     

       118
       114
        
               index.add_user(user_metadata)

     

       119
       115
        
               self._save_index(index)

     

       120
       120
       -
               

     

       116
       116
       +
       

     

       121
       117
        
               return user_metadata

     

       122
       118
        
       

     

       123
       119
        
           def get_user(self, username: str) -> Optional[UserMetadata]:

     
···

       129
       125
        
               """Update user metadata."""

     

       130
       126
        
               index = self._load_index()

     

       131
       127
        
               user = index.get_user(username)

     

       132
       132
       -
               

     

       128
       128
       +
       

     

       133
       129
        
               if not user:

     

       134
       130
        
                   return False

     

       135
       135
       -
               

     

       131
       131
       +
       

     

       136
       132
        
               # Update user metadata

     

       137
       133
        
               for key, value in kwargs.items():

     

       138
       134
        
                   if hasattr(user, key) and value is not None:

     

       139
       135
        
                       setattr(user, key, value)

     

       140
       140
       -
               

     

       136
       136
       +
       

     

       141
       137
        
               user.update_timestamp()

     

       142
       142
       -
               

     

       143
       143
       -
               # Save user metadata

     

       144
       144
       -
               user_dir = self.repo_path / user.directory

     

       145
       145
       -
               metadata_path = user_dir / "metadata.json"

     

       146
       146
       -
               with open(metadata_path, "w") as f:

     

       147
       147
       -
                   json.dump(user.model_dump(mode="json"), f, indent=2, default=str)

     

       148
       148
       -
               

     

       138
       138
       +
       

     

       139
       139
       +
       

     

       149
       140
        
               # Update index

     

       150
       141
        
               index.add_user(user)

     

       151
       142
        
               self._save_index(index)

     

       152
       152
       -
               

     

       143
       143
       +
       

     

       153
       144
        
               return True

     

       154
       145
        
       

     

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

     
···

       157
       148
        
               user = self.get_user(username)

     

       158
       149
        
               if not user:

     

       159
       150
        
                   return False

     

       160
       160
       -
               

     

       151
       151
       +
       

     

       161
       152
        
               # Sanitize entry ID for filename

     

       162
       153
        
               from .feed_parser import FeedParser

     

       163
       154
        
               parser = FeedParser()

     

       164
       155
        
               safe_id = parser.sanitize_entry_id(entry.id)

     

       165
       165
       -
               

     

       156
       156
       +
       

     

       166
       157
        
               # Create entry file

     

       167
       158
        
               user_dir = self.repo_path / user.directory

     

       168
       159
        
               entry_path = user_dir / f"{safe_id}.json"

     

       169
       169
       -
               

     

       160
       160
       +
       

     

       170
       161
        
               # Check if entry already exists

     

       171
       162
        
               entry_exists = entry_path.exists()

     

       172
       172
       -
               

     

       163
       163
       +
       

     

       173
       164
        
               # Save entry

     

       174
       165
        
               with open(entry_path, "w") as f:

     

       175
       175
       -
                   json.dump(entry.model_dump(mode="json"), f, indent=2, default=str)

     

       176
       176
       -
               

     

       166
       166
       +
                   json.dump(entry.model_dump(mode="json", exclude_none=True), f, indent=2, default=str)

     

       167
       167
       +
       

     

       177
       168
        
               # Update user metadata if new entry

     

       178
       169
        
               if not entry_exists:

     

       179
       179
       -
                   user.increment_entry_count()

     

       180
       180
       -
                   self.update_user(username, entry_count=user.entry_count)

     

       181
       181
       -
               

     

       170
       170
       +
                   index = self._load_index()

     

       171
       171
       +
                   index.update_entry_count(username, 1)

     

       172
       172
       +
                   self._save_index(index)

     

       173
       173
       +
       

     

       182
       174
        
               return True

     

       183
       175
        
       

     

       184
       176
        
           def get_entry(self, username: str, entry_id: str) -> Optional[AtomEntry]:

     
···

       186
       178
        
               user = self.get_user(username)

     

       187
       179
        
               if not user:

     

       188
       180
        
                   return None

     

       189
       189
       -
               

     

       181
       181
       +
       

     

       190
       182
        
               # Sanitize entry ID

     

       191
       183
        
               from .feed_parser import FeedParser

     

       192
       184
        
               parser = FeedParser()

     

       193
       185
        
               safe_id = parser.sanitize_entry_id(entry_id)

     

       194
       194
       -
               

     

       186
       186
       +
       

     

       195
       187
        
               entry_path = self.repo_path / user.directory / f"{safe_id}.json"

     

       196
       188
        
               if not entry_path.exists():

     

       197
       189
        
                   return None

     

       198
       198
       -
               

     

       190
       190
       +
       

     

       199
       191
        
               with open(entry_path) as f:

     

       200
       192
        
                   data = json.load(f)

     

       201
       201
       -
               

     

       193
       193
       +
       

     

       202
       194
        
               return AtomEntry(**data)

     

       203
       195
        
       

     

       204
       196
        
           def list_entries(self, username: str, limit: Optional[int] = None) -> list[AtomEntry]:

     
···

       206
       198
        
               user = self.get_user(username)

     

       207
       199
        
               if not user:

     

       208
       200
        
                   return []

     

       209
       209
       -
               

     

       201
       201
       +
       

     

       210
       202
        
               user_dir = self.repo_path / user.directory

     

       211
       203
        
               if not user_dir.exists():

     

       212
       204
        
                   return []

     

       213
       213
       -
               

     

       205
       205
       +
       

     

       214
       206
        
               entries = []

     

       215
       207
        
               entry_files = sorted(user_dir.glob("*.json"), key=lambda p: p.stat().st_mtime, reverse=True)

     

       216
       216
       -
               

     

       217
       217
       -
               # Filter out metadata.json

     

       218
       218
       -
               entry_files = [f for f in entry_files if f.name != "metadata.json"]

     

       219
       219
       -
               

     

       208
       208
       +
       

     

       209
       209
       +
       

     

       220
       210
        
               if limit:

     

       221
       211
        
                   entry_files = entry_files[:limit]

     

       222
       222
       -
               

     

       212
       212
       +
       

     

       223
       213
        
               for entry_file in entry_files:

     

       224
       214
        
                   try:

     

       225
       215
        
                       with open(entry_file) as f:

     
···

       228
       218
        
                   except Exception:

     

       229
       219
        
                       # Skip invalid entries

     

       230
       220
        
                       continue

     

       231
       231
       -
               

     

       221
       221
       +
       

     

       232
       222
        
               return entries

     

       233
       223
        
       

     

       234
       224
        
           def get_duplicates(self) -> DuplicateMap:

     
···

       252
       242
        
               """Commit all changes to the Git repository."""

     

       253
       243
        
               if not self.repo:

     

       254
       244
        
                   return

     

       255
       255
       -
               

     

       245
       245
       +
       

     

       256
       246
        
               # Add all changes

     

       257
       247
        
               self.repo.git.add(A=True)

     

       258
       258
       -
               

     

       248
       248
       +
       

     

       259
       249
        
               # Check if there are changes to commit

     

       260
       250
        
               if self.repo.index.diff("HEAD"):

     

       261
       251
        
                   self.repo.index.commit(message)

     
···

       264
       254
        
               """Get statistics about the Git store."""

     

       265
       255
        
               index = self._load_index()

     

       266
       256
        
               duplicates = self._load_duplicates()

     

       267
       267
       -
               

     

       257
       257
       +
       

     

       268
       258
        
               return {

     

       269
       259
        
                   "total_users": len(index.users),

     

       270
       260
        
                   "total_entries": index.total_entries,

     
···

       277
       267
        
                             limit: Optional[int] = None) -> list[tuple[str, AtomEntry]]:

     

       278
       268
        
               """Search entries by content."""

     

       279
       269
        
               results = []

     

       280
       280
       -
               

     

       270
       270
       +
       

     

       281
       271
        
               # Get users to search

     

       282
       272
        
               index = self._load_index()

     

       283
       273
        
               users = [index.get_user(username)] if username else list(index.users.values())

     

       284
       274
        
               users = [u for u in users if u is not None]

     

       285
       285
       -
               

     

       275
       275
       +
       

     

       286
       276
        
               for user in users:

     

       287
       277
        
                   user_dir = self.repo_path / user.directory

     

       288
       278
        
                   if not user_dir.exists():

     

       289
       279
        
                       continue

     

       290
       290
       -
                   

     

       280
       280
       +
       

     

       291
       281
        
                   entry_files = user_dir.glob("*.json")

     

       292
       292
       -
                   entry_files = [f for f in entry_files if f.name != "metadata.json"]

     

       293
       293
       -
                   

     

       282
       282
       +
       

     

       294
       283
        
                   for entry_file in entry_files:

     

       295
       284
        
                       try:

     

       296
       285
        
                           with open(entry_file) as f:

     

       297
       286
        
                               data = json.load(f)

     

       298
       298
       -
                           

     

       287
       287
       +
       

     

       299
       288
        
                           entry = AtomEntry(**data)

     

       300
       300
       -
                           

     

       289
       289
       +
       

     

       301
       290
        
                           # Simple text search in title, summary, and content

     

       302
       291
        
                           searchable_text = " ".join(filter(None, [

     

       303
       292
        
                               entry.title,

     

       304
       293
        
                               entry.summary or "",

     

       305
       294
        
                               entry.content or "",

     

       306
       295
        
                           ])).lower()

     

       307
       307
       -
                           

     

       296
       296
       +
       

     

       308
       297
        
                           if query.lower() in searchable_text:

     

       309
       298
        
                               results.append((user.username, entry))

     

       310
       310
       -
                               

     

       299
       299
       +
       

     

       311
       300
        
                               if limit and len(results) >= limit:

     

       312
       301
        
                                   return results

     

       313
       313
       -
                           

     

       302
       302
       +
       

     

       314
       303
        
                       except Exception:

     

       315
       304
        
                           # Skip invalid entries

     

       316
       305
        
                           continue

     

       317
       317
       -
               

     

       306
       306
       +
       

     

       318
       307
        
               # Sort by updated time (newest first)

     

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

     

       320
       320
       -
               

     

       321
       321
       -
               return results[:limit] if limit else results
     

       309
       309
       +
       

     

       310
       310
       +
               return results[:limit] if limit else results

+438

src/thicket/core/reference_parser.py

···

       1
       1
       +
       """Reference detection and parsing for blog entries."""

     

       2
       2
       +
       

     

       3
       3
       +
       import re

     

       4
       4
       +
       from typing import Optional

     

       5
       5
       +
       from urllib.parse import urlparse

     

       6
       6
       +
       

     

       7
       7
       +
       from ..models import AtomEntry

     

       8
       8
       +
       

     

       9
       9
       +
       

     

       10
       10
       +
       class BlogReference:

     

       11
       11
       +
           """Represents a reference from one blog entry to another."""

     

       12
       12
       +
       

     

       13
       13
       +
           def __init__(

     

       14
       14
       +
               self,

     

       15
       15
       +
               source_entry_id: str,

     

       16
       16
       +
               source_username: str,

     

       17
       17
       +
               target_url: str,

     

       18
       18
       +
               target_username: Optional[str] = None,

     

       19
       19
       +
               target_entry_id: Optional[str] = None,

     

       20
       20
       +
           ):

     

       21
       21
       +
               self.source_entry_id = source_entry_id

     

       22
       22
       +
               self.source_username = source_username

     

       23
       23
       +
               self.target_url = target_url

     

       24
       24
       +
               self.target_username = target_username

     

       25
       25
       +
               self.target_entry_id = target_entry_id

     

       26
       26
       +
       

     

       27
       27
       +
           def to_dict(self) -> dict:

     

       28
       28
       +
               """Convert to dictionary for JSON serialization."""

     

       29
       29
       +
               result = {

     

       30
       30
       +
                   "source_entry_id": self.source_entry_id,

     

       31
       31
       +
                   "source_username": self.source_username,

     

       32
       32
       +
                   "target_url": self.target_url,

     

       33
       33
       +
               }

     

       34
       34
       +
       

     

       35
       35
       +
               # Only include optional fields if they are not None

     

       36
       36
       +
               if self.target_username is not None:

     

       37
       37
       +
                   result["target_username"] = self.target_username

     

       38
       38
       +
               if self.target_entry_id is not None:

     

       39
       39
       +
                   result["target_entry_id"] = self.target_entry_id

     

       40
       40
       +
       

     

       41
       41
       +
               return result

     

       42
       42
       +
       

     

       43
       43
       +
           @classmethod

     

       44
       44
       +
           def from_dict(cls, data: dict) -> "BlogReference":

     

       45
       45
       +
               """Create from dictionary."""

     

       46
       46
       +
               return cls(

     

       47
       47
       +
                   source_entry_id=data["source_entry_id"],

     

       48
       48
       +
                   source_username=data["source_username"],

     

       49
       49
       +
                   target_url=data["target_url"],

     

       50
       50
       +
                   target_username=data.get("target_username"),

     

       51
       51
       +
                   target_entry_id=data.get("target_entry_id"),

     

       52
       52
       +
               )

     

       53
       53
       +
       

     

       54
       54
       +
       

     

       55
       55
       +
       class ReferenceIndex:

     

       56
       56
       +
           """Index of blog-to-blog references for creating threaded views."""

     

       57
       57
       +
       

     

       58
       58
       +
           def __init__(self):

     

       59
       59
       +
               self.references: list[BlogReference] = []

     

       60
       60
       +
               self.outbound_refs: dict[

     

       61
       61
       +
                   str, list[BlogReference]

     

       62
       62
       +
               ] = {}  # entry_id -> outbound refs

     

       63
       63
       +
               self.inbound_refs: dict[

     

       64
       64
       +
                   str, list[BlogReference]

     

       65
       65
       +
               ] = {}  # entry_id -> inbound refs

     

       66
       66
       +
               self.user_domains: dict[str, set[str]] = {}  # username -> set of domains

     

       67
       67
       +
       

     

       68
       68
       +
           def add_reference(self, ref: BlogReference) -> None:

     

       69
       69
       +
               """Add a reference to the index."""

     

       70
       70
       +
               self.references.append(ref)

     

       71
       71
       +
       

     

       72
       72
       +
               # Update outbound references

     

       73
       73
       +
               source_key = f"{ref.source_username}:{ref.source_entry_id}"

     

       74
       74
       +
               if source_key not in self.outbound_refs:

     

       75
       75
       +
                   self.outbound_refs[source_key] = []

     

       76
       76
       +
               self.outbound_refs[source_key].append(ref)

     

       77
       77
       +
       

     

       78
       78
       +
               # Update inbound references if we can identify the target

     

       79
       79
       +
               if ref.target_username and ref.target_entry_id:

     

       80
       80
       +
                   target_key = f"{ref.target_username}:{ref.target_entry_id}"

     

       81
       81
       +
                   if target_key not in self.inbound_refs:

     

       82
       82
       +
                       self.inbound_refs[target_key] = []

     

       83
       83
       +
                   self.inbound_refs[target_key].append(ref)

     

       84
       84
       +
       

     

       85
       85
       +
           def get_outbound_refs(self, username: str, entry_id: str) -> list[BlogReference]:

     

       86
       86
       +
               """Get all outbound references from an entry."""

     

       87
       87
       +
               key = f"{username}:{entry_id}"

     

       88
       88
       +
               return self.outbound_refs.get(key, [])

     

       89
       89
       +
       

     

       90
       90
       +
           def get_inbound_refs(self, username: str, entry_id: str) -> list[BlogReference]:

     

       91
       91
       +
               """Get all inbound references to an entry."""

     

       92
       92
       +
               key = f"{username}:{entry_id}"

     

       93
       93
       +
               return self.inbound_refs.get(key, [])

     

       94
       94
       +
       

     

       95
       95
       +
           def get_thread_members(self, username: str, entry_id: str) -> set[tuple[str, str]]:

     

       96
       96
       +
               """Get all entries that are part of the same thread."""

     

       97
       97
       +
               visited = set()

     

       98
       98
       +
               to_visit = [(username, entry_id)]

     

       99
       99
       +
               thread_members = set()

     

       100
       100
       +
       

     

       101
       101
       +
               while to_visit:

     

       102
       102
       +
                   current_user, current_entry = to_visit.pop()

     

       103
       103
       +
                   if (current_user, current_entry) in visited:

     

       104
       104
       +
                       continue

     

       105
       105
       +
       

     

       106
       106
       +
                   visited.add((current_user, current_entry))

     

       107
       107
       +
                   thread_members.add((current_user, current_entry))

     

       108
       108
       +
       

     

       109
       109
       +
                   # Add outbound references

     

       110
       110
       +
                   for ref in self.get_outbound_refs(current_user, current_entry):

     

       111
       111
       +
                       if ref.target_username and ref.target_entry_id:

     

       112
       112
       +
                           to_visit.append((ref.target_username, ref.target_entry_id))

     

       113
       113
       +
       

     

       114
       114
       +
                   # Add inbound references

     

       115
       115
       +
                   for ref in self.get_inbound_refs(current_user, current_entry):

     

       116
       116
       +
                       to_visit.append((ref.source_username, ref.source_entry_id))

     

       117
       117
       +
       

     

       118
       118
       +
               return thread_members

     

       119
       119
       +
       

     

       120
       120
       +
           def to_dict(self) -> dict:

     

       121
       121
       +
               """Convert to dictionary for JSON serialization."""

     

       122
       122
       +
               return {

     

       123
       123
       +
                   "references": [ref.to_dict() for ref in self.references],

     

       124
       124
       +
                   "user_domains": {k: list(v) for k, v in self.user_domains.items()},

     

       125
       125
       +
               }

     

       126
       126
       +
       

     

       127
       127
       +
           @classmethod

     

       128
       128
       +
           def from_dict(cls, data: dict) -> "ReferenceIndex":

     

       129
       129
       +
               """Create from dictionary."""

     

       130
       130
       +
               index = cls()

     

       131
       131
       +
               for ref_data in data.get("references", []):

     

       132
       132
       +
                   ref = BlogReference.from_dict(ref_data)

     

       133
       133
       +
                   index.add_reference(ref)

     

       134
       134
       +
       

     

       135
       135
       +
               for username, domains in data.get("user_domains", {}).items():

     

       136
       136
       +
                   index.user_domains[username] = set(domains)

     

       137
       137
       +
       

     

       138
       138
       +
               return index

     

       139
       139
       +
       

     

       140
       140
       +
       

     

       141
       141
       +
       class ReferenceParser:

     

       142
       142
       +
           """Parses blog entries to detect references to other blogs."""

     

       143
       143
       +
       

     

       144
       144
       +
           def __init__(self):

     

       145
       145
       +
               # Common blog platforms and patterns

     

       146
       146
       +
               self.blog_patterns = [

     

       147
       147
       +
                   r"https?://[^/]+\.(?:org|com|net|io|dev|me|co\.uk)/.*",  # Common blog domains

     

       148
       148
       +
                   r"https?://[^/]+\.github\.io/.*",  # GitHub Pages

     

       149
       149
       +
                   r"https?://[^/]+\.substack\.com/.*",  # Substack

     

       150
       150
       +
                   r"https?://medium\.com/.*",  # Medium

     

       151
       151
       +
                   r"https?://[^/]+\.wordpress\.com/.*",  # WordPress.com

     

       152
       152
       +
                   r"https?://[^/]+\.blogspot\.com/.*",  # Blogger

     

       153
       153
       +
               ]

     

       154
       154
       +
       

     

       155
       155
       +
               # Compile regex patterns

     

       156
       156
       +
               self.link_pattern = re.compile(

     

       157
       157
       +
                   r'<a[^>]+href="([^"]+)"[^>]*>(.*?)</a>', re.IGNORECASE | re.DOTALL

     

       158
       158
       +
               )

     

       159
       159
       +
               self.url_pattern = re.compile(r'https?://[^\s<>"]+')

     

       160
       160
       +
       

     

       161
       161
       +
           def extract_links_from_html(self, html_content: str) -> list[tuple[str, str]]:

     

       162
       162
       +
               """Extract all links from HTML content."""

     

       163
       163
       +
               links = []

     

       164
       164
       +
       

     

       165
       165
       +
               # Extract links from <a> tags

     

       166
       166
       +
               for match in self.link_pattern.finditer(html_content):

     

       167
       167
       +
                   url = match.group(1)

     

       168
       168
       +
                   text = re.sub(

     

       169
       169
       +
                       r"<[^>]+>", "", match.group(2)

     

       170
       170
       +
                   ).strip()  # Remove HTML tags from link text

     

       171
       171
       +
                   links.append((url, text))

     

       172
       172
       +
       

     

       173
       173
       +
               return links

     

       174
       174
       +
       

     

       175
       175
       +
           def is_blog_url(self, url: str) -> bool:

     

       176
       176
       +
               """Check if a URL likely points to a blog post."""

     

       177
       177
       +
               for pattern in self.blog_patterns:

     

       178
       178
       +
                   if re.match(pattern, url):

     

       179
       179
       +
                       return True

     

       180
       180
       +
               return False

     

       181
       181
       +
       

     

       182
       182
       +
           def _is_likely_blog_post_url(self, url: str) -> bool:

     

       183
       183
       +
               """Check if a same-domain URL likely points to a blog post (not CSS, images, etc.)."""

     

       184
       184
       +
               parsed_url = urlparse(url)

     

       185
       185
       +
               path = parsed_url.path.lower()

     

       186
       186
       +
       

     

       187
       187
       +
               # Skip obvious non-blog content

     

       188
       188
       +
               if any(path.endswith(ext) for ext in ['.css', '.js', '.png', '.jpg', '.jpeg', '.gif', '.svg', '.ico', '.pdf', '.xml', '.json']):

     

       189
       189
       +
                   return False

     

       190
       190
       +
       

     

       191
       191
       +
               # Skip common non-blog paths

     

       192
       192
       +
               if any(segment in path for segment in ['/static/', '/assets/', '/css/', '/js/', '/images/', '/img/', '/media/', '/uploads/']):

     

       193
       193
       +
                   return False

     

       194
       194
       +
       

     

       195
       195
       +
               # Skip fragment-only links (same page anchors)

     

       196
       196
       +
               if not path or path == '/':

     

       197
       197
       +
                   return False

     

       198
       198
       +
       

     

       199
       199
       +
               # Look for positive indicators of blog posts

     

       200
       200
       +
               # Common blog post patterns: dates, slugs, post indicators

     

       201
       201
       +
               blog_indicators = [

     

       202
       202
       +
                   r'/\d{4}/',  # Year in path

     

       203
       203
       +
                   r'/\d{4}/\d{2}/',  # Year/month in path

     

       204
       204
       +
                   r'/blog/',

     

       205
       205
       +
                   r'/post/',

     

       206
       206
       +
                   r'/posts/',

     

       207
       207
       +
                   r'/articles?/',

     

       208
       208
       +
                   r'/notes?/',

     

       209
       209
       +
                   r'/entries/',

     

       210
       210
       +
                   r'/writing/',

     

       211
       211
       +
               ]

     

       212
       212
       +
       

     

       213
       213
       +
               for pattern in blog_indicators:

     

       214
       214
       +
                   if re.search(pattern, path):

     

       215
       215
       +
                       return True

     

       216
       216
       +
       

     

       217
       217
       +
               # If it has a reasonable path depth and doesn't match exclusions, likely a blog post

     

       218
       218
       +
               path_segments = [seg for seg in path.split('/') if seg]

     

       219
       219
       +
               return len(path_segments) >= 1  # At least one meaningful path segment

     

       220
       220
       +
       

     

       221
       221
       +
           def resolve_target_user(

     

       222
       222
       +
               self, url: str, user_domains: dict[str, set[str]]

     

       223
       223
       +
           ) -> Optional[str]:

     

       224
       224
       +
               """Try to resolve a URL to a known user based on domain mapping."""

     

       225
       225
       +
               parsed_url = urlparse(url)

     

       226
       226
       +
               domain = parsed_url.netloc.lower()

     

       227
       227
       +
       

     

       228
       228
       +
               for username, domains in user_domains.items():

     

       229
       229
       +
                   if domain in domains:

     

       230
       230
       +
                       return username

     

       231
       231
       +
       

     

       232
       232
       +
               return None

     

       233
       233
       +
       

     

       234
       234
       +
           def extract_references(

     

       235
       235
       +
               self, entry: AtomEntry, username: str, user_domains: dict[str, set[str]]

     

       236
       236
       +
           ) -> list[BlogReference]:

     

       237
       237
       +
               """Extract all blog references from an entry."""

     

       238
       238
       +
               references = []

     

       239
       239
       +
       

     

       240
       240
       +
               # Combine all text content for analysis

     

       241
       241
       +
               content_to_search = []

     

       242
       242
       +
               if entry.content:

     

       243
       243
       +
                   content_to_search.append(entry.content)

     

       244
       244
       +
               if entry.summary:

     

       245
       245
       +
                   content_to_search.append(entry.summary)

     

       246
       246
       +
       

     

       247
       247
       +
               for content in content_to_search:

     

       248
       248
       +
                   links = self.extract_links_from_html(content)

     

       249
       249
       +
       

     

       250
       250
       +
                   for url, _link_text in links:

     

       251
       251
       +
                       entry_domain = (

     

       252
       252
       +
                           urlparse(str(entry.link)).netloc.lower() if entry.link else ""

     

       253
       253
       +
                       )

     

       254
       254
       +
                       link_domain = urlparse(url).netloc.lower()

     

       255
       255
       +
       

     

       256
       256
       +
                       # Check if this looks like a blog URL

     

       257
       257
       +
                       if not self.is_blog_url(url):

     

       258
       258
       +
                           continue

     

       259
       259
       +
       

     

       260
       260
       +
                       # For same-domain links, apply additional filtering to avoid non-blog content

     

       261
       261
       +
                       if link_domain == entry_domain:

     

       262
       262
       +
                           # Only include same-domain links that look like blog posts

     

       263
       263
       +
                           if not self._is_likely_blog_post_url(url):

     

       264
       264
       +
                               continue

     

       265
       265
       +
       

     

       266
       266
       +
                       # Try to resolve to a known user

     

       267
       267
       +
                       if link_domain == entry_domain:

     

       268
       268
       +
                           # Same domain - target user is the same as source user

     

       269
       269
       +
                           target_username: Optional[str] = username

     

       270
       270
       +
                       else:

     

       271
       271
       +
                           # Different domain - try to resolve

     

       272
       272
       +
                           target_username = self.resolve_target_user(url, user_domains)

     

       273
       273
       +
       

     

       274
       274
       +
                       ref = BlogReference(

     

       275
       275
       +
                           source_entry_id=entry.id,

     

       276
       276
       +
                           source_username=username,

     

       277
       277
       +
                           target_url=url,

     

       278
       278
       +
                           target_username=target_username,

     

       279
       279
       +
                           target_entry_id=None,  # Will be resolved later if possible

     

       280
       280
       +
                       )

     

       281
       281
       +
       

     

       282
       282
       +
                       references.append(ref)

     

       283
       283
       +
       

     

       284
       284
       +
               return references

     

       285
       285
       +
       

     

       286
       286
       +
           def build_user_domain_mapping(self, git_store: "GitStore") -> dict[str, set[str]]:

     

       287
       287
       +
               """Build mapping of usernames to their known domains."""

     

       288
       288
       +
               user_domains = {}

     

       289
       289
       +
               index = git_store._load_index()

     

       290
       290
       +
       

     

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

     

       292
       292
       +
                   domains = set()

     

       293
       293
       +
       

     

       294
       294
       +
                   # Add domains from feeds

     

       295
       295
       +
                   for feed_url in user_metadata.feeds:

     

       296
       296
       +
                       domain = urlparse(feed_url).netloc.lower()

     

       297
       297
       +
                       if domain:

     

       298
       298
       +
                           domains.add(domain)

     

       299
       299
       +
       

     

       300
       300
       +
                   # Add domain from homepage

     

       301
       301
       +
                   if user_metadata.homepage:

     

       302
       302
       +
                       domain = urlparse(str(user_metadata.homepage)).netloc.lower()

     

       303
       303
       +
                       if domain:

     

       304
       304
       +
                           domains.add(domain)

     

       305
       305
       +
       

     

       306
       306
       +
                   user_domains[username] = domains

     

       307
       307
       +
       

     

       308
       308
       +
               return user_domains

     

       309
       309
       +
       

     

       310
       310
       +
           def _build_url_to_entry_mapping(self, git_store: "GitStore") -> dict[str, str]:

     

       311
       311
       +
               """Build a comprehensive mapping from URLs to entry IDs using git store data.

     

       312
       312
       +
               

     

       313
       313
       +
               This creates a bidirectional mapping that handles:

     

       314
       314
       +
               - Entry link URLs -> Entry IDs

     

       315
       315
       +
               - URL variations (with/without www, http/https)

     

       316
       316
       +
               - Multiple URLs pointing to the same entry

     

       317
       317
       +
               """

     

       318
       318
       +
               url_to_entry: dict[str, str] = {}

     

       319
       319
       +
       

     

       320
       320
       +
               # Load index to get all users

     

       321
       321
       +
               index = git_store._load_index()

     

       322
       322
       +
       

     

       323
       323
       +
               for username in index.users.keys():

     

       324
       324
       +
                   entries = git_store.list_entries(username)

     

       325
       325
       +
       

     

       326
       326
       +
                   for entry in entries:

     

       327
       327
       +
                       if entry.link:

     

       328
       328
       +
                           link_url = str(entry.link)

     

       329
       329
       +
                           entry_id = entry.id

     

       330
       330
       +
       

     

       331
       331
       +
                           # Map the canonical link URL

     

       332
       332
       +
                           url_to_entry[link_url] = entry_id

     

       333
       333
       +
       

     

       334
       334
       +
                           # Handle common URL variations

     

       335
       335
       +
                           parsed = urlparse(link_url)

     

       336
       336
       +
                           if parsed.netloc and parsed.path:

     

       337
       337
       +
                               # Add version without www

     

       338
       338
       +
                               if parsed.netloc.startswith('www.'):

     

       339
       339
       +
                                   no_www_url = f"{parsed.scheme}://{parsed.netloc[4:]}{parsed.path}"

     

       340
       340
       +
                                   if parsed.query:

     

       341
       341
       +
                                       no_www_url += f"?{parsed.query}"

     

       342
       342
       +
                                   if parsed.fragment:

     

       343
       343
       +
                                       no_www_url += f"#{parsed.fragment}"

     

       344
       344
       +
                                   url_to_entry[no_www_url] = entry_id

     

       345
       345
       +
       

     

       346
       346
       +
                               # Add version with www if not present

     

       347
       347
       +
                               elif not parsed.netloc.startswith('www.'):

     

       348
       348
       +
                                   www_url = f"{parsed.scheme}://www.{parsed.netloc}{parsed.path}"

     

       349
       349
       +
                                   if parsed.query:

     

       350
       350
       +
                                       www_url += f"?{parsed.query}"

     

       351
       351
       +
                                   if parsed.fragment:

     

       352
       352
       +
                                       www_url += f"#{parsed.fragment}"

     

       353
       353
       +
                                   url_to_entry[www_url] = entry_id

     

       354
       354
       +
       

     

       355
       355
       +
                               # Add http/https variations

     

       356
       356
       +
                               if parsed.scheme == 'https':

     

       357
       357
       +
                                   http_url = link_url.replace('https://', 'http://', 1)

     

       358
       358
       +
                                   url_to_entry[http_url] = entry_id

     

       359
       359
       +
                               elif parsed.scheme == 'http':

     

       360
       360
       +
                                   https_url = link_url.replace('http://', 'https://', 1)

     

       361
       361
       +
                                   url_to_entry[https_url] = entry_id

     

       362
       362
       +
       

     

       363
       363
       +
               return url_to_entry

     

       364
       364
       +
       

     

       365
       365
       +
           def _normalize_url(self, url: str) -> str:

     

       366
       366
       +
               """Normalize URL for consistent matching.

     

       367
       367
       +
               

     

       368
       368
       +
               Handles common variations like trailing slashes, fragments, etc.

     

       369
       369
       +
               """

     

       370
       370
       +
               parsed = urlparse(url)

     

       371
       371
       +
       

     

       372
       372
       +
               # Remove trailing slash from path

     

       373
       373
       +
               path = parsed.path.rstrip('/') if parsed.path != '/' else parsed.path

     

       374
       374
       +
       

     

       375
       375
       +
               # Reconstruct without fragment for consistent matching

     

       376
       376
       +
               normalized = f"{parsed.scheme}://{parsed.netloc}{path}"

     

       377
       377
       +
               if parsed.query:

     

       378
       378
       +
                   normalized += f"?{parsed.query}"

     

       379
       379
       +
       

     

       380
       380
       +
               return normalized

     

       381
       381
       +
       

     

       382
       382
       +
           def resolve_target_entry_ids(

     

       383
       383
       +
               self, references: list[BlogReference], git_store: "GitStore"

     

       384
       384
       +
           ) -> list[BlogReference]:

     

       385
       385
       +
               """Resolve target_entry_id for references using comprehensive URL mapping."""

     

       386
       386
       +
               resolved_refs = []

     

       387
       387
       +
       

     

       388
       388
       +
               # Build comprehensive URL to entry ID mapping

     

       389
       389
       +
               url_to_entry = self._build_url_to_entry_mapping(git_store)

     

       390
       390
       +
       

     

       391
       391
       +
               for ref in references:

     

       392
       392
       +
                   # If we already have a target_entry_id, keep the reference as-is

     

       393
       393
       +
                   if ref.target_entry_id is not None:

     

       394
       394
       +
                       resolved_refs.append(ref)

     

       395
       395
       +
                       continue

     

       396
       396
       +
       

     

       397
       397
       +
                   # If we don't have a target_username, we can't resolve it

     

       398
       398
       +
                   if ref.target_username is None:

     

       399
       399
       +
                       resolved_refs.append(ref)

     

       400
       400
       +
                       continue

     

       401
       401
       +
       

     

       402
       402
       +
                   # Try to resolve using URL mapping

     

       403
       403
       +
                   resolved_entry_id = None

     

       404
       404
       +
       

     

       405
       405
       +
                   # First, try exact match

     

       406
       406
       +
                   if ref.target_url in url_to_entry:

     

       407
       407
       +
                       resolved_entry_id = url_to_entry[ref.target_url]

     

       408
       408
       +
                   else:

     

       409
       409
       +
                       # Try normalized URL matching

     

       410
       410
       +
                       normalized_target = self._normalize_url(ref.target_url)

     

       411
       411
       +
                       if normalized_target in url_to_entry:

     

       412
       412
       +
                           resolved_entry_id = url_to_entry[normalized_target]

     

       413
       413
       +
                       else:

     

       414
       414
       +
                           # Try URL variations

     

       415
       415
       +
                           for mapped_url, entry_id in url_to_entry.items():

     

       416
       416
       +
                               if self._normalize_url(mapped_url) == normalized_target:

     

       417
       417
       +
                                   resolved_entry_id = entry_id

     

       418
       418
       +
                                   break

     

       419
       419
       +
       

     

       420
       420
       +
                   # Verify the resolved entry belongs to the target username

     

       421
       421
       +
                   if resolved_entry_id:

     

       422
       422
       +
                       # Double-check by loading the actual entry

     

       423
       423
       +
                       entries = git_store.list_entries(ref.target_username)

     

       424
       424
       +
                       entry_found = any(entry.id == resolved_entry_id for entry in entries)

     

       425
       425
       +
                       if not entry_found:

     

       426
       426
       +
                           resolved_entry_id = None

     

       427
       427
       +
       

     

       428
       428
       +
                   # Create a new reference with the resolved target_entry_id

     

       429
       429
       +
                   resolved_ref = BlogReference(

     

       430
       430
       +
                       source_entry_id=ref.source_entry_id,

     

       431
       431
       +
                       source_username=ref.source_username,

     

       432
       432
       +
                       target_url=ref.target_url,

     

       433
       433
       +
                       target_username=ref.target_username,

     

       434
       434
       +
                       target_entry_id=resolved_entry_id,

     

       435
       435
       +
                   )

     

       436
       436
       +
                   resolved_refs.append(resolved_ref)

     

       437
       437
       +
       

     

       438
       438
       +
               return resolved_refs

+1 -1

src/thicket/models/__init__.py

···

       12
       12
        
           "FeedMetadata",

     

       13
       13
        
           "GitStoreIndex",

     

       14
       14
        
           "UserMetadata",

     

       15
       15
       -
       ]
     

       15
       15
       +
       ]

+28 -38

src/thicket/models/config.py

···

       1
       1
        
       """Configuration models for thicket."""

     

       2
       2
        
       

     

       3
       3
       +
       import json

     

       4
       4
       +
       import yaml

     

       3
       5
        
       from pathlib import Path

     

       4
       4
       -
       from typing import Optional

     

       6
       6
       +
       from typing import Optional, Union

     

       5
       7
        
       

     

       6
       6
       -
       from pydantic import BaseModel, EmailStr, HttpUrl

     

       8
       8
       +
       from pydantic import BaseModel, EmailStr, HttpUrl, ValidationError

     

       7
       9
        
       from pydantic_settings import BaseSettings, SettingsConfigDict

     

       8
       10
        
       

     

       9
       11
        
       

     
···

       32
       34
        
           cache_dir: Path

     

       33
       35
        
           users: list[UserConfig] = []

     

       34
       36
        
       

     

       35
       35
       -
           def find_user(self, username: str) -> Optional[UserConfig]:

     

       36
       36
       -
               """Find a user by username."""

     

       37
       37
       -
               for user in self.users:

     

       38
       38
       -
                   if user.username == username:

     

       39
       39
       -
                       return user

     

       40
       40
       -
               return None

     

       41
       41
       -
       

     

       42
       42
       -
           def add_user(self, user: UserConfig) -> None:

     

       43
       43
       -
               """Add a new user or update existing user."""

     

       44
       44
       -
               existing = self.find_user(user.username)

     

       45
       45
       -
               if existing:

     

       46
       46
       -
                   # Update existing user

     

       47
       47
       -
                   existing.feeds = list(set(existing.feeds + user.feeds))

     

       48
       48
       -
                   existing.email = user.email or existing.email

     

       49
       49
       -
                   existing.homepage = user.homepage or existing.homepage

     

       50
       50
       -
                   existing.icon = user.icon or existing.icon

     

       51
       51
       -
                   existing.display_name = user.display_name or existing.display_name

     

       37
       37
       +
           @classmethod

     

       38
       38
       +
           def from_file(cls, config_path: Path) -> 'ThicketConfig':

     

       39
       39
       +
               """Load configuration from a file."""

     

       40
       40
       +
               if not config_path.exists():

     

       41
       41
       +
                   raise FileNotFoundError(f"Configuration file not found: {config_path}")

     

       42
       42
       +
               

     

       43
       43
       +
               content = config_path.read_text(encoding='utf-8')

     

       44
       44
       +
               

     

       45
       45
       +
               if config_path.suffix.lower() in ['.yaml', '.yml']:

     

       46
       46
       +
                   try:

     

       47
       47
       +
                       data = yaml.safe_load(content)

     

       48
       48
       +
                   except yaml.YAMLError as e:

     

       49
       49
       +
                       raise ValueError(f"Invalid YAML in {config_path}: {e}")

     

       50
       50
       +
               elif config_path.suffix.lower() == '.json':

     

       51
       51
       +
                   try:

     

       52
       52
       +
                       data = json.loads(content)

     

       53
       53
       +
                   except json.JSONDecodeError as e:

     

       54
       54
       +
                       raise ValueError(f"Invalid JSON in {config_path}: {e}")

     

       52
       55
        
               else:

     

       53
       53
       -
                   # Add new user

     

       54
       54
       -
                   self.users.append(user)

     

       55
       55
       -
       

     

       56
       56
       -
           def remove_user(self, username: str) -> bool:

     

       57
       57
       -
               """Remove a user by username. Returns True if user was found and removed."""

     

       58
       58
       -
               for i, user in enumerate(self.users):

     

       59
       59
       -
                   if user.username == username:

     

       60
       60
       -
                       del self.users[i]

     

       61
       61
       -
                       return True

     

       62
       62
       -
               return False

     

       63
       63
       -
       

     

       64
       64
       -
           def add_feed_to_user(self, username: str, feed_url: HttpUrl) -> bool:

     

       65
       65
       -
               """Add a feed to an existing user. Returns True if user was found."""

     

       66
       66
       -
               user = self.find_user(username)

     

       67
       67
       -
               if user:

     

       68
       68
       -
                   if feed_url not in user.feeds:

     

       69
       69
       -
                       user.feeds.append(feed_url)

     

       70
       70
       -
                   return True

     

       71
       71
       -
               return False
     

       56
       56
       +
                   raise ValueError(f"Unsupported configuration file format: {config_path.suffix}")

     

       57
       57
       +
               

     

       58
       58
       +
               try:

     

       59
       59
       +
                   return cls(**data)

     

       60
       60
       +
               except ValidationError as e:

     

       61
       61
       +
                   raise ValueError(f"Configuration validation error: {e}")

+5 -2

src/thicket/models/feed.py

···

       1
       1
        
       """Feed and entry models for thicket."""

     

       2
       2
        
       

     

       3
       3
        
       from datetime import datetime

     

       4
       4
       -
       from typing import Optional

     

       4
       4
       +
       from typing import TYPE_CHECKING, Optional

     

       5
       5
        
       

     

       6
       6
        
       from pydantic import BaseModel, ConfigDict, EmailStr, HttpUrl

     

       7
       7
       +
       

     

       8
       8
       +
       if TYPE_CHECKING:

     

       9
       9
       +
           from .config import UserConfig

     

       7
       10
        
       

     

       8
       11
        
       

     

       9
       12
        
       class AtomEntry(BaseModel):

     
···

       83
       86
        
                   duplicate_id

     

       84
       87
        
                   for duplicate_id, canonical in self.duplicates.items()

     

       85
       88
        
                   if canonical == canonical_id

     

       86
       86
       -
               ]
     

       89
       89
       +
               ]

+1 -2

src/thicket/models/user.py

···

       68
       68
        
               """Update entry count for a user and total."""

     

       69
       69
        
               user = self.get_user(username)

     

       70
       70
        
               if user:

     

       71
       71
       -
                   old_count = user.entry_count

     

       72
       71
        
                   user.increment_entry_count(count)

     

       73
       72
        
                   self.total_entries += count

     

       74
       73
        
                   self.last_updated = datetime.now()

     
···

       76
       75
        
           def recalculate_totals(self) -> None:

     

       77
       76
        
               """Recalculate total entries from all users."""

     

       78
       77
        
               self.total_entries = sum(user.entry_count for user in self.users.values())

     

       79
       79
       -
               self.last_updated = datetime.now()
     

       78
       78
       +
               self.last_updated = datetime.now()

src/thicket/subsystems/__init__.py

···

       1
       1
       +
       """Thicket subsystems for specialized operations."""

+227

src/thicket/subsystems/feeds.py

···

       1
       1
       +
       """Feed management subsystem."""

     

       2
       2
       +
       

     

       3
       3
       +
       import asyncio

     

       4
       4
       +
       import json

     

       5
       5
       +
       from datetime import datetime

     

       6
       6
       +
       from pathlib import Path

     

       7
       7
       +
       from typing import Callable, Optional

     

       8
       8
       +
       

     

       9
       9
       +
       from pydantic import HttpUrl

     

       10
       10
       +
       

     

       11
       11
       +
       from ..core.feed_parser import FeedParser

     

       12
       12
       +
       from ..core.git_store import GitStore

     

       13
       13
       +
       from ..models import AtomEntry, ThicketConfig

     

       14
       14
       +
       

     

       15
       15
       +
       

     

       16
       16
       +
       class FeedManager:

     

       17
       17
       +
           """Manages feed operations and caching."""

     

       18
       18
       +
       

     

       19
       19
       +
           def __init__(self, git_store: GitStore, feed_parser: FeedParser, config: ThicketConfig):

     

       20
       20
       +
               """Initialize feed manager."""

     

       21
       21
       +
               self.git_store = git_store

     

       22
       22
       +
               self.feed_parser = feed_parser

     

       23
       23
       +
               self.config = config

     

       24
       24
       +
               self._ensure_cache_dir()

     

       25
       25
       +
       

     

       26
       26
       +
           def _ensure_cache_dir(self):

     

       27
       27
       +
               """Ensure cache directory exists."""

     

       28
       28
       +
               self.config.cache_dir.mkdir(parents=True, exist_ok=True)

     

       29
       29
       +
       

     

       30
       30
       +
           async def sync_feeds(self, username: Optional[str] = None, progress_callback: Optional[Callable] = None) -> dict:

     

       31
       31
       +
               """Sync feeds for all users or specific user."""

     

       32
       32
       +
               if username:

     

       33
       33
       +
                   return await self.sync_user_feeds(username, progress_callback)

     

       34
       34
       +
               

     

       35
       35
       +
               # Sync all users

     

       36
       36
       +
               results = {}

     

       37
       37
       +
               total_users = len(self.config.users)

     

       38
       38
       +
               

     

       39
       39
       +
               for i, user_config in enumerate(self.config.users):

     

       40
       40
       +
                   if progress_callback:

     

       41
       41
       +
                       progress_callback(f"Syncing feeds for {user_config.username}", i, total_users)

     

       42
       42
       +
                   

     

       43
       43
       +
                   user_results = await self.sync_user_feeds(user_config.username, progress_callback)

     

       44
       44
       +
                   results[user_config.username] = user_results

     

       45
       45
       +
               

     

       46
       46
       +
               return results

     

       47
       47
       +
       

     

       48
       48
       +
           async def sync_user_feeds(self, username: str, progress_callback: Optional[Callable] = None) -> dict:

     

       49
       49
       +
               """Sync feeds for a specific user."""

     

       50
       50
       +
               user_config = next((u for u in self.config.users if u.username == username), None)

     

       51
       51
       +
               if not user_config:

     

       52
       52
       +
                   return {'error': f'User {username} not found in configuration'}

     

       53
       53
       +
               

     

       54
       54
       +
               # Ensure user exists in git store

     

       55
       55
       +
               git_user = self.git_store.get_user(username)

     

       56
       56
       +
               if not git_user:

     

       57
       57
       +
                   self.git_store.add_user(

     

       58
       58
       +
                       username=user_config.username,

     

       59
       59
       +
                       display_name=user_config.display_name,

     

       60
       60
       +
                       email=str(user_config.email) if user_config.email else None,

     

       61
       61
       +
                       homepage=str(user_config.homepage) if user_config.homepage else None,

     

       62
       62
       +
                       icon=str(user_config.icon) if user_config.icon else None,

     

       63
       63
       +
                       feeds=[str(feed) for feed in user_config.feeds]

     

       64
       64
       +
                   )

     

       65
       65
       +
               

     

       66
       66
       +
               results = {

     

       67
       67
       +
                   'username': username,

     

       68
       68
       +
                   'feeds_processed': 0,

     

       69
       69
       +
                   'new_entries': 0,

     

       70
       70
       +
                   'errors': [],

     

       71
       71
       +
                   'feeds': {}

     

       72
       72
       +
               }

     

       73
       73
       +
               

     

       74
       74
       +
               total_feeds = len(user_config.feeds)

     

       75
       75
       +
               

     

       76
       76
       +
               for i, feed_url in enumerate(user_config.feeds):

     

       77
       77
       +
                   if progress_callback:

     

       78
       78
       +
                       progress_callback(f"Processing feed {i+1}/{total_feeds} for {username}", i, total_feeds)

     

       79
       79
       +
                   

     

       80
       80
       +
                   try:

     

       81
       81
       +
                       feed_result = await self._sync_single_feed(username, feed_url)

     

       82
       82
       +
                       results['feeds'][str(feed_url)] = feed_result

     

       83
       83
       +
                       results['feeds_processed'] += 1

     

       84
       84
       +
                       results['new_entries'] += feed_result.get('new_entries', 0)

     

       85
       85
       +
                   except Exception as e:

     

       86
       86
       +
                       error_msg = f"Error syncing {feed_url}: {str(e)}"

     

       87
       87
       +
                       results['errors'].append(error_msg)

     

       88
       88
       +
                       results['feeds'][str(feed_url)] = {'error': error_msg}

     

       89
       89
       +
               

     

       90
       90
       +
               return results

     

       91
       91
       +
       

     

       92
       92
       +
           async def _sync_single_feed(self, username: str, feed_url: HttpUrl) -> dict:

     

       93
       93
       +
               """Sync a single feed for a user."""

     

       94
       94
       +
               cache_key = self._get_cache_key(username, feed_url)

     

       95
       95
       +
               last_modified = self._get_last_modified(cache_key)

     

       96
       96
       +
               

     

       97
       97
       +
               try:

     

       98
       98
       +
                   # Fetch feed content

     

       99
       99
       +
                   content = await self.feed_parser.fetch_feed(feed_url)

     

       100
       100
       +
                   

     

       101
       101
       +
                   # Parse feed

     

       102
       102
       +
                   feed_meta, entries = self.feed_parser.parse_feed(content, feed_url)

     

       103
       103
       +
                   

     

       104
       104
       +
                   # Filter new entries

     

       105
       105
       +
                   new_entries = []

     

       106
       106
       +
                   for entry in entries:

     

       107
       107
       +
                       existing_entry = self.git_store.get_entry(username, entry.id)

     

       108
       108
       +
                       if not existing_entry:

     

       109
       109
       +
                           new_entries.append(entry)

     

       110
       110
       +
                   

     

       111
       111
       +
                   # Store new entries

     

       112
       112
       +
                   stored_count = 0

     

       113
       113
       +
                   for entry in new_entries:

     

       114
       114
       +
                       if self.git_store.store_entry(username, entry):

     

       115
       115
       +
                           stored_count += 1

     

       116
       116
       +
                   

     

       117
       117
       +
                   # Update cache

     

       118
       118
       +
                   self._update_cache(cache_key, {

     

       119
       119
       +
                       'last_fetched': datetime.now().isoformat(),

     

       120
       120
       +
                       'feed_meta': feed_meta.model_dump(exclude_none=True),

     

       121
       121
       +
                       'entry_count': len(entries),

     

       122
       122
       +
                       'new_entries': stored_count,

     

       123
       123
       +
                       'feed_url': str(feed_url)

     

       124
       124
       +
                   })

     

       125
       125
       +
                   

     

       126
       126
       +
                   return {

     

       127
       127
       +
                       'success': True,

     

       128
       128
       +
                       'total_entries': len(entries),

     

       129
       129
       +
                       'new_entries': stored_count,

     

       130
       130
       +
                       'feed_title': feed_meta.title,

     

       131
       131
       +
                       'last_fetched': datetime.now().isoformat()

     

       132
       132
       +
                   }

     

       133
       133
       +
                   

     

       134
       134
       +
               except Exception as e:

     

       135
       135
       +
                   return {

     

       136
       136
       +
                       'success': False,

     

       137
       137
       +
                       'error': str(e),

     

       138
       138
       +
                       'feed_url': str(feed_url)

     

       139
       139
       +
                   }

     

       140
       140
       +
       

     

       141
       141
       +
           def get_entries(self, username: str, limit: Optional[int] = None) -> list[AtomEntry]:

     

       142
       142
       +
               """Get entries for a user."""

     

       143
       143
       +
               return self.git_store.list_entries(username, limit)

     

       144
       144
       +
       

     

       145
       145
       +
           def get_entry(self, username: str, entry_id: str) -> Optional[AtomEntry]:

     

       146
       146
       +
               """Get a specific entry."""

     

       147
       147
       +
               return self.git_store.get_entry(username, entry_id)

     

       148
       148
       +
       

     

       149
       149
       +
           def search_entries(self, query: str, username: Optional[str] = None, limit: Optional[int] = None) -> list[tuple[str, AtomEntry]]:

     

       150
       150
       +
               """Search entries across users."""

     

       151
       151
       +
               return self.git_store.search_entries(query, username, limit)

     

       152
       152
       +
       

     

       153
       153
       +
           def get_stats(self) -> dict:

     

       154
       154
       +
               """Get feed-related statistics."""

     

       155
       155
       +
               index = self.git_store._load_index()

     

       156
       156
       +
               

     

       157
       157
       +
               feed_stats = {

     

       158
       158
       +
                   'total_feeds_configured': sum(len(user.feeds) for user in self.config.users),

     

       159
       159
       +
                   'users_with_entries': len([u for u in index.users.values() if u.entry_count > 0]),

     

       160
       160
       +
                   'cache_files': len(list(self.config.cache_dir.glob("*.json"))) if self.config.cache_dir.exists() else 0,

     

       161
       161
       +
               }

     

       162
       162
       +
               

     

       163
       163
       +
               return feed_stats

     

       164
       164
       +
       

     

       165
       165
       +
           def _get_cache_key(self, username: str, feed_url: HttpUrl) -> str:

     

       166
       166
       +
               """Generate cache key for feed."""

     

       167
       167
       +
               # Simple hash of username and feed URL

     

       168
       168
       +
               import hashlib

     

       169
       169
       +
               key_data = f"{username}:{str(feed_url)}"

     

       170
       170
       +
               return hashlib.md5(key_data.encode()).hexdigest()

     

       171
       171
       +
       

     

       172
       172
       +
           def _get_last_modified(self, cache_key: str) -> Optional[datetime]:

     

       173
       173
       +
               """Get last modified time from cache."""

     

       174
       174
       +
               cache_file = self.config.cache_dir / f"{cache_key}.json"

     

       175
       175
       +
               if cache_file.exists():

     

       176
       176
       +
                   try:

     

       177
       177
       +
                       with open(cache_file) as f:

     

       178
       178
       +
                           data = json.load(f)

     

       179
       179
       +
                       return datetime.fromisoformat(data.get('last_fetched', ''))

     

       180
       180
       +
                   except Exception:

     

       181
       181
       +
                       pass

     

       182
       182
       +
               return None

     

       183
       183
       +
       

     

       184
       184
       +
           def _update_cache(self, cache_key: str, data: dict):

     

       185
       185
       +
               """Update cache with feed data."""

     

       186
       186
       +
               cache_file = self.config.cache_dir / f"{cache_key}.json"

     

       187
       187
       +
               try:

     

       188
       188
       +
                   with open(cache_file, 'w') as f:

     

       189
       189
       +
                       json.dump(data, f, indent=2)

     

       190
       190
       +
               except Exception:

     

       191
       191
       +
                   # Cache update failure shouldn't break the sync

     

       192
       192
       +
                   pass

     

       193
       193
       +
       

     

       194
       194
       +
           def clear_cache(self, username: Optional[str] = None) -> bool:

     

       195
       195
       +
               """Clear feed cache."""

     

       196
       196
       +
               try:

     

       197
       197
       +
                   if username:

     

       198
       198
       +
                       # Clear cache for specific user

     

       199
       199
       +
                       for user_config in self.config.users:

     

       200
       200
       +
                           if user_config.username == username:

     

       201
       201
       +
                               for feed_url in user_config.feeds:

     

       202
       202
       +
                                   cache_key = self._get_cache_key(username, feed_url)

     

       203
       203
       +
                                   cache_file = self.config.cache_dir / f"{cache_key}.json"

     

       204
       204
       +
                                   if cache_file.exists():

     

       205
       205
       +
                                       cache_file.unlink()

     

       206
       206
       +
                   else:

     

       207
       207
       +
                       # Clear all cache

     

       208
       208
       +
                       if self.config.cache_dir.exists():

     

       209
       209
       +
                           for cache_file in self.config.cache_dir.glob("*.json"):

     

       210
       210
       +
                               cache_file.unlink()

     

       211
       211
       +
                   return True

     

       212
       212
       +
               except Exception:

     

       213
       213
       +
                   return False

     

       214
       214
       +
       

     

       215
       215
       +
           def get_feed_info(self, username: str, feed_url: str) -> Optional[dict]:

     

       216
       216
       +
               """Get cached information about a specific feed."""

     

       217
       217
       +
               try:

     

       218
       218
       +
                   feed_url_obj = HttpUrl(feed_url)

     

       219
       219
       +
                   cache_key = self._get_cache_key(username, feed_url_obj)

     

       220
       220
       +
                   cache_file = self.config.cache_dir / f"{cache_key}.json"

     

       221
       221
       +
                   

     

       222
       222
       +
                   if cache_file.exists():

     

       223
       223
       +
                       with open(cache_file) as f:

     

       224
       224
       +
                           return json.load(f)

     

       225
       225
       +
               except Exception:

     

       226
       226
       +
                   pass

     

       227
       227
       +
               return None

+304

src/thicket/subsystems/links.py

···

       1
       1
       +
       """Link processing subsystem."""

     

       2
       2
       +
       

     

       3
       3
       +
       import json

     

       4
       4
       +
       import re

     

       5
       5
       +
       from collections import defaultdict

     

       6
       6
       +
       from pathlib import Path

     

       7
       7
       +
       from typing import Optional

     

       8
       8
       +
       from urllib.parse import urljoin, urlparse

     

       9
       9
       +
       

     

       10
       10
       +
       from ..core.git_store import GitStore

     

       11
       11
       +
       from ..models import AtomEntry, ThicketConfig

     

       12
       12
       +
       

     

       13
       13
       +
       

     

       14
       14
       +
       class LinkProcessor:

     

       15
       15
       +
           """Processes and manages links between entries."""

     

       16
       16
       +
       

     

       17
       17
       +
           def __init__(self, git_store: GitStore, config: ThicketConfig):

     

       18
       18
       +
               """Initialize link processor."""

     

       19
       19
       +
               self.git_store = git_store

     

       20
       20
       +
               self.config = config

     

       21
       21
       +
               self.links_file = self.git_store.repo_path / "links.json"

     

       22
       22
       +
       

     

       23
       23
       +
           def process_links(self, username: Optional[str] = None) -> dict:

     

       24
       24
       +
               """Process and extract links from entries."""

     

       25
       25
       +
               if username:

     

       26
       26
       +
                   return self._process_user_links(username)

     

       27
       27
       +
               

     

       28
       28
       +
               # Process all users

     

       29
       29
       +
               results = {}

     

       30
       30
       +
               index = self.git_store._load_index()

     

       31
       31
       +
               

     

       32
       32
       +
               for user_metadata in index.users.values():

     

       33
       33
       +
                   user_results = self._process_user_links(user_metadata.username)

     

       34
       34
       +
                   results[user_metadata.username] = user_results

     

       35
       35
       +
               

     

       36
       36
       +
               # Consolidate all links

     

       37
       37
       +
               self._consolidate_links()

     

       38
       38
       +
               

     

       39
       39
       +
               return results

     

       40
       40
       +
       

     

       41
       41
       +
           def _process_user_links(self, username: str) -> dict:

     

       42
       42
       +
               """Process links for a specific user."""

     

       43
       43
       +
               entries = self.git_store.list_entries(username)

     

       44
       44
       +
               

     

       45
       45
       +
               results = {

     

       46
       46
       +
                   'username': username,

     

       47
       47
       +
                   'entries_processed': 0,

     

       48
       48
       +
                   'links_found': 0,

     

       49
       49
       +
                   'external_links': 0,

     

       50
       50
       +
                   'internal_links': 0,

     

       51
       51
       +
               }

     

       52
       52
       +
               

     

       53
       53
       +
               links_data = self._load_links_data()

     

       54
       54
       +
               

     

       55
       55
       +
               for entry in entries:

     

       56
       56
       +
                   entry_links = self._extract_links_from_entry(entry)

     

       57
       57
       +
                   

     

       58
       58
       +
                   if entry_links:

     

       59
       59
       +
                       # Store links for this entry

     

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

     

       61
       61
       +
                       links_data[entry_key] = {

     

       62
       62
       +
                           'entry_id': entry.id,

     

       63
       63
       +
                           'username': username,

     

       64
       64
       +
                           'title': entry.title,

     

       65
       65
       +
                           'links': entry_links,

     

       66
       66
       +
                           'processed_at': entry.updated.isoformat() if entry.updated else None,

     

       67
       67
       +
                       }

     

       68
       68
       +
                       

     

       69
       69
       +
                       results['links_found'] += len(entry_links)

     

       70
       70
       +
                       results['external_links'] += len([l for l in entry_links if self._is_external_link(l['url'])])

     

       71
       71
       +
                       results['internal_links'] += len([l for l in entry_links if not self._is_external_link(l['url'])])

     

       72
       72
       +
                   

     

       73
       73
       +
                   results['entries_processed'] += 1

     

       74
       74
       +
               

     

       75
       75
       +
               self._save_links_data(links_data)

     

       76
       76
       +
               

     

       77
       77
       +
               return results

     

       78
       78
       +
       

     

       79
       79
       +
           def _extract_links_from_entry(self, entry: AtomEntry) -> list[dict]:

     

       80
       80
       +
               """Extract links from an entry's content."""

     

       81
       81
       +
               links = []

     

       82
       82
       +
               

     

       83
       83
       +
               # Combine content and summary for link extraction

     

       84
       84
       +
               text_content = ""

     

       85
       85
       +
               if entry.content:

     

       86
       86
       +
                   text_content += entry.content

     

       87
       87
       +
               if entry.summary:

     

       88
       88
       +
                   text_content += " " + entry.summary

     

       89
       89
       +
               

     

       90
       90
       +
               if not text_content:

     

       91
       91
       +
                   return links

     

       92
       92
       +
               

     

       93
       93
       +
               # Extract HTML links

     

       94
       94
       +
               html_link_pattern = r'<a[^>]+href=["\']([^"\']+)["\'][^>]*>([^<]*)</a>'

     

       95
       95
       +
               html_matches = re.findall(html_link_pattern, text_content, re.IGNORECASE)

     

       96
       96
       +
               

     

       97
       97
       +
               for url, text in html_matches:

     

       98
       98
       +
                   # Clean up the URL

     

       99
       99
       +
                   url = url.strip()

     

       100
       100
       +
                   text = text.strip()

     

       101
       101
       +
                   

     

       102
       102
       +
                   if url and url not in ['#', 'javascript:void(0)']:

     

       103
       103
       +
                       # Resolve relative URLs if possible

     

       104
       104
       +
                       if entry.link and url.startswith('/'):

     

       105
       105
       +
                           base_url = str(entry.link)

     

       106
       106
       +
                           parsed_base = urlparse(base_url)

     

       107
       107
       +
                           base_domain = f"{parsed_base.scheme}://{parsed_base.netloc}"

     

       108
       108
       +
                           url = urljoin(base_domain, url)

     

       109
       109
       +
                       

     

       110
       110
       +
                       links.append({

     

       111
       111
       +
                           'url': url,

     

       112
       112
       +
                           'text': text or url,

     

       113
       113
       +
                           'type': 'html'

     

       114
       114
       +
                       })

     

       115
       115
       +
               

     

       116
       116
       +
               # Extract markdown links

     

       117
       117
       +
               markdown_link_pattern = r'\[([^\]]*)\]\(([^\)]+)\)'

     

       118
       118
       +
               markdown_matches = re.findall(markdown_link_pattern, text_content)

     

       119
       119
       +
               

     

       120
       120
       +
               for text, url in markdown_matches:

     

       121
       121
       +
                   url = url.strip()

     

       122
       122
       +
                   text = text.strip()

     

       123
       123
       +
                   

     

       124
       124
       +
                   if url and url not in ['#']:

     

       125
       125
       +
                       links.append({

     

       126
       126
       +
                           'url': url,

     

       127
       127
       +
                           'text': text or url,

     

       128
       128
       +
                           'type': 'markdown'

     

       129
       129
       +
                       })

     

       130
       130
       +
               

     

       131
       131
       +
               # Extract plain URLs

     

       132
       132
       +
               url_pattern = r'https?://[^\s<>"]+[^\s<>".,;!?]'

     

       133
       133
       +
               url_matches = re.findall(url_pattern, text_content)

     

       134
       134
       +
               

     

       135
       135
       +
               for url in url_matches:

     

       136
       136
       +
                   # Skip if already found as HTML or markdown link

     

       137
       137
       +
                   if not any(link['url'] == url for link in links):

     

       138
       138
       +
                       links.append({

     

       139
       139
       +
                           'url': url,

     

       140
       140
       +
                           'text': url,

     

       141
       141
       +
                           'type': 'plain'

     

       142
       142
       +
                       })

     

       143
       143
       +
               

     

       144
       144
       +
               return links

     

       145
       145
       +
       

     

       146
       146
       +
           def _is_external_link(self, url: str) -> bool:

     

       147
       147
       +
               """Check if a link is external to the configured domains."""

     

       148
       148
       +
               try:

     

       149
       149
       +
                   parsed = urlparse(url)

     

       150
       150
       +
                   domain = parsed.netloc.lower()

     

       151
       151
       +
                   

     

       152
       152
       +
                   # Check against user domains from feeds

     

       153
       153
       +
                   for user_config in self.config.users:

     

       154
       154
       +
                       for feed_url in user_config.feeds:

     

       155
       155
       +
                           feed_domain = urlparse(str(feed_url)).netloc.lower()

     

       156
       156
       +
                           if domain == feed_domain or domain.endswith(f'.{feed_domain}'):

     

       157
       157
       +
                               return False

     

       158
       158
       +
                       

     

       159
       159
       +
                       # Check homepage domain

     

       160
       160
       +
                       if user_config.homepage:

     

       161
       161
       +
                           homepage_domain = urlparse(str(user_config.homepage)).netloc.lower()

     

       162
       162
       +
                           if domain == homepage_domain or domain.endswith(f'.{homepage_domain}'):

     

       163
       163
       +
                               return False

     

       164
       164
       +
                   

     

       165
       165
       +
                   return True

     

       166
       166
       +
               except Exception:

     

       167
       167
       +
                   return True

     

       168
       168
       +
       

     

       169
       169
       +
           def _load_links_data(self) -> dict:

     

       170
       170
       +
               """Load existing links data."""

     

       171
       171
       +
               if self.links_file.exists():

     

       172
       172
       +
                   try:

     

       173
       173
       +
                       with open(self.links_file) as f:

     

       174
       174
       +
                           return json.load(f)

     

       175
       175
       +
                   except Exception:

     

       176
       176
       +
                       pass

     

       177
       177
       +
               return {}

     

       178
       178
       +
       

     

       179
       179
       +
           def _save_links_data(self, links_data: dict):

     

       180
       180
       +
               """Save links data to file."""

     

       181
       181
       +
               try:

     

       182
       182
       +
                   with open(self.links_file, 'w') as f:

     

       183
       183
       +
                       json.dump(links_data, f, indent=2, ensure_ascii=False)

     

       184
       184
       +
               except Exception:

     

       185
       185
       +
                   # Link processing failure shouldn't break the main operation

     

       186
       186
       +
                   pass

     

       187
       187
       +
       

     

       188
       188
       +
           def _consolidate_links(self):

     

       189
       189
       +
               """Consolidate and create reverse link mappings."""

     

       190
       190
       +
               links_data = self._load_links_data()

     

       191
       191
       +
               

     

       192
       192
       +
               # Create URL to entries mapping

     

       193
       193
       +
               url_mapping = defaultdict(list)

     

       194
       194
       +
               

     

       195
       195
       +
               for entry_key, entry_data in links_data.items():

     

       196
       196
       +
                   for link in entry_data.get('links', []):

     

       197
       197
       +
                       url_mapping[link['url']].append({

     

       198
       198
       +
                           'entry_key': entry_key,

     

       199
       199
       +
                           'username': entry_data['username'],

     

       200
       200
       +
                           'entry_id': entry_data['entry_id'],

     

       201
       201
       +
                           'title': entry_data['title'],

     

       202
       202
       +
                           'link_text': link['text'],

     

       203
       203
       +
                           'link_type': link['type'],

     

       204
       204
       +
                       })

     

       205
       205
       +
               

     

       206
       206
       +
               # Save URL mapping

     

       207
       207
       +
               url_mapping_file = self.git_store.repo_path / "url_mapping.json"

     

       208
       208
       +
               try:

     

       209
       209
       +
                   with open(url_mapping_file, 'w') as f:

     

       210
       210
       +
                       json.dump(dict(url_mapping), f, indent=2, ensure_ascii=False)

     

       211
       211
       +
               except Exception:

     

       212
       212
       +
                   pass

     

       213
       213
       +
       

     

       214
       214
       +
           def get_links(self, username: Optional[str] = None) -> dict:

     

       215
       215
       +
               """Get processed links."""

     

       216
       216
       +
               links_data = self._load_links_data()

     

       217
       217
       +
               

     

       218
       218
       +
               if username:

     

       219
       219
       +
                   user_links = {k: v for k, v in links_data.items() if v.get('username') == username}

     

       220
       220
       +
                   return user_links

     

       221
       221
       +
               

     

       222
       222
       +
               return links_data

     

       223
       223
       +
       

     

       224
       224
       +
           def find_references(self, url: str) -> list[tuple[str, AtomEntry]]:

     

       225
       225
       +
               """Find entries that reference a URL."""

     

       226
       226
       +
               url_mapping_file = self.git_store.repo_path / "url_mapping.json"

     

       227
       227
       +
               

     

       228
       228
       +
               if not url_mapping_file.exists():

     

       229
       229
       +
                   return []

     

       230
       230
       +
               

     

       231
       231
       +
               try:

     

       232
       232
       +
                   with open(url_mapping_file) as f:

     

       233
       233
       +
                       url_mapping = json.load(f)

     

       234
       234
       +
                   

     

       235
       235
       +
                   references = url_mapping.get(url, [])

     

       236
       236
       +
                   results = []

     

       237
       237
       +
                   

     

       238
       238
       +
                   for ref in references:

     

       239
       239
       +
                       entry = self.git_store.get_entry(ref['username'], ref['entry_id'])

     

       240
       240
       +
                       if entry:

     

       241
       241
       +
                           results.append((ref['username'], entry))

     

       242
       242
       +
                   

     

       243
       243
       +
                   return results

     

       244
       244
       +
               except Exception:

     

       245
       245
       +
                   return []

     

       246
       246
       +
       

     

       247
       247
       +
           def get_stats(self) -> dict:

     

       248
       248
       +
               """Get link processing statistics."""

     

       249
       249
       +
               links_data = self._load_links_data()

     

       250
       250
       +
               

     

       251
       251
       +
               total_entries_with_links = len(links_data)

     

       252
       252
       +
               total_links = sum(len(entry_data.get('links', [])) for entry_data in links_data.values())

     

       253
       253
       +
               

     

       254
       254
       +
               external_links = 0

     

       255
       255
       +
               internal_links = 0

     

       256
       256
       +
               

     

       257
       257
       +
               for entry_data in links_data.values():

     

       258
       258
       +
                   for link in entry_data.get('links', []):

     

       259
       259
       +
                       if self._is_external_link(link['url']):

     

       260
       260
       +
                           external_links += 1

     

       261
       261
       +
                       else:

     

       262
       262
       +
                           internal_links += 1

     

       263
       263
       +
               

     

       264
       264
       +
               # Count unique URLs

     

       265
       265
       +
               unique_urls = set()

     

       266
       266
       +
               for entry_data in links_data.values():

     

       267
       267
       +
                   for link in entry_data.get('links', []):

     

       268
       268
       +
                       unique_urls.add(link['url'])

     

       269
       269
       +
               

     

       270
       270
       +
               return {

     

       271
       271
       +
                   'entries_with_links': total_entries_with_links,

     

       272
       272
       +
                   'total_links': total_links,

     

       273
       273
       +
                   'unique_urls': len(unique_urls),

     

       274
       274
       +
                   'external_links': external_links,

     

       275
       275
       +
                   'internal_links': internal_links,

     

       276
       276
       +
               }

     

       277
       277
       +
       

     

       278
       278
       +
           def get_most_referenced_urls(self, limit: int = 10) -> list[dict]:

     

       279
       279
       +
               """Get most frequently referenced URLs."""

     

       280
       280
       +
               url_mapping_file = self.git_store.repo_path / "url_mapping.json"

     

       281
       281
       +
               

     

       282
       282
       +
               if not url_mapping_file.exists():

     

       283
       283
       +
                   return []

     

       284
       284
       +
               

     

       285
       285
       +
               try:

     

       286
       286
       +
                   with open(url_mapping_file) as f:

     

       287
       287
       +
                       url_mapping = json.load(f)

     

       288
       288
       +
                   

     

       289
       289
       +
                   # Count references per URL

     

       290
       290
       +
                   url_counts = [(url, len(refs)) for url, refs in url_mapping.items()]

     

       291
       291
       +
                   url_counts.sort(key=lambda x: x[1], reverse=True)

     

       292
       292
       +
                   

     

       293
       293
       +
                   results = []

     

       294
       294
       +
                   for url, count in url_counts[:limit]:

     

       295
       295
       +
                       results.append({

     

       296
       296
       +
                           'url': url,

     

       297
       297
       +
                           'reference_count': count,

     

       298
       298
       +
                           'is_external': self._is_external_link(url),

     

       299
       299
       +
                           'references': url_mapping[url]

     

       300
       300
       +
                       })

     

       301
       301
       +
                   

     

       302
       302
       +
                   return results

     

       303
       303
       +
               except Exception:

     

       304
       304
       +
                   return []

+158

src/thicket/subsystems/repository.py

···

       1
       1
       +
       """Repository management subsystem."""

     

       2
       2
       +
       

     

       3
       3
       +
       import shutil

     

       4
       4
       +
       from datetime import datetime

     

       5
       5
       +
       from pathlib import Path

     

       6
       6
       +
       from typing import Optional

     

       7
       7
       +
       

     

       8
       8
       +
       from ..core.git_store import GitStore

     

       9
       9
       +
       from ..models import ThicketConfig

     

       10
       10
       +
       

     

       11
       11
       +
       

     

       12
       12
       +
       class RepositoryManager:

     

       13
       13
       +
           """Manages repository operations and metadata."""

     

       14
       14
       +
       

     

       15
       15
       +
           def __init__(self, git_store: GitStore, config: ThicketConfig):

     

       16
       16
       +
               """Initialize repository manager."""

     

       17
       17
       +
               self.git_store = git_store

     

       18
       18
       +
               self.config = config

     

       19
       19
       +
       

     

       20
       20
       +
           def init_repository(self) -> bool:

     

       21
       21
       +
               """Initialize the git repository if not already done."""

     

       22
       22
       +
               try:

     

       23
       23
       +
                   # GitStore.__init__ already handles repository initialization

     

       24
       24
       +
                   return True

     

       25
       25
       +
               except Exception:

     

       26
       26
       +
                   return False

     

       27
       27
       +
       

     

       28
       28
       +
           def commit_changes(self, message: str) -> bool:

     

       29
       29
       +
               """Commit all pending changes."""

     

       30
       30
       +
               try:

     

       31
       31
       +
                   self.git_store.commit_changes(message)

     

       32
       32
       +
                   return True

     

       33
       33
       +
               except Exception:

     

       34
       34
       +
                   return False

     

       35
       35
       +
       

     

       36
       36
       +
           def get_status(self) -> dict:

     

       37
       37
       +
               """Get repository status and statistics."""

     

       38
       38
       +
               try:

     

       39
       39
       +
                   stats = self.git_store.get_stats()

     

       40
       40
       +
                   

     

       41
       41
       +
                   # Add repository-specific information

     

       42
       42
       +
                   repo_status = {

     

       43
       43
       +
                       **stats,

     

       44
       44
       +
                       'repository_path': str(self.config.git_store),

     

       45
       45
       +
                       'cache_path': str(self.config.cache_dir),

     

       46
       46
       +
                       'has_uncommitted_changes': self._has_uncommitted_changes(),

     

       47
       47
       +
                       'last_commit': self._get_last_commit_info(),

     

       48
       48
       +
                   }

     

       49
       49
       +
                   

     

       50
       50
       +
                   return repo_status

     

       51
       51
       +
               except Exception as e:

     

       52
       52
       +
                   return {'error': str(e)}

     

       53
       53
       +
       

     

       54
       54
       +
           def backup_repository(self, backup_path: Path) -> bool:

     

       55
       55
       +
               """Create a backup of the repository."""

     

       56
       56
       +
               try:

     

       57
       57
       +
                   if backup_path.exists():

     

       58
       58
       +
                       shutil.rmtree(backup_path)

     

       59
       59
       +
                   

     

       60
       60
       +
                   shutil.copytree(self.config.git_store, backup_path)

     

       61
       61
       +
                   return True

     

       62
       62
       +
               except Exception:

     

       63
       63
       +
                   return False

     

       64
       64
       +
       

     

       65
       65
       +
           def cleanup_cache(self) -> bool:

     

       66
       66
       +
               """Clean up cache directory."""

     

       67
       67
       +
               try:

     

       68
       68
       +
                   if self.config.cache_dir.exists():

     

       69
       69
       +
                       shutil.rmtree(self.config.cache_dir)

     

       70
       70
       +
                   self.config.cache_dir.mkdir(parents=True, exist_ok=True)

     

       71
       71
       +
                   return True

     

       72
       72
       +
               except Exception:

     

       73
       73
       +
                   return False

     

       74
       74
       +
       

     

       75
       75
       +
           def get_repository_size(self) -> dict:

     

       76
       76
       +
               """Get detailed repository size information."""

     

       77
       77
       +
               try:

     

       78
       78
       +
                   total_size = 0

     

       79
       79
       +
                   file_count = 0

     

       80
       80
       +
                   dir_count = 0

     

       81
       81
       +
                   

     

       82
       82
       +
                   for path in self.config.git_store.rglob("*"):

     

       83
       83
       +
                       if path.is_file():

     

       84
       84
       +
                           total_size += path.stat().st_size

     

       85
       85
       +
                           file_count += 1

     

       86
       86
       +
                       elif path.is_dir():

     

       87
       87
       +
                           dir_count += 1

     

       88
       88
       +
                   

     

       89
       89
       +
                   return {

     

       90
       90
       +
                       'total_size_bytes': total_size,

     

       91
       91
       +
                       'total_size_mb': round(total_size / (1024 * 1024), 2),

     

       92
       92
       +
                       'file_count': file_count,

     

       93
       93
       +
                       'directory_count': dir_count,

     

       94
       94
       +
                   }

     

       95
       95
       +
               except Exception as e:

     

       96
       96
       +
                   return {'error': str(e)}

     

       97
       97
       +
       

     

       98
       98
       +
           def _has_uncommitted_changes(self) -> bool:

     

       99
       99
       +
               """Check if there are uncommitted changes."""

     

       100
       100
       +
               try:

     

       101
       101
       +
                   if not self.git_store.repo:

     

       102
       102
       +
                       return False

     

       103
       103
       +
                   return bool(self.git_store.repo.index.diff("HEAD") or self.git_store.repo.untracked_files)

     

       104
       104
       +
               except Exception:

     

       105
       105
       +
                   return False

     

       106
       106
       +
       

     

       107
       107
       +
           def _get_last_commit_info(self) -> Optional[dict]:

     

       108
       108
       +
               """Get information about the last commit."""

     

       109
       109
       +
               try:

     

       110
       110
       +
                   if not self.git_store.repo:

     

       111
       111
       +
                       return None

     

       112
       112
       +
                       

     

       113
       113
       +
                   last_commit = self.git_store.repo.head.commit

     

       114
       114
       +
                   return {

     

       115
       115
       +
                       'hash': last_commit.hexsha[:8],

     

       116
       116
       +
                       'message': last_commit.message.strip(),

     

       117
       117
       +
                       'author': str(last_commit.author),

     

       118
       118
       +
                       'date': datetime.fromtimestamp(last_commit.committed_date).isoformat(),

     

       119
       119
       +
                   }

     

       120
       120
       +
               except Exception:

     

       121
       121
       +
                   return None

     

       122
       122
       +
       

     

       123
       123
       +
           def verify_integrity(self) -> dict:

     

       124
       124
       +
               """Verify repository integrity."""

     

       125
       125
       +
               issues = []

     

       126
       126
       +
               

     

       127
       127
       +
               # Check if git repository is valid

     

       128
       128
       +
               try:

     

       129
       129
       +
                   if not self.git_store.repo:

     

       130
       130
       +
                       issues.append("Git repository not initialized")

     

       131
       131
       +
               except Exception as e:

     

       132
       132
       +
                   issues.append(f"Git repository error: {e}")

     

       133
       133
       +
               

     

       134
       134
       +
               # Check if index.json exists and is valid

     

       135
       135
       +
               index_path = self.config.git_store / "index.json"

     

       136
       136
       +
               if not index_path.exists():

     

       137
       137
       +
                   issues.append("index.json missing")

     

       138
       138
       +
               else:

     

       139
       139
       +
                   try:

     

       140
       140
       +
                       self.git_store._load_index()

     

       141
       141
       +
                   except Exception as e:

     

       142
       142
       +
                       issues.append(f"index.json corrupted: {e}")

     

       143
       143
       +
               

     

       144
       144
       +
               # Check if duplicates.json exists

     

       145
       145
       +
               duplicates_path = self.config.git_store / "duplicates.json"

     

       146
       146
       +
               if not duplicates_path.exists():

     

       147
       147
       +
                   issues.append("duplicates.json missing")

     

       148
       148
       +
               else:

     

       149
       149
       +
                   try:

     

       150
       150
       +
                       self.git_store._load_duplicates()

     

       151
       151
       +
                   except Exception as e:

     

       152
       152
       +
                       issues.append(f"duplicates.json corrupted: {e}")

     

       153
       153
       +
               

     

       154
       154
       +
               return {

     

       155
       155
       +
                   'is_valid': len(issues) == 0,

     

       156
       156
       +
                   'issues': issues,

     

       157
       157
       +
                   'checked_at': datetime.now().isoformat(),

     

       158
       158
       +
               }

+319

src/thicket/subsystems/site.py

···

       1
       1
       +
       """Site generation subsystem."""

     

       2
       2
       +
       

     

       3
       3
       +
       import json

     

       4
       4
       +
       import shutil

     

       5
       5
       +
       from datetime import datetime

     

       6
       6
       +
       from pathlib import Path

     

       7
       7
       +
       from typing import Optional

     

       8
       8
       +
       

     

       9
       9
       +
       from jinja2 import Environment, FileSystemLoader, select_autoescape

     

       10
       10
       +
       

     

       11
       11
       +
       from ..core.git_store import GitStore

     

       12
       12
       +
       from ..models import ThicketConfig

     

       13
       13
       +
       

     

       14
       14
       +
       

     

       15
       15
       +
       class SiteGenerator:

     

       16
       16
       +
           """Generates static sites from stored entries."""

     

       17
       17
       +
       

     

       18
       18
       +
           def __init__(self, git_store: GitStore, config: ThicketConfig):

     

       19
       19
       +
               """Initialize site generator."""

     

       20
       20
       +
               self.git_store = git_store

     

       21
       21
       +
               self.config = config

     

       22
       22
       +
               self.default_template_dir = Path(__file__).parent.parent / "templates"

     

       23
       23
       +
       

     

       24
       24
       +
           def generate_site(self, output_dir: Path, template_dir: Optional[Path] = None) -> bool:

     

       25
       25
       +
               """Generate complete static site."""

     

       26
       26
       +
               try:

     

       27
       27
       +
                   # Setup template environment

     

       28
       28
       +
                   template_dir = template_dir or self.default_template_dir

     

       29
       29
       +
                   if not template_dir.exists():

     

       30
       30
       +
                       return False

     

       31
       31
       +
                   

     

       32
       32
       +
                   env = Environment(

     

       33
       33
       +
                       loader=FileSystemLoader(str(template_dir)),

     

       34
       34
       +
                       autoescape=select_autoescape(['html', 'xml'])

     

       35
       35
       +
                   )

     

       36
       36
       +
                   

     

       37
       37
       +
                   # Prepare output directory

     

       38
       38
       +
                   output_dir.mkdir(parents=True, exist_ok=True)

     

       39
       39
       +
                   

     

       40
       40
       +
                   # Copy static assets

     

       41
       41
       +
                   self._copy_static_assets(template_dir, output_dir)

     

       42
       42
       +
                   

     

       43
       43
       +
                   # Generate pages

     

       44
       44
       +
                   self._generate_index_page(env, output_dir)

     

       45
       45
       +
                   self._generate_timeline_page(env, output_dir)

     

       46
       46
       +
                   self._generate_users_page(env, output_dir)

     

       47
       47
       +
                   self._generate_links_page(env, output_dir)

     

       48
       48
       +
                   self._generate_user_detail_pages(env, output_dir)

     

       49
       49
       +
                   

     

       50
       50
       +
                   return True

     

       51
       51
       +
               except Exception:

     

       52
       52
       +
                   return False

     

       53
       53
       +
       

     

       54
       54
       +
           def generate_timeline(self, output_path: Path, limit: Optional[int] = None) -> bool:

     

       55
       55
       +
               """Generate timeline HTML file."""

     

       56
       56
       +
               try:

     

       57
       57
       +
                   env = Environment(

     

       58
       58
       +
                       loader=FileSystemLoader(str(self.default_template_dir)),

     

       59
       59
       +
                       autoescape=select_autoescape(['html', 'xml'])

     

       60
       60
       +
                   )

     

       61
       61
       +
                   

     

       62
       62
       +
                   timeline_data = self._get_timeline_data(limit)

     

       63
       63
       +
                   template = env.get_template('timeline.html')

     

       64
       64
       +
                   

     

       65
       65
       +
                   content = template.render(**timeline_data)

     

       66
       66
       +
                   

     

       67
       67
       +
                   output_path.parent.mkdir(parents=True, exist_ok=True)

     

       68
       68
       +
                   with open(output_path, 'w', encoding='utf-8') as f:

     

       69
       69
       +
                       f.write(content)

     

       70
       70
       +
                   

     

       71
       71
       +
                   return True

     

       72
       72
       +
               except Exception:

     

       73
       73
       +
                   return False

     

       74
       74
       +
       

     

       75
       75
       +
           def generate_user_pages(self, output_dir: Path) -> bool:

     

       76
       76
       +
               """Generate individual user pages."""

     

       77
       77
       +
               try:

     

       78
       78
       +
                   env = Environment(

     

       79
       79
       +
                       loader=FileSystemLoader(str(self.default_template_dir)),

     

       80
       80
       +
                       autoescape=select_autoescape(['html', 'xml'])

     

       81
       81
       +
                   )

     

       82
       82
       +
                   

     

       83
       83
       +
                   return self._generate_user_detail_pages(env, output_dir)

     

       84
       84
       +
               except Exception:

     

       85
       85
       +
                   return False

     

       86
       86
       +
       

     

       87
       87
       +
           def _copy_static_assets(self, template_dir: Path, output_dir: Path):

     

       88
       88
       +
               """Copy CSS, JS, and other static assets."""

     

       89
       89
       +
               static_files = ['style.css', 'script.js']

     

       90
       90
       +
               

     

       91
       91
       +
               for filename in static_files:

     

       92
       92
       +
                   src_file = template_dir / filename

     

       93
       93
       +
                   if src_file.exists():

     

       94
       94
       +
                       dst_file = output_dir / filename

     

       95
       95
       +
                       shutil.copy2(src_file, dst_file)

     

       96
       96
       +
       

     

       97
       97
       +
           def _generate_index_page(self, env: Environment, output_dir: Path):

     

       98
       98
       +
               """Generate main index page."""

     

       99
       99
       +
               template = env.get_template('index.html')

     

       100
       100
       +
               

     

       101
       101
       +
               # Get summary statistics

     

       102
       102
       +
               stats = self.git_store.get_stats()

     

       103
       103
       +
               index = self.git_store._load_index()

     

       104
       104
       +
               

     

       105
       105
       +
               # Recent entries

     

       106
       106
       +
               recent_entries = []

     

       107
       107
       +
               for username in index.users.keys():

     

       108
       108
       +
                   user_entries = self.git_store.list_entries(username, limit=5)

     

       109
       109
       +
                   for entry in user_entries:

     

       110
       110
       +
                       recent_entries.append({

     

       111
       111
       +
                           'username': username,

     

       112
       112
       +
                           'entry': entry

     

       113
       113
       +
                       })

     

       114
       114
       +
               

     

       115
       115
       +
               # Sort by date

     

       116
       116
       +
               recent_entries.sort(key=lambda x: x['entry'].updated or x['entry'].published, reverse=True)

     

       117
       117
       +
               recent_entries = recent_entries[:10]

     

       118
       118
       +
               

     

       119
       119
       +
               context = {

     

       120
       120
       +
                   'title': 'Thicket Feed Archive',

     

       121
       121
       +
                   'stats': stats,

     

       122
       122
       +
                   'recent_entries': recent_entries,

     

       123
       123
       +
                   'users': list(index.users.values()),

     

       124
       124
       +
                   'generated_at': datetime.now().isoformat(),

     

       125
       125
       +
               }

     

       126
       126
       +
               

     

       127
       127
       +
               content = template.render(**context)

     

       128
       128
       +
               

     

       129
       129
       +
               with open(output_dir / 'index.html', 'w', encoding='utf-8') as f:

     

       130
       130
       +
                   f.write(content)

     

       131
       131
       +
       

     

       132
       132
       +
           def _generate_timeline_page(self, env: Environment, output_dir: Path):

     

       133
       133
       +
               """Generate timeline page."""

     

       134
       134
       +
               template = env.get_template('timeline.html')

     

       135
       135
       +
               timeline_data = self._get_timeline_data()

     

       136
       136
       +
               

     

       137
       137
       +
               content = template.render(**timeline_data)

     

       138
       138
       +
               

     

       139
       139
       +
               with open(output_dir / 'timeline.html', 'w', encoding='utf-8') as f:

     

       140
       140
       +
                   f.write(content)

     

       141
       141
       +
       

     

       142
       142
       +
           def _generate_users_page(self, env: Environment, output_dir: Path):

     

       143
       143
       +
               """Generate users overview page."""

     

       144
       144
       +
               template = env.get_template('users.html')

     

       145
       145
       +
               

     

       146
       146
       +
               index = self.git_store._load_index()

     

       147
       147
       +
               users_data = []

     

       148
       148
       +
               

     

       149
       149
       +
               for user_metadata in index.users.values():

     

       150
       150
       +
                   # Get user config for additional details

     

       151
       151
       +
                   user_config = next(

     

       152
       152
       +
                       (u for u in self.config.users if u.username == user_metadata.username), 

     

       153
       153
       +
                       None

     

       154
       154
       +
                   )

     

       155
       155
       +
                   

     

       156
       156
       +
                   # Get recent entries

     

       157
       157
       +
                   recent_entries = self.git_store.list_entries(user_metadata.username, limit=3)

     

       158
       158
       +
                   

     

       159
       159
       +
                   users_data.append({

     

       160
       160
       +
                       'metadata': user_metadata,

     

       161
       161
       +
                       'config': user_config,

     

       162
       162
       +
                       'recent_entries': recent_entries,

     

       163
       163
       +
                   })

     

       164
       164
       +
               

     

       165
       165
       +
               # Sort by entry count

     

       166
       166
       +
               users_data.sort(key=lambda x: x['metadata'].entry_count, reverse=True)

     

       167
       167
       +
               

     

       168
       168
       +
               context = {

     

       169
       169
       +
                   'title': 'Users',

     

       170
       170
       +
                   'users': users_data,

     

       171
       171
       +
                   'generated_at': datetime.now().isoformat(),

     

       172
       172
       +
               }

     

       173
       173
       +
               

     

       174
       174
       +
               content = template.render(**context)

     

       175
       175
       +
               

     

       176
       176
       +
               with open(output_dir / 'users.html', 'w', encoding='utf-8') as f:

     

       177
       177
       +
                   f.write(content)

     

       178
       178
       +
       

     

       179
       179
       +
           def _generate_links_page(self, env: Environment, output_dir: Path):

     

       180
       180
       +
               """Generate links overview page."""

     

       181
       181
       +
               template = env.get_template('links.html')

     

       182
       182
       +
               

     

       183
       183
       +
               # Load links data

     

       184
       184
       +
               links_file = self.git_store.repo_path / "links.json"

     

       185
       185
       +
               url_mapping_file = self.git_store.repo_path / "url_mapping.json"

     

       186
       186
       +
               

     

       187
       187
       +
               links_data = {}

     

       188
       188
       +
               url_mapping = {}

     

       189
       189
       +
               

     

       190
       190
       +
               if links_file.exists():

     

       191
       191
       +
                   try:

     

       192
       192
       +
                       with open(links_file) as f:

     

       193
       193
       +
                           links_data = json.load(f)

     

       194
       194
       +
                   except Exception:

     

       195
       195
       +
                       pass

     

       196
       196
       +
               

     

       197
       197
       +
               if url_mapping_file.exists():

     

       198
       198
       +
                   try:

     

       199
       199
       +
                       with open(url_mapping_file) as f:

     

       200
       200
       +
                           url_mapping = json.load(f)

     

       201
       201
       +
                   except Exception:

     

       202
       202
       +
                       pass

     

       203
       203
       +
               

     

       204
       204
       +
               # Process most referenced URLs

     

       205
       205
       +
               url_counts = [(url, len(refs)) for url, refs in url_mapping.items()]

     

       206
       206
       +
               url_counts.sort(key=lambda x: x[1], reverse=True)

     

       207
       207
       +
               most_referenced = url_counts[:20]

     

       208
       208
       +
               

     

       209
       209
       +
               # Count links by type

     

       210
       210
       +
               link_stats = {

     

       211
       211
       +
                   'total_entries_with_links': len(links_data),

     

       212
       212
       +
                   'total_links': sum(len(entry_data.get('links', [])) for entry_data in links_data.values()),

     

       213
       213
       +
                   'unique_urls': len(url_mapping),

     

       214
       214
       +
               }

     

       215
       215
       +
               

     

       216
       216
       +
               context = {

     

       217
       217
       +
                   'title': 'Links',

     

       218
       218
       +
                   'most_referenced': most_referenced,

     

       219
       219
       +
                   'url_mapping': url_mapping,

     

       220
       220
       +
                   'link_stats': link_stats,

     

       221
       221
       +
                   'generated_at': datetime.now().isoformat(),

     

       222
       222
       +
               }

     

       223
       223
       +
               

     

       224
       224
       +
               content = template.render(**context)

     

       225
       225
       +
               

     

       226
       226
       +
               with open(output_dir / 'links.html', 'w', encoding='utf-8') as f:

     

       227
       227
       +
                   f.write(content)

     

       228
       228
       +
       

     

       229
       229
       +
           def _generate_user_detail_pages(self, env: Environment, output_dir: Path) -> bool:

     

       230
       230
       +
               """Generate individual user detail pages."""

     

       231
       231
       +
               try:

     

       232
       232
       +
                   template = env.get_template('user_detail.html')

     

       233
       233
       +
                   index = self.git_store._load_index()

     

       234
       234
       +
                   

     

       235
       235
       +
                   # Create users subdirectory

     

       236
       236
       +
                   users_dir = output_dir / 'users'

     

       237
       237
       +
                   users_dir.mkdir(exist_ok=True)

     

       238
       238
       +
                   

     

       239
       239
       +
                   for user_metadata in index.users.values():

     

       240
       240
       +
                       user_config = next(

     

       241
       241
       +
                           (u for u in self.config.users if u.username == user_metadata.username), 

     

       242
       242
       +
                           None

     

       243
       243
       +
                       )

     

       244
       244
       +
                       

     

       245
       245
       +
                       entries = self.git_store.list_entries(user_metadata.username)

     

       246
       246
       +
                       

     

       247
       247
       +
                       # Get user's links

     

       248
       248
       +
                       links_file = self.git_store.repo_path / "links.json"

     

       249
       249
       +
                       user_links = []

     

       250
       250
       +
                       if links_file.exists():

     

       251
       251
       +
                           try:

     

       252
       252
       +
                               with open(links_file) as f:

     

       253
       253
       +
                                   all_links = json.load(f)

     

       254
       254
       +
                               user_links = [

     

       255
       255
       +
                                   data for key, data in all_links.items() 

     

       256
       256
       +
                                   if data.get('username') == user_metadata.username

     

       257
       257
       +
                               ]

     

       258
       258
       +
                           except Exception:

     

       259
       259
       +
                               pass

     

       260
       260
       +
                       

     

       261
       261
       +
                       context = {

     

       262
       262
       +
                           'title': f"{user_metadata.display_name or user_metadata.username}",

     

       263
       263
       +
                           'user_metadata': user_metadata,

     

       264
       264
       +
                           'user_config': user_config,

     

       265
       265
       +
                           'entries': entries,

     

       266
       266
       +
                           'user_links': user_links,

     

       267
       267
       +
                           'generated_at': datetime.now().isoformat(),

     

       268
       268
       +
                       }

     

       269
       269
       +
                       

     

       270
       270
       +
                       content = template.render(**context)

     

       271
       271
       +
                       

     

       272
       272
       +
                       user_file = users_dir / f"{user_metadata.username}.html"

     

       273
       273
       +
                       with open(user_file, 'w', encoding='utf-8') as f:

     

       274
       274
       +
                           f.write(content)

     

       275
       275
       +
                   

     

       276
       276
       +
                   return True

     

       277
       277
       +
               except Exception:

     

       278
       278
       +
                   return False

     

       279
       279
       +
       

     

       280
       280
       +
           def _get_timeline_data(self, limit: Optional[int] = None) -> dict:

     

       281
       281
       +
               """Get data for timeline page."""

     

       282
       282
       +
               index = self.git_store._load_index()

     

       283
       283
       +
               

     

       284
       284
       +
               # Collect all entries with metadata

     

       285
       285
       +
               all_entries = []

     

       286
       286
       +
               for user_metadata in index.users.values():

     

       287
       287
       +
                   user_entries = self.git_store.list_entries(user_metadata.username)

     

       288
       288
       +
                   for entry in user_entries:

     

       289
       289
       +
                       all_entries.append({

     

       290
       290
       +
                           'username': user_metadata.username,

     

       291
       291
       +
                           'display_name': user_metadata.display_name,

     

       292
       292
       +
                           'entry': entry,

     

       293
       293
       +
                       })

     

       294
       294
       +
               

     

       295
       295
       +
               # Sort by date (newest first)

     

       296
       296
       +
               all_entries.sort(

     

       297
       297
       +
                   key=lambda x: x['entry'].updated or x['entry'].published or datetime.min, 

     

       298
       298
       +
                   reverse=True

     

       299
       299
       +
               )

     

       300
       300
       +
               

     

       301
       301
       +
               if limit:

     

       302
       302
       +
                   all_entries = all_entries[:limit]

     

       303
       303
       +
               

     

       304
       304
       +
               # Group by date for timeline display

     

       305
       305
       +
               timeline_groups = {}

     

       306
       306
       +
               for item in all_entries:

     

       307
       307
       +
                   entry_date = item['entry'].updated or item['entry'].published

     

       308
       308
       +
                   if entry_date:

     

       309
       309
       +
                       date_key = entry_date.strftime('%Y-%m-%d')

     

       310
       310
       +
                       if date_key not in timeline_groups:

     

       311
       311
       +
                           timeline_groups[date_key] = []

     

       312
       312
       +
                       timeline_groups[date_key].append(item)

     

       313
       313
       +
               

     

       314
       314
       +
               return {

     

       315
       315
       +
                   'title': 'Timeline',

     

       316
       316
       +
                   'timeline_groups': timeline_groups,

     

       317
       317
       +
                   'total_entries': len(all_entries),

     

       318
       318
       +
                   'generated_at': datetime.now().isoformat(),

     

       319
       319
       +
               }

+254

src/thicket/subsystems/users.py

···

       1
       1
       +
       """User management subsystem."""

     

       2
       2
       +
       

     

       3
       3
       +
       import shutil

     

       4
       4
       +
       from typing import Optional

     

       5
       5
       +
       

     

       6
       6
       +
       from pydantic import EmailStr, HttpUrl, ValidationError

     

       7
       7
       +
       

     

       8
       8
       +
       from ..core.git_store import GitStore

     

       9
       9
       +
       from ..models import ThicketConfig, UserConfig, UserMetadata

     

       10
       10
       +
       

     

       11
       11
       +
       

     

       12
       12
       +
       class UserManager:

     

       13
       13
       +
           """Manages user operations and metadata."""

     

       14
       14
       +
       

     

       15
       15
       +
           def __init__(self, git_store: GitStore, config: ThicketConfig):

     

       16
       16
       +
               """Initialize user manager."""

     

       17
       17
       +
               self.git_store = git_store

     

       18
       18
       +
               self.config = config

     

       19
       19
       +
       

     

       20
       20
       +
           def add_user(self, username: str, feeds: list[str], **kwargs) -> UserConfig:

     

       21
       21
       +
               """Add a new user with feeds."""

     

       22
       22
       +
               # Validate feeds

     

       23
       23
       +
               validated_feeds = []

     

       24
       24
       +
               for feed in feeds:

     

       25
       25
       +
                   try:

     

       26
       26
       +
                       validated_feeds.append(HttpUrl(feed))

     

       27
       27
       +
                   except ValidationError as e:

     

       28
       28
       +
                       raise ValueError(f"Invalid feed URL '{feed}': {e}")

     

       29
       29
       +
               

     

       30
       30
       +
               # Validate optional fields

     

       31
       31
       +
               email = None

     

       32
       32
       +
               if 'email' in kwargs and kwargs['email']:

     

       33
       33
       +
                   try:

     

       34
       34
       +
                       email = EmailStr(kwargs['email'])

     

       35
       35
       +
                   except ValidationError as e:

     

       36
       36
       +
                       raise ValueError(f"Invalid email '{kwargs['email']}': {e}")

     

       37
       37
       +
               

     

       38
       38
       +
               homepage = None

     

       39
       39
       +
               if 'homepage' in kwargs and kwargs['homepage']:

     

       40
       40
       +
                   try:

     

       41
       41
       +
                       homepage = HttpUrl(kwargs['homepage'])

     

       42
       42
       +
                   except ValidationError as e:

     

       43
       43
       +
                       raise ValueError(f"Invalid homepage URL '{kwargs['homepage']}': {e}")

     

       44
       44
       +
               

     

       45
       45
       +
               icon = None

     

       46
       46
       +
               if 'icon' in kwargs and kwargs['icon']:

     

       47
       47
       +
                   try:

     

       48
       48
       +
                       icon = HttpUrl(kwargs['icon'])

     

       49
       49
       +
                   except ValidationError as e:

     

       50
       50
       +
                       raise ValueError(f"Invalid icon URL '{kwargs['icon']}': {e}")

     

       51
       51
       +
               

     

       52
       52
       +
               # Create user config

     

       53
       53
       +
               user_config = UserConfig(

     

       54
       54
       +
                   username=username,

     

       55
       55
       +
                   feeds=validated_feeds,

     

       56
       56
       +
                   email=email,

     

       57
       57
       +
                   homepage=homepage,

     

       58
       58
       +
                   icon=icon,

     

       59
       59
       +
                   display_name=kwargs.get('display_name')

     

       60
       60
       +
               )

     

       61
       61
       +
               

     

       62
       62
       +
               # Add to git store

     

       63
       63
       +
               self.git_store.add_user(

     

       64
       64
       +
                   username=username,

     

       65
       65
       +
                   display_name=user_config.display_name,

     

       66
       66
       +
                   email=str(user_config.email) if user_config.email else None,

     

       67
       67
       +
                   homepage=str(user_config.homepage) if user_config.homepage else None,

     

       68
       68
       +
                   icon=str(user_config.icon) if user_config.icon else None,

     

       69
       69
       +
                   feeds=[str(feed) for feed in user_config.feeds]

     

       70
       70
       +
               )

     

       71
       71
       +
               

     

       72
       72
       +
               # Add to config if not already present

     

       73
       73
       +
               existing_user = next((u for u in self.config.users if u.username == username), None)

     

       74
       74
       +
               if not existing_user:

     

       75
       75
       +
                   self.config.users.append(user_config)

     

       76
       76
       +
               else:

     

       77
       77
       +
                   # Update existing config

     

       78
       78
       +
                   existing_user.feeds = user_config.feeds

     

       79
       79
       +
                   existing_user.email = user_config.email

     

       80
       80
       +
                   existing_user.homepage = user_config.homepage

     

       81
       81
       +
                   existing_user.icon = user_config.icon

     

       82
       82
       +
                   existing_user.display_name = user_config.display_name

     

       83
       83
       +
               

     

       84
       84
       +
               return user_config

     

       85
       85
       +
       

     

       86
       86
       +
           def get_user(self, username: str) -> Optional[UserConfig]:

     

       87
       87
       +
               """Get user configuration."""

     

       88
       88
       +
               return next((u for u in self.config.users if u.username == username), None)

     

       89
       89
       +
       

     

       90
       90
       +
           def get_user_metadata(self, username: str) -> Optional[UserMetadata]:

     

       91
       91
       +
               """Get user metadata from git store."""

     

       92
       92
       +
               return self.git_store.get_user(username)

     

       93
       93
       +
       

     

       94
       94
       +
           def list_users(self) -> list[UserConfig]:

     

       95
       95
       +
               """List all configured users."""

     

       96
       96
       +
               return self.config.users.copy()

     

       97
       97
       +
       

     

       98
       98
       +
           def list_users_with_metadata(self) -> list[tuple[UserConfig, Optional[UserMetadata]]]:

     

       99
       99
       +
               """List users with their git store metadata."""

     

       100
       100
       +
               result = []

     

       101
       101
       +
               for user_config in self.config.users:

     

       102
       102
       +
                   metadata = self.git_store.get_user(user_config.username)

     

       103
       103
       +
                   result.append((user_config, metadata))

     

       104
       104
       +
               return result

     

       105
       105
       +
       

     

       106
       106
       +
           def update_user(self, username: str, **kwargs) -> bool:

     

       107
       107
       +
               """Update user configuration."""

     

       108
       108
       +
               # Update in config

     

       109
       109
       +
               user_config = self.get_user(username)

     

       110
       110
       +
               if not user_config:

     

       111
       111
       +
                   return False

     

       112
       112
       +
               

     

       113
       113
       +
               # Validate and update feeds if provided

     

       114
       114
       +
               if 'feeds' in kwargs:

     

       115
       115
       +
                   validated_feeds = []

     

       116
       116
       +
                   for feed in kwargs['feeds']:

     

       117
       117
       +
                       try:

     

       118
       118
       +
                           validated_feeds.append(HttpUrl(feed))

     

       119
       119
       +
                       except ValidationError:

     

       120
       120
       +
                           return False

     

       121
       121
       +
                   user_config.feeds = validated_feeds

     

       122
       122
       +
               

     

       123
       123
       +
               # Validate and update other fields

     

       124
       124
       +
               if 'email' in kwargs and kwargs['email']:

     

       125
       125
       +
                   try:

     

       126
       126
       +
                       user_config.email = EmailStr(kwargs['email'])

     

       127
       127
       +
                   except ValidationError:

     

       128
       128
       +
                       return False

     

       129
       129
       +
               elif 'email' in kwargs and not kwargs['email']:

     

       130
       130
       +
                   user_config.email = None

     

       131
       131
       +
               

     

       132
       132
       +
               if 'homepage' in kwargs and kwargs['homepage']:

     

       133
       133
       +
                   try:

     

       134
       134
       +
                       user_config.homepage = HttpUrl(kwargs['homepage'])

     

       135
       135
       +
                   except ValidationError:

     

       136
       136
       +
                       return False

     

       137
       137
       +
               elif 'homepage' in kwargs and not kwargs['homepage']:

     

       138
       138
       +
                   user_config.homepage = None

     

       139
       139
       +
               

     

       140
       140
       +
               if 'icon' in kwargs and kwargs['icon']:

     

       141
       141
       +
                   try:

     

       142
       142
       +
                       user_config.icon = HttpUrl(kwargs['icon'])

     

       143
       143
       +
                   except ValidationError:

     

       144
       144
       +
                       return False

     

       145
       145
       +
               elif 'icon' in kwargs and not kwargs['icon']:

     

       146
       146
       +
                   user_config.icon = None

     

       147
       147
       +
               

     

       148
       148
       +
               if 'display_name' in kwargs:

     

       149
       149
       +
                   user_config.display_name = kwargs['display_name'] or None

     

       150
       150
       +
               

     

       151
       151
       +
               # Update in git store

     

       152
       152
       +
               git_kwargs = {}

     

       153
       153
       +
               if 'feeds' in kwargs:

     

       154
       154
       +
                   git_kwargs['feeds'] = [str(feed) for feed in user_config.feeds]

     

       155
       155
       +
               if user_config.email:

     

       156
       156
       +
                   git_kwargs['email'] = str(user_config.email)

     

       157
       157
       +
               if user_config.homepage:

     

       158
       158
       +
                   git_kwargs['homepage'] = str(user_config.homepage)

     

       159
       159
       +
               if user_config.icon:

     

       160
       160
       +
                   git_kwargs['icon'] = str(user_config.icon)

     

       161
       161
       +
               if user_config.display_name:

     

       162
       162
       +
                   git_kwargs['display_name'] = user_config.display_name

     

       163
       163
       +
               

     

       164
       164
       +
               return self.git_store.update_user(username, **git_kwargs)

     

       165
       165
       +
       

     

       166
       166
       +
           def remove_user(self, username: str) -> bool:

     

       167
       167
       +
               """Remove a user and their data."""

     

       168
       168
       +
               # Remove from config

     

       169
       169
       +
               self.config.users = [u for u in self.config.users if u.username != username]

     

       170
       170
       +
               

     

       171
       171
       +
               # Remove user directory from git store

     

       172
       172
       +
               user_metadata = self.git_store.get_user(username)

     

       173
       173
       +
               if user_metadata:

     

       174
       174
       +
                   user_dir = self.git_store.repo_path / user_metadata.directory

     

       175
       175
       +
                   if user_dir.exists():

     

       176
       176
       +
                       try:

     

       177
       177
       +
                           shutil.rmtree(user_dir)

     

       178
       178
       +
                       except Exception:

     

       179
       179
       +
                           return False

     

       180
       180
       +
               

     

       181
       181
       +
               # Remove user from index

     

       182
       182
       +
               index = self.git_store._load_index()

     

       183
       183
       +
               if username in index.users:

     

       184
       184
       +
                   del index.users[username]

     

       185
       185
       +
                   self.git_store._save_index(index)

     

       186
       186
       +
               

     

       187
       187
       +
               return True

     

       188
       188
       +
       

     

       189
       189
       +
           def get_user_stats(self, username: str) -> Optional[dict]:

     

       190
       190
       +
               """Get statistics for a specific user."""

     

       191
       191
       +
               user_metadata = self.git_store.get_user(username)

     

       192
       192
       +
               if not user_metadata:

     

       193
       193
       +
                   return None

     

       194
       194
       +
               

     

       195
       195
       +
               user_config = self.get_user(username)

     

       196
       196
       +
               entries = self.git_store.list_entries(username)

     

       197
       197
       +
               

     

       198
       198
       +
               return {

     

       199
       199
       +
                   'username': username,

     

       200
       200
       +
                   'display_name': user_metadata.display_name,

     

       201
       201
       +
                   'entry_count': user_metadata.entry_count,

     

       202
       202
       +
                   'feeds_configured': len(user_config.feeds) if user_config else 0,

     

       203
       203
       +
                   'directory': user_metadata.directory,

     

       204
       204
       +
                   'created': user_metadata.created.isoformat() if user_metadata.created else None,

     

       205
       205
       +
                   'last_updated': user_metadata.last_updated.isoformat() if user_metadata.last_updated else None,

     

       206
       206
       +
                   'latest_entry': entries[0].updated.isoformat() if entries else None,

     

       207
       207
       +
               }

     

       208
       208
       +
       

     

       209
       209
       +
           def validate_user_feeds(self, username: str) -> dict:

     

       210
       210
       +
               """Validate all feeds for a user."""

     

       211
       211
       +
               user_config = self.get_user(username)

     

       212
       212
       +
               if not user_config:

     

       213
       213
       +
                   return {'error': 'User not found'}

     

       214
       214
       +
               

     

       215
       215
       +
               results = {

     

       216
       216
       +
                   'username': username,

     

       217
       217
       +
                   'total_feeds': len(user_config.feeds),

     

       218
       218
       +
                   'valid_feeds': [],

     

       219
       219
       +
                   'invalid_feeds': [],

     

       220
       220
       +
               }

     

       221
       221
       +
               

     

       222
       222
       +
               for feed_url in user_config.feeds:

     

       223
       223
       +
                   try:

     

       224
       224
       +
                       # Basic URL validation - more comprehensive validation would require fetching

     

       225
       225
       +
                       HttpUrl(str(feed_url))

     

       226
       226
       +
                       results['valid_feeds'].append(str(feed_url))

     

       227
       227
       +
                   except ValidationError as e:

     

       228
       228
       +
                       results['invalid_feeds'].append({

     

       229
       229
       +
                           'url': str(feed_url),

     

       230
       230
       +
                           'error': str(e)

     

       231
       231
       +
                       })

     

       232
       232
       +
               

     

       233
       233
       +
               results['is_valid'] = len(results['invalid_feeds']) == 0

     

       234
       234
       +
               

     

       235
       235
       +
               return results

     

       236
       236
       +
       

     

       237
       237
       +
           def sync_config_with_git_store(self) -> bool:

     

       238
       238
       +
               """Sync configuration users with git store."""

     

       239
       239
       +
               try:

     

       240
       240
       +
                   for user_config in self.config.users:

     

       241
       241
       +
                       git_user = self.git_store.get_user(user_config.username)

     

       242
       242
       +
                       if not git_user:

     

       243
       243
       +
                           # Add missing user to git store

     

       244
       244
       +
                           self.git_store.add_user(

     

       245
       245
       +
                               username=user_config.username,

     

       246
       246
       +
                               display_name=user_config.display_name,

     

       247
       247
       +
                               email=str(user_config.email) if user_config.email else None,

     

       248
       248
       +
                               homepage=str(user_config.homepage) if user_config.homepage else None,

     

       249
       249
       +
                               icon=str(user_config.icon) if user_config.icon else None,

     

       250
       250
       +
                               feeds=[str(feed) for feed in user_config.feeds]

     

       251
       251
       +
                           )

     

       252
       252
       +
                   return True

     

       253
       253
       +
               except Exception:

     

       254
       254
       +
                   return False

+31

src/thicket/templates/base.html

···

       1
       1
       +
       <!DOCTYPE html>

     

       2
       2
       +
       <html lang="en">

     

       3
       3
       +
       <head>

     

       4
       4
       +
           <meta charset="UTF-8">

     

       5
       5
       +
           <meta name="viewport" content="width=device-width, initial-scale=1.0">

     

       6
       6
       +
           <title>{% block page_title %}{{ title }}{% endblock %}</title>

     

       7
       7
       +
           <link rel="stylesheet" href="css/style.css">

     

       8
       8
       +
       </head>

     

       9
       9
       +
       <body>

     

       10
       10
       +
           <header class="site-header">

     

       11
       11
       +
               <div class="header-content">

     

       12
       12
       +
                   <h1 class="site-title">{{ title }}</h1>

     

       13
       13
       +
                   <nav class="site-nav">

     

       14
       14
       +
                       <a href="timeline.html" class="nav-link {% if page == 'timeline' %}active{% endif %}">Timeline</a>

     

       15
       15
       +
                       <a href="links.html" class="nav-link {% if page == 'links' %}active{% endif %}">Links</a>

     

       16
       16
       +
                       <a href="users.html" class="nav-link {% if page == 'users' %}active{% endif %}">Users</a>

     

       17
       17
       +
                   </nav>

     

       18
       18
       +
               </div>

     

       19
       19
       +
           </header>

     

       20
       20
       +
       

     

       21
       21
       +
           <main class="main-content">

     

       22
       22
       +
               {% block content %}{% endblock %}

     

       23
       23
       +
           </main>

     

       24
       24
       +
       

     

       25
       25
       +
           <footer class="site-footer">

     

       26
       26
       +
               <p>Generated on {{ generated_at }} by <a href="https://github.com/avsm/thicket">Thicket</a></p>

     

       27
       27
       +
           </footer>

     

       28
       28
       +
       

     

       29
       29
       +
           <script src="js/script.js"></script>

     

       30
       30
       +
       </body>

     

       31
       31
       +
       </html>

+13

src/thicket/templates/index.html

···

       1
       1
       +
       <!DOCTYPE html>

     

       2
       2
       +
       <html lang="en">

     

       3
       3
       +
       <head>

     

       4
       4
       +
           <meta charset="UTF-8">

     

       5
       5
       +
           <meta name="viewport" content="width=device-width, initial-scale=1.0">

     

       6
       6
       +
           <title>{{ title }}</title>

     

       7
       7
       +
           <meta http-equiv="refresh" content="0; url=timeline.html">

     

       8
       8
       +
           <link rel="canonical" href="timeline.html">

     

       9
       9
       +
       </head>

     

       10
       10
       +
       <body>

     

       11
       11
       +
           <p>Redirecting to <a href="timeline.html">Timeline</a>...</p>

     

       12
       12
       +
       </body>

     

       13
       13
       +
       </html>

+38

src/thicket/templates/links.html

···

       1
       1
       +
       {% extends "base.html" %}

     

       2
       2
       +
       

     

       3
       3
       +
       {% block page_title %}Outgoing Links - {{ title }}{% endblock %}

     

       4
       4
       +
       

     

       5
       5
       +
       {% block content %}

     

       6
       6
       +
       <div class="page-content">

     

       7
       7
       +
           <h2>Outgoing Links</h2>

     

       8
       8
       +
           <p class="page-description">External links referenced in blog posts, ordered by most recent reference.</p>

     

       9
       9
       +
           

     

       10
       10
       +
           {% for link in outgoing_links %}

     

       11
       11
       +
           <article class="link-group">

     

       12
       12
       +
               <h3 class="link-url">

     

       13
       13
       +
                   <a href="{{ link.url }}" target="_blank">{{ link.url|truncate(80) }}</a>

     

       14
       14
       +
                   {% if link.target_username %}

     

       15
       15
       +
                   <span class="target-user">({{ link.target_username }})</span>

     

       16
       16
       +
                   {% endif %}

     

       17
       17
       +
               </h3>

     

       18
       18
       +
               <div class="referencing-entries">

     

       19
       19
       +
                   <span class="ref-count">Referenced in {{ link.entries|length }} post(s):</span>

     

       20
       20
       +
                   <ul>

     

       21
       21
       +
                       {% for display_name, entry in link.entries[:5] %}

     

       22
       22
       +
                       <li>

     

       23
       23
       +
                           <span class="author">{{ display_name }}</span> - 

     

       24
       24
       +
                           <a href="{{ entry.link }}" target="_blank">{{ entry.title }}</a>

     

       25
       25
       +
                           <time datetime="{{ entry.updated or entry.published }}">

     

       26
       26
       +
                               ({{ (entry.updated or entry.published).strftime('%Y-%m-%d') }})

     

       27
       27
       +
                           </time>

     

       28
       28
       +
                       </li>

     

       29
       29
       +
                       {% endfor %}

     

       30
       30
       +
                       {% if link.entries|length > 5 %}

     

       31
       31
       +
                       <li class="more">... and {{ link.entries|length - 5 }} more</li>

     

       32
       32
       +
                       {% endif %}

     

       33
       33
       +
                   </ul>

     

       34
       34
       +
               </div>

     

       35
       35
       +
           </article>

     

       36
       36
       +
           {% endfor %}

     

       37
       37
       +
       </div>

     

       38
       38
       +
       {% endblock %}

+88

src/thicket/templates/script.js

···

       1
       1
       +
       // Enhanced functionality for thicket website

     

       2
       2
       +
       document.addEventListener('DOMContentLoaded', function() {

     

       3
       3
       +
           

     

       4
       4
       +
           // Enhance thread collapsing (optional feature)

     

       5
       5
       +
           const threadHeaders = document.querySelectorAll('.thread-header');

     

       6
       6
       +
           threadHeaders.forEach(header => {

     

       7
       7
       +
               header.style.cursor = 'pointer';

     

       8
       8
       +
               header.addEventListener('click', function() {

     

       9
       9
       +
                   const thread = this.parentElement;

     

       10
       10
       +
                   const entries = thread.querySelectorAll('.thread-entry');

     

       11
       11
       +
                   

     

       12
       12
       +
                   // Toggle visibility of all but the first entry

     

       13
       13
       +
                   for (let i = 1; i < entries.length; i++) {

     

       14
       14
       +
                       entries[i].style.display = entries[i].style.display === 'none' ? 'block' : 'none';

     

       15
       15
       +
                   }

     

       16
       16
       +
                   

     

       17
       17
       +
                   // Update thread count text

     

       18
       18
       +
                   const count = this.querySelector('.thread-count');

     

       19
       19
       +
                   if (entries[1] && entries[1].style.display === 'none') {

     

       20
       20
       +
                       count.textContent = count.textContent.replace('posts', 'posts (collapsed)');

     

       21
       21
       +
                   } else {

     

       22
       22
       +
                       count.textContent = count.textContent.replace(' (collapsed)', '');

     

       23
       23
       +
                   }

     

       24
       24
       +
               });

     

       25
       25
       +
           });

     

       26
       26
       +
           

     

       27
       27
       +
           // Add relative time display

     

       28
       28
       +
           const timeElements = document.querySelectorAll('time');

     

       29
       29
       +
           timeElements.forEach(timeEl => {

     

       30
       30
       +
               const datetime = new Date(timeEl.getAttribute('datetime'));

     

       31
       31
       +
               const now = new Date();

     

       32
       32
       +
               const diffMs = now - datetime;

     

       33
       33
       +
               const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));

     

       34
       34
       +
               

     

       35
       35
       +
               let relativeTime;

     

       36
       36
       +
               if (diffDays === 0) {

     

       37
       37
       +
                   const diffHours = Math.floor(diffMs / (1000 * 60 * 60));

     

       38
       38
       +
                   if (diffHours === 0) {

     

       39
       39
       +
                       const diffMinutes = Math.floor(diffMs / (1000 * 60));

     

       40
       40
       +
                       relativeTime = diffMinutes === 0 ? 'just now' : `${diffMinutes}m ago`;

     

       41
       41
       +
                   } else {

     

       42
       42
       +
                       relativeTime = `${diffHours}h ago`;

     

       43
       43
       +
                   }

     

       44
       44
       +
               } else if (diffDays === 1) {

     

       45
       45
       +
                   relativeTime = 'yesterday';

     

       46
       46
       +
               } else if (diffDays < 7) {

     

       47
       47
       +
                   relativeTime = `${diffDays}d ago`;

     

       48
       48
       +
               } else if (diffDays < 30) {

     

       49
       49
       +
                   const weeks = Math.floor(diffDays / 7);

     

       50
       50
       +
                   relativeTime = weeks === 1 ? '1w ago' : `${weeks}w ago`;

     

       51
       51
       +
               } else if (diffDays < 365) {

     

       52
       52
       +
                   const months = Math.floor(diffDays / 30);

     

       53
       53
       +
                   relativeTime = months === 1 ? '1mo ago' : `${months}mo ago`;

     

       54
       54
       +
               } else {

     

       55
       55
       +
                   const years = Math.floor(diffDays / 365);

     

       56
       56
       +
                   relativeTime = years === 1 ? '1y ago' : `${years}y ago`;

     

       57
       57
       +
               }

     

       58
       58
       +
               

     

       59
       59
       +
               // Add relative time as title attribute

     

       60
       60
       +
               timeEl.setAttribute('title', timeEl.textContent);

     

       61
       61
       +
               timeEl.textContent = relativeTime;

     

       62
       62
       +
           });

     

       63
       63
       +
           

     

       64
       64
       +
           // Enhanced anchor link scrolling for shared references

     

       65
       65
       +
           document.querySelectorAll('a[href^="#"]').forEach(anchor => {

     

       66
       66
       +
               anchor.addEventListener('click', function (e) {

     

       67
       67
       +
                   e.preventDefault();

     

       68
       68
       +
                   const target = document.querySelector(this.getAttribute('href'));

     

       69
       69
       +
                   if (target) {

     

       70
       70
       +
                       target.scrollIntoView({

     

       71
       71
       +
                           behavior: 'smooth',

     

       72
       72
       +
                           block: 'center'

     

       73
       73
       +
                       });

     

       74
       74
       +
                       

     

       75
       75
       +
                       // Highlight the target briefly

     

       76
       76
       +
                       const timelineEntry = target.closest('.timeline-entry');

     

       77
       77
       +
                       if (timelineEntry) {

     

       78
       78
       +
                           timelineEntry.style.outline = '2px solid var(--primary-color)';

     

       79
       79
       +
                           timelineEntry.style.borderRadius = '8px';

     

       80
       80
       +
                           setTimeout(() => {

     

       81
       81
       +
                               timelineEntry.style.outline = '';

     

       82
       82
       +
                               timelineEntry.style.borderRadius = '';

     

       83
       83
       +
                           }, 2000);

     

       84
       84
       +
                       }

     

       85
       85
       +
                   }

     

       86
       86
       +
               });

     

       87
       87
       +
           });

     

       88
       88
       +
       });

+754

src/thicket/templates/style.css

···

       1
       1
       +
       /* Modern, clean design with high-density text and readable theme */

     

       2
       2
       +
       

     

       3
       3
       +
       :root {

     

       4
       4
       +
           --primary-color: #2c3e50;

     

       5
       5
       +
           --secondary-color: #3498db;

     

       6
       6
       +
           --accent-color: #e74c3c;

     

       7
       7
       +
           --background: #ffffff;

     

       8
       8
       +
           --surface: #f8f9fa;

     

       9
       9
       +
           --text-primary: #2c3e50;

     

       10
       10
       +
           --text-secondary: #7f8c8d;

     

       11
       11
       +
           --border-color: #e0e0e0;

     

       12
       12
       +
           --thread-indent: 20px;

     

       13
       13
       +
           --max-width: 1200px;

     

       14
       14
       +
       }

     

       15
       15
       +
       

     

       16
       16
       +
       * {

     

       17
       17
       +
           margin: 0;

     

       18
       18
       +
           padding: 0;

     

       19
       19
       +
           box-sizing: border-box;

     

       20
       20
       +
       }

     

       21
       21
       +
       

     

       22
       22
       +
       body {

     

       23
       23
       +
           font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Helvetica Neue', Arial, sans-serif;

     

       24
       24
       +
           font-size: 14px;

     

       25
       25
       +
           line-height: 1.6;

     

       26
       26
       +
           color: var(--text-primary);

     

       27
       27
       +
           background-color: var(--background);

     

       28
       28
       +
       }

     

       29
       29
       +
       

     

       30
       30
       +
       /* Header */

     

       31
       31
       +
       .site-header {

     

       32
       32
       +
           background-color: var(--surface);

     

       33
       33
       +
           border-bottom: 1px solid var(--border-color);

     

       34
       34
       +
           padding: 0.75rem 0;

     

       35
       35
       +
           position: sticky;

     

       36
       36
       +
           top: 0;

     

       37
       37
       +
           z-index: 100;

     

       38
       38
       +
       }

     

       39
       39
       +
       

     

       40
       40
       +
       .header-content {

     

       41
       41
       +
           max-width: var(--max-width);

     

       42
       42
       +
           margin: 0 auto;

     

       43
       43
       +
           padding: 0 2rem;

     

       44
       44
       +
           display: flex;

     

       45
       45
       +
           justify-content: space-between;

     

       46
       46
       +
           align-items: center;

     

       47
       47
       +
       }

     

       48
       48
       +
       

     

       49
       49
       +
       .site-title {

     

       50
       50
       +
           font-size: 1.5rem;

     

       51
       51
       +
           font-weight: 600;

     

       52
       52
       +
           color: var(--primary-color);

     

       53
       53
       +
           margin: 0;

     

       54
       54
       +
       }

     

       55
       55
       +
       

     

       56
       56
       +
       /* Navigation */

     

       57
       57
       +
       .site-nav {

     

       58
       58
       +
           display: flex;

     

       59
       59
       +
           gap: 1.5rem;

     

       60
       60
       +
       }

     

       61
       61
       +
       

     

       62
       62
       +
       .nav-link {

     

       63
       63
       +
           text-decoration: none;

     

       64
       64
       +
           color: var(--text-secondary);

     

       65
       65
       +
           font-weight: 500;

     

       66
       66
       +
           font-size: 0.95rem;

     

       67
       67
       +
           padding: 0.5rem 0.75rem;

     

       68
       68
       +
           border-radius: 4px;

     

       69
       69
       +
           transition: all 0.2s ease;

     

       70
       70
       +
       }

     

       71
       71
       +
       

     

       72
       72
       +
       .nav-link:hover {

     

       73
       73
       +
           color: var(--primary-color);

     

       74
       74
       +
           background-color: var(--background);

     

       75
       75
       +
       }

     

       76
       76
       +
       

     

       77
       77
       +
       .nav-link.active {

     

       78
       78
       +
           color: var(--secondary-color);

     

       79
       79
       +
           background-color: var(--background);

     

       80
       80
       +
           font-weight: 600;

     

       81
       81
       +
       }

     

       82
       82
       +
       

     

       83
       83
       +
       /* Main Content */

     

       84
       84
       +
       .main-content {

     

       85
       85
       +
           max-width: var(--max-width);

     

       86
       86
       +
           margin: 2rem auto;

     

       87
       87
       +
           padding: 0 2rem;

     

       88
       88
       +
       }

     

       89
       89
       +
       

     

       90
       90
       +
       .page-content {

     

       91
       91
       +
           margin: 0;

     

       92
       92
       +
       }

     

       93
       93
       +
       

     

       94
       94
       +
       .page-description {

     

       95
       95
       +
           color: var(--text-secondary);

     

       96
       96
       +
           margin-bottom: 1.5rem;

     

       97
       97
       +
           font-style: italic;

     

       98
       98
       +
       }

     

       99
       99
       +
       

     

       100
       100
       +
       /* Sections */

     

       101
       101
       +
       section {

     

       102
       102
       +
           margin-bottom: 2rem;

     

       103
       103
       +
       }

     

       104
       104
       +
       

     

       105
       105
       +
       h2 {

     

       106
       106
       +
           font-size: 1.3rem;

     

       107
       107
       +
           font-weight: 600;

     

       108
       108
       +
           margin-bottom: 0.75rem;

     

       109
       109
       +
           color: var(--primary-color);

     

       110
       110
       +
       }

     

       111
       111
       +
       

     

       112
       112
       +
       h3 {

     

       113
       113
       +
           font-size: 1.1rem;

     

       114
       114
       +
           font-weight: 600;

     

       115
       115
       +
           margin-bottom: 0.75rem;

     

       116
       116
       +
           color: var(--primary-color);

     

       117
       117
       +
       }

     

       118
       118
       +
       

     

       119
       119
       +
       /* Entries and Threads */

     

       120
       120
       +
       article {

     

       121
       121
       +
           margin-bottom: 1.5rem;

     

       122
       122
       +
           padding: 1rem;

     

       123
       123
       +
           background-color: var(--surface);

     

       124
       124
       +
           border-radius: 4px;

     

       125
       125
       +
           border: 1px solid var(--border-color);

     

       126
       126
       +
       }

     

       127
       127
       +
       

     

       128
       128
       +
       /* Timeline-style entries */

     

       129
       129
       +
       .timeline-entry {

     

       130
       130
       +
           margin-bottom: 0.5rem;

     

       131
       131
       +
           padding: 0.5rem 0.75rem;

     

       132
       132
       +
           border: none;

     

       133
       133
       +
           background: transparent;

     

       134
       134
       +
           transition: background-color 0.2s ease;

     

       135
       135
       +
       }

     

       136
       136
       +
       

     

       137
       137
       +
       .timeline-entry:hover {

     

       138
       138
       +
           background-color: var(--surface);

     

       139
       139
       +
       }

     

       140
       140
       +
       

     

       141
       141
       +
       .timeline-meta {

     

       142
       142
       +
           display: inline-flex;

     

       143
       143
       +
           gap: 0.5rem;

     

       144
       144
       +
           align-items: center;

     

       145
       145
       +
           font-size: 0.75rem;

     

       146
       146
       +
           color: var(--text-secondary);

     

       147
       147
       +
           margin-bottom: 0.25rem;

     

       148
       148
       +
       }

     

       149
       149
       +
       

     

       150
       150
       +
       .timeline-time {

     

       151
       151
       +
           font-family: 'SF Mono', Monaco, Consolas, 'Courier New', monospace;

     

       152
       152
       +
           font-size: 0.75rem;

     

       153
       153
       +
           color: var(--text-secondary);

     

       154
       154
       +
       }

     

       155
       155
       +
       

     

       156
       156
       +
       .timeline-author {

     

       157
       157
       +
           font-weight: 600;

     

       158
       158
       +
           color: var(--primary-color);

     

       159
       159
       +
           font-size: 0.8rem;

     

       160
       160
       +
           text-decoration: none;

     

       161
       161
       +
       }

     

       162
       162
       +
       

     

       163
       163
       +
       .timeline-author:hover {

     

       164
       164
       +
           color: var(--secondary-color);

     

       165
       165
       +
           text-decoration: underline;

     

       166
       166
       +
       }

     

       167
       167
       +
       

     

       168
       168
       +
       .timeline-content {

     

       169
       169
       +
           line-height: 1.4;

     

       170
       170
       +
       }

     

       171
       171
       +
       

     

       172
       172
       +
       .timeline-title {

     

       173
       173
       +
           font-size: 0.95rem;

     

       174
       174
       +
           font-weight: 600;

     

       175
       175
       +
       }

     

       176
       176
       +
       

     

       177
       177
       +
       .timeline-title a {

     

       178
       178
       +
           color: var(--primary-color);

     

       179
       179
       +
           text-decoration: none;

     

       180
       180
       +
       }

     

       181
       181
       +
       

     

       182
       182
       +
       .timeline-title a:hover {

     

       183
       183
       +
           color: var(--secondary-color);

     

       184
       184
       +
           text-decoration: underline;

     

       185
       185
       +
       }

     

       186
       186
       +
       

     

       187
       187
       +
       .timeline-summary {

     

       188
       188
       +
           color: var(--text-secondary);

     

       189
       189
       +
           font-size: 0.9rem;

     

       190
       190
       +
           line-height: 1.4;

     

       191
       191
       +
       }

     

       192
       192
       +
       

     

       193
       193
       +
       /* Legacy styles for other sections */

     

       194
       194
       +
       .entry-meta, .thread-header {

     

       195
       195
       +
           display: flex;

     

       196
       196
       +
           gap: 1rem;

     

       197
       197
       +
           align-items: center;

     

       198
       198
       +
           margin-bottom: 0.5rem;

     

       199
       199
       +
           font-size: 0.85rem;

     

       200
       200
       +
           color: var(--text-secondary);

     

       201
       201
       +
       }

     

       202
       202
       +
       

     

       203
       203
       +
       .author {

     

       204
       204
       +
           font-weight: 600;

     

       205
       205
       +
           color: var(--primary-color);

     

       206
       206
       +
       }

     

       207
       207
       +
       

     

       208
       208
       +
       time {

     

       209
       209
       +
           font-size: 0.85rem;

     

       210
       210
       +
       }

     

       211
       211
       +
       

     

       212
       212
       +
       h4 {

     

       213
       213
       +
           font-size: 1.1rem;

     

       214
       214
       +
           font-weight: 600;

     

       215
       215
       +
           margin-bottom: 0.5rem;

     

       216
       216
       +
       }

     

       217
       217
       +
       

     

       218
       218
       +
       h4 a {

     

       219
       219
       +
           color: var(--primary-color);

     

       220
       220
       +
           text-decoration: none;

     

       221
       221
       +
       }

     

       222
       222
       +
       

     

       223
       223
       +
       h4 a:hover {

     

       224
       224
       +
           color: var(--secondary-color);

     

       225
       225
       +
           text-decoration: underline;

     

       226
       226
       +
       }

     

       227
       227
       +
       

     

       228
       228
       +
       .entry-summary {

     

       229
       229
       +
           color: var(--text-primary);

     

       230
       230
       +
           line-height: 1.5;

     

       231
       231
       +
           margin-top: 0.5rem;

     

       232
       232
       +
       }

     

       233
       233
       +
       

     

       234
       234
       +
       /* Enhanced Threading Styles */

     

       235
       235
       +
       

     

       236
       236
       +
       /* Conversation Clusters */

     

       237
       237
       +
       .conversation-cluster {

     

       238
       238
       +
           background-color: var(--background);

     

       239
       239
       +
           border: 2px solid var(--border-color);

     

       240
       240
       +
           border-radius: 8px;

     

       241
       241
       +
           margin-bottom: 2rem;

     

       242
       242
       +
           overflow: hidden;

     

       243
       243
       +
           box-shadow: 0 2px 4px rgba(0, 0, 0, 0.05);

     

       244
       244
       +
       }

     

       245
       245
       +
       

     

       246
       246
       +
       .conversation-header {

     

       247
       247
       +
           background: linear-gradient(135deg, var(--surface) 0%, #f1f3f4 100%);

     

       248
       248
       +
           padding: 0.75rem 1rem;

     

       249
       249
       +
           border-bottom: 1px solid var(--border-color);

     

       250
       250
       +
       }

     

       251
       251
       +
       

     

       252
       252
       +
       .conversation-meta {

     

       253
       253
       +
           display: flex;

     

       254
       254
       +
           justify-content: space-between;

     

       255
       255
       +
           align-items: center;

     

       256
       256
       +
           flex-wrap: wrap;

     

       257
       257
       +
           gap: 0.5rem;

     

       258
       258
       +
       }

     

       259
       259
       +
       

     

       260
       260
       +
       .conversation-count {

     

       261
       261
       +
           font-weight: 600;

     

       262
       262
       +
           color: var(--secondary-color);

     

       263
       263
       +
           font-size: 0.9rem;

     

       264
       264
       +
       }

     

       265
       265
       +
       

     

       266
       266
       +
       .conversation-participants {

     

       267
       267
       +
           font-size: 0.8rem;

     

       268
       268
       +
           color: var(--text-secondary);

     

       269
       269
       +
           flex: 1;

     

       270
       270
       +
           text-align: right;

     

       271
       271
       +
       }

     

       272
       272
       +
       

     

       273
       273
       +
       .conversation-flow {

     

       274
       274
       +
           padding: 0.5rem;

     

       275
       275
       +
       }

     

       276
       276
       +
       

     

       277
       277
       +
       /* Threaded Conversation Entries */

     

       278
       278
       +
       .conversation-entry {

     

       279
       279
       +
           position: relative;

     

       280
       280
       +
           margin-bottom: 0.75rem;

     

       281
       281
       +
           display: flex;

     

       282
       282
       +
           align-items: flex-start;

     

       283
       283
       +
       }

     

       284
       284
       +
       

     

       285
       285
       +
       .conversation-entry.level-0 {

     

       286
       286
       +
           margin-left: 0;

     

       287
       287
       +
       }

     

       288
       288
       +
       

     

       289
       289
       +
       .conversation-entry.level-1 {

     

       290
       290
       +
           margin-left: 1.5rem;

     

       291
       291
       +
       }

     

       292
       292
       +
       

     

       293
       293
       +
       .conversation-entry.level-2 {

     

       294
       294
       +
           margin-left: 3rem;

     

       295
       295
       +
       }

     

       296
       296
       +
       

     

       297
       297
       +
       .conversation-entry.level-3 {

     

       298
       298
       +
           margin-left: 4.5rem;

     

       299
       299
       +
       }

     

       300
       300
       +
       

     

       301
       301
       +
       .conversation-entry.level-4 {

     

       302
       302
       +
           margin-left: 6rem;

     

       303
       303
       +
       }

     

       304
       304
       +
       

     

       305
       305
       +
       .entry-connector {

     

       306
       306
       +
           width: 3px;

     

       307
       307
       +
           background-color: var(--secondary-color);

     

       308
       308
       +
           margin-right: 0.75rem;

     

       309
       309
       +
           margin-top: 0.25rem;

     

       310
       310
       +
           min-height: 2rem;

     

       311
       311
       +
           border-radius: 2px;

     

       312
       312
       +
           opacity: 0.6;

     

       313
       313
       +
       }

     

       314
       314
       +
       

     

       315
       315
       +
       .conversation-entry.level-0 .entry-connector {

     

       316
       316
       +
           background-color: var(--accent-color);

     

       317
       317
       +
           opacity: 0.8;

     

       318
       318
       +
       }

     

       319
       319
       +
       

     

       320
       320
       +
       .entry-content {

     

       321
       321
       +
           flex: 1;

     

       322
       322
       +
           background-color: var(--surface);

     

       323
       323
       +
           padding: 0.75rem;

     

       324
       324
       +
           border-radius: 6px;

     

       325
       325
       +
           border: 1px solid var(--border-color);

     

       326
       326
       +
           transition: all 0.2s ease;

     

       327
       327
       +
       }

     

       328
       328
       +
       

     

       329
       329
       +
       .entry-content:hover {

     

       330
       330
       +
           border-color: var(--secondary-color);

     

       331
       331
       +
           box-shadow: 0 2px 8px rgba(52, 152, 219, 0.1);

     

       332
       332
       +
       }

     

       333
       333
       +
       

     

       334
       334
       +
       /* Reference Indicators */

     

       335
       335
       +
       .reference-indicators {

     

       336
       336
       +
           display: inline-flex;

     

       337
       337
       +
           gap: 0.25rem;

     

       338
       338
       +
           margin-left: 0.5rem;

     

       339
       339
       +
       }

     

       340
       340
       +
       

     

       341
       341
       +
       .ref-out, .ref-in {

     

       342
       342
       +
           display: inline-block;

     

       343
       343
       +
           width: 1rem;

     

       344
       344
       +
           height: 1rem;

     

       345
       345
       +
           border-radius: 50%;

     

       346
       346
       +
           text-align: center;

     

       347
       347
       +
           line-height: 1rem;

     

       348
       348
       +
           font-size: 0.7rem;

     

       349
       349
       +
           font-weight: bold;

     

       350
       350
       +
       }

     

       351
       351
       +
       

     

       352
       352
       +
       .ref-out {

     

       353
       353
       +
           background-color: #e8f5e8;

     

       354
       354
       +
           color: #2d8f2d;

     

       355
       355
       +
       }

     

       356
       356
       +
       

     

       357
       357
       +
       .ref-in {

     

       358
       358
       +
           background-color: #e8f0ff;

     

       359
       359
       +
           color: #1f5fbf;

     

       360
       360
       +
       }

     

       361
       361
       +
       

     

       362
       362
       +
       /* Reference Badges for Individual Posts */

     

       363
       363
       +
       .timeline-entry.with-references {

     

       364
       364
       +
           background-color: var(--surface);

     

       365
       365
       +
       }

     

       366
       366
       +
       

     

       367
       367
       +
       /* Conversation posts in unified timeline */

     

       368
       368
       +
       .timeline-entry.conversation-post {

     

       369
       369
       +
           background: transparent;

     

       370
       370
       +
           border: none;

     

       371
       371
       +
           margin-bottom: 0.5rem;

     

       372
       372
       +
           padding: 0.5rem 0.75rem;

     

       373
       373
       +
       }

     

       374
       374
       +
       

     

       375
       375
       +
       .timeline-entry.conversation-post.level-0 {

     

       376
       376
       +
           margin-left: 0;

     

       377
       377
       +
           border-left: 2px solid var(--accent-color);

     

       378
       378
       +
           padding-left: 0.75rem;

     

       379
       379
       +
       }

     

       380
       380
       +
       

     

       381
       381
       +
       .timeline-entry.conversation-post.level-1 {

     

       382
       382
       +
           margin-left: 1.5rem;

     

       383
       383
       +
           border-left: 2px solid var(--secondary-color);

     

       384
       384
       +
           padding-left: 0.75rem;

     

       385
       385
       +
       }

     

       386
       386
       +
       

     

       387
       387
       +
       .timeline-entry.conversation-post.level-2 {

     

       388
       388
       +
           margin-left: 3rem;

     

       389
       389
       +
           border-left: 2px solid var(--text-secondary);

     

       390
       390
       +
           padding-left: 0.75rem;

     

       391
       391
       +
       }

     

       392
       392
       +
       

     

       393
       393
       +
       .timeline-entry.conversation-post.level-3 {

     

       394
       394
       +
           margin-left: 4.5rem;

     

       395
       395
       +
           border-left: 2px solid var(--text-secondary);

     

       396
       396
       +
           padding-left: 0.75rem;

     

       397
       397
       +
       }

     

       398
       398
       +
       

     

       399
       399
       +
       .timeline-entry.conversation-post.level-4 {

     

       400
       400
       +
           margin-left: 6rem;

     

       401
       401
       +
           border-left: 2px solid var(--text-secondary);

     

       402
       402
       +
           padding-left: 0.75rem;

     

       403
       403
       +
       }

     

       404
       404
       +
       

     

       405
       405
       +
       /* Cross-thread linking */

     

       406
       406
       +
       .cross-thread-links {

     

       407
       407
       +
           margin-top: 0.5rem;

     

       408
       408
       +
           padding-top: 0.5rem;

     

       409
       409
       +
           border-top: 1px solid var(--border-color);

     

       410
       410
       +
       }

     

       411
       411
       +
       

     

       412
       412
       +
       .cross-thread-indicator {

     

       413
       413
       +
           font-size: 0.75rem;

     

       414
       414
       +
           color: var(--text-secondary);

     

       415
       415
       +
           background-color: var(--surface);

     

       416
       416
       +
           padding: 0.25rem 0.5rem;

     

       417
       417
       +
           border-radius: 12px;

     

       418
       418
       +
           border: 1px solid var(--border-color);

     

       419
       419
       +
           display: inline-block;

     

       420
       420
       +
       }

     

       421
       421
       +
       

     

       422
       422
       +
       /* Inline shared references styling */

     

       423
       423
       +
       .inline-shared-refs {

     

       424
       424
       +
           margin-left: 0.5rem;

     

       425
       425
       +
           font-size: 0.85rem;

     

       426
       426
       +
           color: var(--text-secondary);

     

       427
       427
       +
       }

     

       428
       428
       +
       

     

       429
       429
       +
       .shared-ref-link {

     

       430
       430
       +
           color: var(--primary-color);

     

       431
       431
       +
           text-decoration: none;

     

       432
       432
       +
           font-weight: 500;

     

       433
       433
       +
           transition: color 0.2s ease;

     

       434
       434
       +
       }

     

       435
       435
       +
       

     

       436
       436
       +
       .shared-ref-link:hover {

     

       437
       437
       +
           color: var(--secondary-color);

     

       438
       438
       +
           text-decoration: underline;

     

       439
       439
       +
       }

     

       440
       440
       +
       

     

       441
       441
       +
       .shared-ref-more {

     

       442
       442
       +
           font-style: italic;

     

       443
       443
       +
           color: var(--text-secondary);

     

       444
       444
       +
           font-size: 0.8rem;

     

       445
       445
       +
           margin-left: 0.25rem;

     

       446
       446
       +
       }

     

       447
       447
       +
       

     

       448
       448
       +
       .user-anchor, .post-anchor {

     

       449
       449
       +
           position: absolute;

     

       450
       450
       +
           margin-top: -60px; /* Offset for fixed header */

     

       451
       451
       +
           pointer-events: none;

     

       452
       452
       +
       }

     

       453
       453
       +
       

     

       454
       454
       +
       .cross-thread-link {

     

       455
       455
       +
           color: var(--primary-color);

     

       456
       456
       +
           text-decoration: none;

     

       457
       457
       +
           font-weight: 500;

     

       458
       458
       +
           transition: color 0.2s ease;

     

       459
       459
       +
       }

     

       460
       460
       +
       

     

       461
       461
       +
       .cross-thread-link:hover {

     

       462
       462
       +
           color: var(--secondary-color);

     

       463
       463
       +
           text-decoration: underline;

     

       464
       464
       +
       }

     

       465
       465
       +
       

     

       466
       466
       +
       .reference-badges {

     

       467
       467
       +
           display: flex;

     

       468
       468
       +
           gap: 0.25rem;

     

       469
       469
       +
           margin-left: 0.5rem;

     

       470
       470
       +
           flex-wrap: wrap;

     

       471
       471
       +
       }

     

       472
       472
       +
       

     

       473
       473
       +
       .ref-badge {

     

       474
       474
       +
           display: inline-block;

     

       475
       475
       +
           padding: 0.1rem 0.4rem;

     

       476
       476
       +
           border-radius: 12px;

     

       477
       477
       +
           font-size: 0.7rem;

     

       478
       478
       +
           font-weight: 600;

     

       479
       479
       +
           text-transform: uppercase;

     

       480
       480
       +
           letter-spacing: 0.05em;

     

       481
       481
       +
       }

     

       482
       482
       +
       

     

       483
       483
       +
       .ref-badge.ref-outbound {

     

       484
       484
       +
           background-color: #e8f5e8;

     

       485
       485
       +
           color: #2d8f2d;

     

       486
       486
       +
           border: 1px solid #c3e6c3;

     

       487
       487
       +
       }

     

       488
       488
       +
       

     

       489
       489
       +
       .ref-badge.ref-inbound {

     

       490
       490
       +
           background-color: #e8f0ff;

     

       491
       491
       +
           color: #1f5fbf;

     

       492
       492
       +
           border: 1px solid #b3d9ff;

     

       493
       493
       +
       }

     

       494
       494
       +
       

     

       495
       495
       +
       /* Author Color Coding */

     

       496
       496
       +
       .timeline-author {

     

       497
       497
       +
           position: relative;

     

       498
       498
       +
       }

     

       499
       499
       +
       

     

       500
       500
       +
       .timeline-author::before {

     

       501
       501
       +
           content: '';

     

       502
       502
       +
           display: inline-block;

     

       503
       503
       +
           width: 8px;

     

       504
       504
       +
           height: 8px;

     

       505
       505
       +
           border-radius: 50%;

     

       506
       506
       +
           margin-right: 0.5rem;

     

       507
       507
       +
           background-color: var(--secondary-color);

     

       508
       508
       +
       }

     

       509
       509
       +
       

     

       510
       510
       +
       /* Generate consistent colors for authors */

     

       511
       511
       +
       .author-avsm::before { background-color: #e74c3c; }

     

       512
       512
       +
       .author-mort::before { background-color: #3498db; }

     

       513
       513
       +
       .author-mte::before { background-color: #2ecc71; }

     

       514
       514
       +
       .author-ryan::before { background-color: #f39c12; }

     

       515
       515
       +
       .author-mwd::before { background-color: #9b59b6; }

     

       516
       516
       +
       .author-dra::before { background-color: #1abc9c; }

     

       517
       517
       +
       .author-pf341::before { background-color: #34495e; }

     

       518
       518
       +
       .author-sadiqj::before { background-color: #e67e22; }

     

       519
       519
       +
       .author-martinkl::before { background-color: #8e44ad; }

     

       520
       520
       +
       .author-jonsterling::before { background-color: #27ae60; }

     

       521
       521
       +
       .author-jon::before { background-color: #f1c40f; }

     

       522
       522
       +
       .author-onkar::before { background-color: #e91e63; }

     

       523
       523
       +
       .author-gabriel::before { background-color: #00bcd4; }

     

       524
       524
       +
       .author-jess::before { background-color: #ff5722; }

     

       525
       525
       +
       .author-ibrahim::before { background-color: #607d8b; }

     

       526
       526
       +
       .author-andres::before { background-color: #795548; }

     

       527
       527
       +
       .author-eeg::before { background-color: #ff9800; }

     

       528
       528
       +
       

     

       529
       529
       +
       /* Section Headers */

     

       530
       530
       +
       .conversations-section h3,

     

       531
       531
       +
       .referenced-posts-section h3,

     

       532
       532
       +
       .individual-posts-section h3 {

     

       533
       533
       +
           border-bottom: 2px solid var(--border-color);

     

       534
       534
       +
           padding-bottom: 0.5rem;

     

       535
       535
       +
           margin-bottom: 1.5rem;

     

       536
       536
       +
           position: relative;

     

       537
       537
       +
       }

     

       538
       538
       +
       

     

       539
       539
       +
       .conversations-section h3::before {

     

       540
       540
       +
           content: "💬";

     

       541
       541
       +
           margin-right: 0.5rem;

     

       542
       542
       +
       }

     

       543
       543
       +
       

     

       544
       544
       +
       .referenced-posts-section h3::before {

     

       545
       545
       +
           content: "🔗";

     

       546
       546
       +
           margin-right: 0.5rem;

     

       547
       547
       +
       }

     

       548
       548
       +
       

     

       549
       549
       +
       .individual-posts-section h3::before {

     

       550
       550
       +
           content: "📝";

     

       551
       551
       +
           margin-right: 0.5rem;

     

       552
       552
       +
       }

     

       553
       553
       +
       

     

       554
       554
       +
       /* Legacy thread styles (for backward compatibility) */

     

       555
       555
       +
       .thread {

     

       556
       556
       +
           background-color: var(--background);

     

       557
       557
       +
           border: 1px solid var(--border-color);

     

       558
       558
       +
           padding: 0;

     

       559
       559
       +
           overflow: hidden;

     

       560
       560
       +
           margin-bottom: 1rem;

     

       561
       561
       +
       }

     

       562
       562
       +
       

     

       563
       563
       +
       .thread-header {

     

       564
       564
       +
           background-color: var(--surface);

     

       565
       565
       +
           padding: 0.5rem 0.75rem;

     

       566
       566
       +
           border-bottom: 1px solid var(--border-color);

     

       567
       567
       +
       }

     

       568
       568
       +
       

     

       569
       569
       +
       .thread-count {

     

       570
       570
       +
           font-weight: 600;

     

       571
       571
       +
           color: var(--secondary-color);

     

       572
       572
       +
       }

     

       573
       573
       +
       

     

       574
       574
       +
       .thread-entry {

     

       575
       575
       +
           padding: 0.5rem 0.75rem;

     

       576
       576
       +
           border-bottom: 1px solid var(--border-color);

     

       577
       577
       +
       }

     

       578
       578
       +
       

     

       579
       579
       +
       .thread-entry:last-child {

     

       580
       580
       +
           border-bottom: none;

     

       581
       581
       +
       }

     

       582
       582
       +
       

     

       583
       583
       +
       .thread-entry.reply {

     

       584
       584
       +
           margin-left: var(--thread-indent);

     

       585
       585
       +
           border-left: 3px solid var(--secondary-color);

     

       586
       586
       +
           background-color: var(--surface);

     

       587
       587
       +
       }

     

       588
       588
       +
       

     

       589
       589
       +
       /* Links Section */

     

       590
       590
       +
       .link-group {

     

       591
       591
       +
           background-color: var(--background);

     

       592
       592
       +
       }

     

       593
       593
       +
       

     

       594
       594
       +
       .link-url {

     

       595
       595
       +
           font-size: 1rem;

     

       596
       596
       +
           word-break: break-word;

     

       597
       597
       +
       }

     

       598
       598
       +
       

     

       599
       599
       +
       .link-url a {

     

       600
       600
       +
           color: var(--secondary-color);

     

       601
       601
       +
           text-decoration: none;

     

       602
       602
       +
       }

     

       603
       603
       +
       

     

       604
       604
       +
       .link-url a:hover {

     

       605
       605
       +
           text-decoration: underline;

     

       606
       606
       +
       }

     

       607
       607
       +
       

     

       608
       608
       +
       .target-user {

     

       609
       609
       +
           font-size: 0.9rem;

     

       610
       610
       +
           color: var(--text-secondary);

     

       611
       611
       +
           font-weight: normal;

     

       612
       612
       +
       }

     

       613
       613
       +
       

     

       614
       614
       +
       .referencing-entries {

     

       615
       615
       +
           margin-top: 0.75rem;

     

       616
       616
       +
       }

     

       617
       617
       +
       

     

       618
       618
       +
       .ref-count {

     

       619
       619
       +
           font-weight: 600;

     

       620
       620
       +
           color: var(--text-secondary);

     

       621
       621
       +
           font-size: 0.9rem;

     

       622
       622
       +
       }

     

       623
       623
       +
       

     

       624
       624
       +
       .referencing-entries ul {

     

       625
       625
       +
           list-style: none;

     

       626
       626
       +
           margin-top: 0.5rem;

     

       627
       627
       +
           padding-left: 1rem;

     

       628
       628
       +
       }

     

       629
       629
       +
       

     

       630
       630
       +
       .referencing-entries li {

     

       631
       631
       +
           margin-bottom: 0.25rem;

     

       632
       632
       +
           font-size: 0.9rem;

     

       633
       633
       +
       }

     

       634
       634
       +
       

     

       635
       635
       +
       .referencing-entries .more {

     

       636
       636
       +
           font-style: italic;

     

       637
       637
       +
           color: var(--text-secondary);

     

       638
       638
       +
       }

     

       639
       639
       +
       

     

       640
       640
       +
       /* Users Section */

     

       641
       641
       +
       .user-card {

     

       642
       642
       +
           background-color: var(--background);

     

       643
       643
       +
       }

     

       644
       644
       +
       

     

       645
       645
       +
       .user-header {

     

       646
       646
       +
           display: flex;

     

       647
       647
       +
           gap: 1rem;

     

       648
       648
       +
           align-items: start;

     

       649
       649
       +
           margin-bottom: 1rem;

     

       650
       650
       +
       }

     

       651
       651
       +
       

     

       652
       652
       +
       .user-icon {

     

       653
       653
       +
           width: 48px;

     

       654
       654
       +
           height: 48px;

     

       655
       655
       +
           border-radius: 50%;

     

       656
       656
       +
           object-fit: cover;

     

       657
       657
       +
       }

     

       658
       658
       +
       

     

       659
       659
       +
       .user-info h3 {

     

       660
       660
       +
           margin-bottom: 0.25rem;

     

       661
       661
       +
       }

     

       662
       662
       +
       

     

       663
       663
       +
       .username {

     

       664
       664
       +
           font-size: 0.9rem;

     

       665
       665
       +
           color: var(--text-secondary);

     

       666
       666
       +
           font-weight: normal;

     

       667
       667
       +
       }

     

       668
       668
       +
       

     

       669
       669
       +
       .user-meta {

     

       670
       670
       +
           font-size: 0.9rem;

     

       671
       671
       +
           color: var(--text-secondary);

     

       672
       672
       +
       }

     

       673
       673
       +
       

     

       674
       674
       +
       .user-meta a {

     

       675
       675
       +
           color: var(--secondary-color);

     

       676
       676
       +
           text-decoration: none;

     

       677
       677
       +
       }

     

       678
       678
       +
       

     

       679
       679
       +
       .user-meta a:hover {

     

       680
       680
       +
           text-decoration: underline;

     

       681
       681
       +
       }

     

       682
       682
       +
       

     

       683
       683
       +
       .separator {

     

       684
       684
       +
           margin: 0 0.5rem;

     

       685
       685
       +
       }

     

       686
       686
       +
       

     

       687
       687
       +
       .post-count {

     

       688
       688
       +
           font-weight: 600;

     

       689
       689
       +
       }

     

       690
       690
       +
       

     

       691
       691
       +
       .user-recent h4 {

     

       692
       692
       +
           font-size: 0.95rem;

     

       693
       693
       +
           margin-bottom: 0.5rem;

     

       694
       694
       +
           color: var(--text-secondary);

     

       695
       695
       +
       }

     

       696
       696
       +
       

     

       697
       697
       +
       .user-recent ul {

     

       698
       698
       +
           list-style: none;

     

       699
       699
       +
           padding-left: 0;

     

       700
       700
       +
       }

     

       701
       701
       +
       

     

       702
       702
       +
       .user-recent li {

     

       703
       703
       +
           margin-bottom: 0.25rem;

     

       704
       704
       +
           font-size: 0.9rem;

     

       705
       705
       +
       }

     

       706
       706
       +
       

     

       707
       707
       +
       /* Footer */

     

       708
       708
       +
       .site-footer {

     

       709
       709
       +
           max-width: var(--max-width);

     

       710
       710
       +
           margin: 3rem auto 2rem;

     

       711
       711
       +
           padding: 1rem 2rem;

     

       712
       712
       +
           text-align: center;

     

       713
       713
       +
           color: var(--text-secondary);

     

       714
       714
       +
           font-size: 0.85rem;

     

       715
       715
       +
           border-top: 1px solid var(--border-color);

     

       716
       716
       +
       }

     

       717
       717
       +
       

     

       718
       718
       +
       .site-footer a {

     

       719
       719
       +
           color: var(--secondary-color);

     

       720
       720
       +
           text-decoration: none;

     

       721
       721
       +
       }

     

       722
       722
       +
       

     

       723
       723
       +
       .site-footer a:hover {

     

       724
       724
       +
           text-decoration: underline;

     

       725
       725
       +
       }

     

       726
       726
       +
       

     

       727
       727
       +
       /* Responsive */

     

       728
       728
       +
       @media (max-width: 768px) {

     

       729
       729
       +
           .site-title {

     

       730
       730
       +
               font-size: 1.3rem;

     

       731
       731
       +
           }

     

       732
       732
       +
           

     

       733
       733
       +
           .header-content {

     

       734
       734
       +
               flex-direction: column;

     

       735
       735
       +
               gap: 0.75rem;

     

       736
       736
       +
               align-items: flex-start;

     

       737
       737
       +
           }

     

       738
       738
       +
           

     

       739
       739
       +
           .site-nav {

     

       740
       740
       +
               gap: 1rem;

     

       741
       741
       +
           }

     

       742
       742
       +
           

     

       743
       743
       +
           .main-content {

     

       744
       744
       +
               padding: 0 1rem;

     

       745
       745
       +
           }

     

       746
       746
       +
           

     

       747
       747
       +
           .thread-entry.reply {

     

       748
       748
       +
               margin-left: calc(var(--thread-indent) / 2);

     

       749
       749
       +
           }

     

       750
       750
       +
           

     

       751
       751
       +
           .user-header {

     

       752
       752
       +
               flex-direction: column;

     

       753
       753
       +
           }

     

       754
       754
       +
       }

+141

src/thicket/templates/timeline.html

···

       1
       1
       +
       {% extends "base.html" %}

     

       2
       2
       +
       

     

       3
       3
       +
       {% block page_title %}Timeline - {{ title }}{% endblock %}

     

       4
       4
       +
       

     

       5
       5
       +
       {% block content %}

     

       6
       6
       +
       {% set seen_users = [] %}

     

       7
       7
       +
       <div class="page-content">

     

       8
       8
       +
           <h2>Recent Posts & Conversations</h2>

     

       9
       9
       +
           

     

       10
       10
       +
           <section class="unified-timeline">

     

       11
       11
       +
               {% for item in timeline_items %}

     

       12
       12
       +
                   {% if item.type == "post" %}

     

       13
       13
       +
                       <!-- Individual Post -->

     

       14
       14
       +
                       <article class="timeline-entry {% if item.content.references %}with-references{% endif %}">

     

       15
       15
       +
                           <div class="timeline-meta">

     

       16
       16
       +
                               <time datetime="{{ item.content.entry.updated or item.content.entry.published }}" class="timeline-time">

     

       17
       17
       +
                                   {{ (item.content.entry.updated or item.content.entry.published).strftime('%Y-%m-%d %H:%M') }}

     

       18
       18
       +
                               </time>

     

       19
       19
       +
                               {% set homepage = get_user_homepage(item.content.username) %}

     

       20
       20
       +
                               {% if item.content.username not in seen_users %}

     

       21
       21
       +
                               <a id="{{ item.content.username }}" class="user-anchor"></a>

     

       22
       22
       +
                               {% set _ = seen_users.append(item.content.username) %}

     

       23
       23
       +
                               {% endif %}

     

       24
       24
       +
                               <a id="post-{{ loop.index0 }}-{{ safe_anchor_id(item.content.entry.id) }}" class="post-anchor"></a>

     

       25
       25
       +
                               {% if homepage %}

     

       26
       26
       +
                               <a href="{{ homepage }}" target="_blank" class="timeline-author">{{ item.content.display_name }}</a>

     

       27
       27
       +
                               {% else %}

     

       28
       28
       +
                               <span class="timeline-author">{{ item.content.display_name }}</span>

     

       29
       29
       +
                               {% endif %}

     

       30
       30
       +
                               {% if item.content.references %}

     

       31
       31
       +
                               <div class="reference-badges">

     

       32
       32
       +
                                   {% for ref in item.content.references %}

     

       33
       33
       +
                                       {% if ref.type == 'outbound' %}

     

       34
       34
       +
                                       <span class="ref-badge ref-outbound" title="References {{ ref.target_username or 'external post' }}">

     

       35
       35
       +
                                           → {{ ref.target_username or 'ext' }}

     

       36
       36
       +
                                       </span>

     

       37
       37
       +
                                       {% elif ref.type == 'inbound' %}

     

       38
       38
       +
                                       <span class="ref-badge ref-inbound" title="Referenced by {{ ref.source_username or 'external post' }}">

     

       39
       39
       +
                                           ← {{ ref.source_username or 'ext' }}

     

       40
       40
       +
                                       </span>

     

       41
       41
       +
                                       {% endif %}

     

       42
       42
       +
                                   {% endfor %}

     

       43
       43
       +
                               </div>

     

       44
       44
       +
                               {% endif %}

     

       45
       45
       +
                           </div>

     

       46
       46
       +
                           <div class="timeline-content">

     

       47
       47
       +
                               <strong class="timeline-title">

     

       48
       48
       +
                                   <a href="{{ item.content.entry.link }}" target="_blank">{{ item.content.entry.title }}</a>

     

       49
       49
       +
                               </strong>

     

       50
       50
       +
                               {% if item.content.entry.summary %}

     

       51
       51
       +
                               <span class="timeline-summary">— {{ clean_html_summary(item.content.entry.summary, 250) }}</span>

     

       52
       52
       +
                               {% endif %}

     

       53
       53
       +
                               {% if item.content.shared_references %}

     

       54
       54
       +
                               <span class="inline-shared-refs">

     

       55
       55
       +
                                   {% for ref in item.content.shared_references[:3] %}

     

       56
       56
       +
                                   {% if ref.target_username %}

     

       57
       57
       +
                                   <a href="#{{ ref.target_username }}" class="shared-ref-link" title="Referenced by {{ ref.count }} entries">@{{ ref.target_username }}</a>{% if not loop.last %}, {% endif %}

     

       58
       58
       +
                                   {% endif %}

     

       59
       59
       +
                                   {% endfor %}

     

       60
       60
       +
                                   {% if item.content.shared_references|length > 3 %}

     

       61
       61
       +
                                   <span class="shared-ref-more">+{{ item.content.shared_references|length - 3 }} more</span>

     

       62
       62
       +
                                   {% endif %}

     

       63
       63
       +
                               </span>

     

       64
       64
       +
                               {% endif %}

     

       65
       65
       +
                               {% if item.content.cross_thread_links %}

     

       66
       66
       +
                               <div class="cross-thread-links">

     

       67
       67
       +
                                   <span class="cross-thread-indicator">🔗 Also appears: </span>

     

       68
       68
       +
                                   {% for link in item.content.cross_thread_links %}

     

       69
       69
       +
                                   <a href="#{{ link.anchor_id }}" class="cross-thread-link" title="{{ link.title }}">{{ link.context }}</a>{% if not loop.last %}, {% endif %}

     

       70
       70
       +
                                   {% endfor %}

     

       71
       71
       +
                               </div>

     

       72
       72
       +
                               {% endif %}

     

       73
       73
       +
                           </div>

     

       74
       74
       +
                       </article>

     

       75
       75
       +
                   

     

       76
       76
       +
                   {% elif item.type == "thread" %}

     

       77
       77
       +
                       <!-- Conversation Thread -->

     

       78
       78
       +
                       {% set outer_loop_index = loop.index0 %}

     

       79
       79
       +
                       {% for thread_item in item.content %}

     

       80
       80
       +
                       <article class="timeline-entry conversation-post level-{{ thread_item.thread_level }}">

     

       81
       81
       +
                           <div class="timeline-meta">

     

       82
       82
       +
                               <time datetime="{{ thread_item.entry.updated or thread_item.entry.published }}" class="timeline-time">

     

       83
       83
       +
                                   {{ (thread_item.entry.updated or thread_item.entry.published).strftime('%Y-%m-%d %H:%M') }}

     

       84
       84
       +
                               </time>

     

       85
       85
       +
                               {% set homepage = get_user_homepage(thread_item.username) %}

     

       86
       86
       +
                               {% if thread_item.username not in seen_users %}

     

       87
       87
       +
                               <a id="{{ thread_item.username }}" class="user-anchor"></a>

     

       88
       88
       +
                               {% set _ = seen_users.append(thread_item.username) %}

     

       89
       89
       +
                               {% endif %}

     

       90
       90
       +
                               <a id="post-{{ outer_loop_index }}-{{ loop.index0 }}-{{ safe_anchor_id(thread_item.entry.id) }}" class="post-anchor"></a>

     

       91
       91
       +
                               {% if homepage %}

     

       92
       92
       +
                               <a href="{{ homepage }}" target="_blank" class="timeline-author author-{{ thread_item.username }}">{{ thread_item.display_name }}</a>

     

       93
       93
       +
                               {% else %}

     

       94
       94
       +
                               <span class="timeline-author author-{{ thread_item.username }}">{{ thread_item.display_name }}</span>

     

       95
       95
       +
                               {% endif %}

     

       96
       96
       +
                               {% if thread_item.references_to or thread_item.referenced_by %}

     

       97
       97
       +
                               <span class="reference-indicators">

     

       98
       98
       +
                                   {% if thread_item.references_to %}

     

       99
       99
       +
                                   <span class="ref-out" title="References other posts">→</span>

     

       100
       100
       +
                                   {% endif %}

     

       101
       101
       +
                                   {% if thread_item.referenced_by %}

     

       102
       102
       +
                                   <span class="ref-in" title="Referenced by other posts">←</span>

     

       103
       103
       +
                                   {% endif %}

     

       104
       104
       +
                               </span>

     

       105
       105
       +
                               {% endif %}

     

       106
       106
       +
                           </div>

     

       107
       107
       +
                           <div class="timeline-content">

     

       108
       108
       +
                               <strong class="timeline-title">

     

       109
       109
       +
                                   <a href="{{ thread_item.entry.link }}" target="_blank">{{ thread_item.entry.title }}</a>

     

       110
       110
       +
                               </strong>

     

       111
       111
       +
                               {% if thread_item.entry.summary %}

     

       112
       112
       +
                               <span class="timeline-summary">— {{ clean_html_summary(thread_item.entry.summary, 300) }}</span>

     

       113
       113
       +
                               {% endif %}

     

       114
       114
       +
                               {% if thread_item.shared_references %}

     

       115
       115
       +
                               <span class="inline-shared-refs">

     

       116
       116
       +
                                   {% for ref in thread_item.shared_references[:3] %}

     

       117
       117
       +
                                   {% if ref.target_username %}

     

       118
       118
       +
                                   <a href="#{{ ref.target_username }}" class="shared-ref-link" title="Referenced by {{ ref.count }} entries">@{{ ref.target_username }}</a>{% if not loop.last %}, {% endif %}

     

       119
       119
       +
                                   {% endif %}

     

       120
       120
       +
                                   {% endfor %}

     

       121
       121
       +
                                   {% if thread_item.shared_references|length > 3 %}

     

       122
       122
       +
                                   <span class="shared-ref-more">+{{ thread_item.shared_references|length - 3 }} more</span>

     

       123
       123
       +
                                   {% endif %}

     

       124
       124
       +
                               </span>

     

       125
       125
       +
                               {% endif %}

     

       126
       126
       +
                               {% if thread_item.cross_thread_links %}

     

       127
       127
       +
                               <div class="cross-thread-links">

     

       128
       128
       +
                                   <span class="cross-thread-indicator">🔗 Also appears: </span>

     

       129
       129
       +
                                   {% for link in thread_item.cross_thread_links %}

     

       130
       130
       +
                                   <a href="#{{ link.anchor_id }}" class="cross-thread-link" title="{{ link.title }}">{{ link.context }}</a>{% if not loop.last %}, {% endif %}

     

       131
       131
       +
                                   {% endfor %}

     

       132
       132
       +
                               </div>

     

       133
       133
       +
                               {% endif %}

     

       134
       134
       +
                           </div>

     

       135
       135
       +
                       </article>

     

       136
       136
       +
                       {% endfor %}

     

       137
       137
       +
                   {% endif %}

     

       138
       138
       +
               {% endfor %}

     

       139
       139
       +
           </section>

     

       140
       140
       +
       </div>

     

       141
       141
       +
       {% endblock %}

+169

src/thicket/templates/user_detail.html

···

       1
       1
       +
       {% extends "base.html" %}

     

       2
       2
       +
       

     

       3
       3
       +
       {% block title %}{{ title }} - Thicket{% endblock %}

     

       4
       4
       +
       

     

       5
       5
       +
       {% block content %}

     

       6
       6
       +
       <div class="container mx-auto px-4 py-8">

     

       7
       7
       +
           <div class="max-w-4xl mx-auto">

     

       8
       8
       +
               <!-- User Header -->

     

       9
       9
       +
               <div class="bg-white rounded-lg shadow-md p-6 mb-6">

     

       10
       10
       +
                   <div class="flex items-center space-x-4">

     

       11
       11
       +
                       {% if user_config and user_config.icon %}

     

       12
       12
       +
                       <img src="{{ user_config.icon }}" alt="{{ title }}" class="w-16 h-16 rounded-full">

     

       13
       13
       +
                       {% else %}

     

       14
       14
       +
                       <div class="w-16 h-16 rounded-full bg-blue-500 flex items-center justify-center text-white text-xl font-bold">

     

       15
       15
       +
                           {{ user_metadata.username[0].upper() }}

     

       16
       16
       +
                       </div>

     

       17
       17
       +
                       {% endif %}

     

       18
       18
       +
                       

     

       19
       19
       +
                       <div>

     

       20
       20
       +
                           <h1 class="text-2xl font-bold text-gray-900">{{ title }}</h1>

     

       21
       21
       +
                           <p class="text-gray-600">@{{ user_metadata.username }}</p>

     

       22
       22
       +
                           {% if user_config and user_config.email %}

     

       23
       23
       +
                           <p class="text-sm text-gray-500">{{ user_config.email }}</p>

     

       24
       24
       +
                           {% endif %}

     

       25
       25
       +
                       </div>

     

       26
       26
       +
                   </div>

     

       27
       27
       +
                   

     

       28
       28
       +
                   {% if user_config and user_config.homepage %}

     

       29
       29
       +
                   <div class="mt-4">

     

       30
       30
       +
                       <a href="{{ user_config.homepage }}" class="text-blue-600 hover:text-blue-800" target="_blank">

     

       31
       31
       +
                           🏠 Homepage

     

       32
       32
       +
                       </a>

     

       33
       33
       +
                   </div>

     

       34
       34
       +
                   {% endif %}

     

       35
       35
       +
                   

     

       36
       36
       +
                   <div class="mt-4 grid grid-cols-2 md:grid-cols-4 gap-4">

     

       37
       37
       +
                       <div class="text-center">

     

       38
       38
       +
                           <div class="text-2xl font-bold text-blue-600">{{ user_metadata.entry_count }}</div>

     

       39
       39
       +
                           <div class="text-sm text-gray-500">Entries</div>

     

       40
       40
       +
                       </div>

     

       41
       41
       +
                       

     

       42
       42
       +
                       {% if user_config %}

     

       43
       43
       +
                       <div class="text-center">

     

       44
       44
       +
                           <div class="text-2xl font-bold text-green-600">{{ user_config.feeds|length }}</div>

     

       45
       45
       +
                           <div class="text-sm text-gray-500">Feeds</div>

     

       46
       46
       +
                       </div>

     

       47
       47
       +
                       {% endif %}

     

       48
       48
       +
                       

     

       49
       49
       +
                       <div class="text-center">

     

       50
       50
       +
                           <div class="text-2xl font-bold text-purple-600">{{ user_links|length }}</div>

     

       51
       51
       +
                           <div class="text-sm text-gray-500">Link Groups</div>

     

       52
       52
       +
                       </div>

     

       53
       53
       +
                       

     

       54
       54
       +
                       <div class="text-center">

     

       55
       55
       +
                           <div class="text-sm text-gray-500">Member since</div>

     

       56
       56
       +
                           <div class="text-sm font-medium">{{ user_metadata.created.strftime('%Y-%m-%d') if user_metadata.created else 'Unknown' }}</div>

     

       57
       57
       +
                       </div>

     

       58
       58
       +
                   </div>

     

       59
       59
       +
               </div>

     

       60
       60
       +
               

     

       61
       61
       +
               <!-- Feeds -->

     

       62
       62
       +
               {% if user_config and user_config.feeds %}

     

       63
       63
       +
               <div class="bg-white rounded-lg shadow-md p-6 mb-6">

     

       64
       64
       +
                   <h2 class="text-xl font-semibold mb-4">Feeds</h2>

     

       65
       65
       +
                   <div class="space-y-2">

     

       66
       66
       +
                       {% for feed in user_config.feeds %}

     

       67
       67
       +
                       <div class="flex items-center space-x-2">

     

       68
       68
       +
                           <span class="text-green-500">📡</span>

     

       69
       69
       +
                           <a href="{{ feed }}" class="text-blue-600 hover:text-blue-800" target="_blank">{{ feed }}</a>

     

       70
       70
       +
                       </div>

     

       71
       71
       +
                       {% endfor %}

     

       72
       72
       +
                   </div>

     

       73
       73
       +
               </div>

     

       74
       74
       +
               {% endif %}

     

       75
       75
       +
               

     

       76
       76
       +
               <!-- Recent Entries -->

     

       77
       77
       +
               <div class="bg-white rounded-lg shadow-md p-6 mb-6">

     

       78
       78
       +
                   <h2 class="text-xl font-semibold mb-4">Recent Entries</h2>

     

       79
       79
       +
                   

     

       80
       80
       +
                   {% if entries %}

     

       81
       81
       +
                   <div class="space-y-4">

     

       82
       82
       +
                       {% for entry in entries[:10] %}

     

       83
       83
       +
                       <div class="border-l-4 border-blue-500 pl-4 py-2">

     

       84
       84
       +
                           <h3 class="font-semibold text-lg">

     

       85
       85
       +
                               <a href="{{ entry.link }}" class="text-blue-600 hover:text-blue-800" target="_blank">

     

       86
       86
       +
                                   {{ entry.title }}

     

       87
       87
       +
                               </a>

     

       88
       88
       +
                           </h3>

     

       89
       89
       +
                           

     

       90
       90
       +
                           <div class="text-sm text-gray-500 mb-2">

     

       91
       91
       +
                               {% if entry.published %}

     

       92
       92
       +
                               Published: {{ entry.published.strftime('%Y-%m-%d %H:%M') }}

     

       93
       93
       +
                               {% endif %}

     

       94
       94
       +
                               {% if entry.updated and entry.updated != entry.published %}

     

       95
       95
       +
                               • Updated: {{ entry.updated.strftime('%Y-%m-%d %H:%M') }}

     

       96
       96
       +
                               {% endif %}

     

       97
       97
       +
                           </div>

     

       98
       98
       +
                           

     

       99
       99
       +
                           {% if entry.summary %}

     

       100
       100
       +
                           <div class="text-gray-700 mb-2">

     

       101
       101
       +
                               {{ entry.summary|truncate(200) }}

     

       102
       102
       +
                           </div>

     

       103
       103
       +
                           {% endif %}

     

       104
       104
       +
                           

     

       105
       105
       +
                           {% if entry.categories %}

     

       106
       106
       +
                           <div class="flex flex-wrap gap-1">

     

       107
       107
       +
                               {% for category in entry.categories %}

     

       108
       108
       +
                               <span class="px-2 py-1 bg-blue-100 text-blue-800 text-xs rounded">{{ category }}</span>

     

       109
       109
       +
                               {% endfor %}

     

       110
       110
       +
                           </div>

     

       111
       111
       +
                           {% endif %}

     

       112
       112
       +
                       </div>

     

       113
       113
       +
                       {% endfor %}

     

       114
       114
       +
                   </div>

     

       115
       115
       +
                   

     

       116
       116
       +
                   {% if entries|length > 10 %}

     

       117
       117
       +
                   <div class="mt-4 text-center">

     

       118
       118
       +
                       <p class="text-gray-500">Showing 10 of {{ entries|length }} entries</p>

     

       119
       119
       +
                   </div>

     

       120
       120
       +
                   {% endif %}

     

       121
       121
       +
                   

     

       122
       122
       +
                   {% else %}

     

       123
       123
       +
                   <p class="text-gray-500">No entries found.</p>

     

       124
       124
       +
                   {% endif %}

     

       125
       125
       +
               </div>

     

       126
       126
       +
               

     

       127
       127
       +
               <!-- Links Summary -->

     

       128
       128
       +
               {% if user_links %}

     

       129
       129
       +
               <div class="bg-white rounded-lg shadow-md p-6">

     

       130
       130
       +
                   <h2 class="text-xl font-semibold mb-4">Link Activity</h2>

     

       131
       131
       +
                   

     

       132
       132
       +
                   <div class="space-y-3">

     

       133
       133
       +
                       {% for link_group in user_links[:5] %}

     

       134
       134
       +
                       <div class="border-l-4 border-green-500 pl-4">

     

       135
       135
       +
                           <h3 class="font-medium">{{ link_group.title }}</h3>

     

       136
       136
       +
                           <div class="text-sm text-gray-500 mb-2">

     

       137
       137
       +
                               {{ link_group.links|length }} link(s) found

     

       138
       138
       +
                           </div>

     

       139
       139
       +
                           

     

       140
       140
       +
                           <div class="space-y-1">

     

       141
       141
       +
                               {% for link in link_group.links[:3] %}

     

       142
       142
       +
                               <div class="text-sm">

     

       143
       143
       +
                                   <a href="{{ link.url }}" class="text-blue-600 hover:text-blue-800" target="_blank">

     

       144
       144
       +
                                       {{ link.text or link.url }}

     

       145
       145
       +
                                   </a>

     

       146
       146
       +
                                   <span class="text-gray-400 ml-2">({{ link.type }})</span>

     

       147
       147
       +
                               </div>

     

       148
       148
       +
                               {% endfor %}

     

       149
       149
       +
                               

     

       150
       150
       +
                               {% if link_group.links|length > 3 %}

     

       151
       151
       +
                               <div class="text-sm text-gray-500">

     

       152
       152
       +
                                   ... and {{ link_group.links|length - 3 }} more

     

       153
       153
       +
                               </div>

     

       154
       154
       +
                               {% endif %}

     

       155
       155
       +
                           </div>

     

       156
       156
       +
                       </div>

     

       157
       157
       +
                       {% endfor %}

     

       158
       158
       +
                   </div>

     

       159
       159
       +
                   

     

       160
       160
       +
                   {% if user_links|length > 5 %}

     

       161
       161
       +
                   <div class="mt-4 text-center">

     

       162
       162
       +
                       <p class="text-gray-500">Showing 5 of {{ user_links|length }} entries with links</p>

     

       163
       163
       +
                   </div>

     

       164
       164
       +
                   {% endif %}

     

       165
       165
       +
               </div>

     

       166
       166
       +
               {% endif %}

     

       167
       167
       +
           </div>

     

       168
       168
       +
       </div>

     

       169
       169
       +
       {% endblock %}

+57

src/thicket/templates/users.html

···

       1
       1
       +
       {% extends "base.html" %}

     

       2
       2
       +
       

     

       3
       3
       +
       {% block page_title %}Users - {{ title }}{% endblock %}

     

       4
       4
       +
       

     

       5
       5
       +
       {% block content %}

     

       6
       6
       +
       <div class="page-content">

     

       7
       7
       +
           <h2>Users</h2>

     

       8
       8
       +
           <p class="page-description">All users contributing to this thicket, ordered by post count.</p>

     

       9
       9
       +
           

     

       10
       10
       +
           {% for user_info in users %}

     

       11
       11
       +
           <article class="user-card">

     

       12
       12
       +
               <div class="user-header">

     

       13
       13
       +
                   {% if user_info.metadata.icon and user_info.metadata.icon != "None" %}

     

       14
       14
       +
                   <img src="{{ user_info.metadata.icon }}" alt="{{ user_info.metadata.username }}" class="user-icon">

     

       15
       15
       +
                   {% endif %}

     

       16
       16
       +
                   <div class="user-info">

     

       17
       17
       +
                       <h3>

     

       18
       18
       +
                           {% if user_info.metadata.display_name %}

     

       19
       19
       +
                               {{ user_info.metadata.display_name }}

     

       20
       20
       +
                               <span class="username">({{ user_info.metadata.username }})</span>

     

       21
       21
       +
                           {% else %}

     

       22
       22
       +
                               {{ user_info.metadata.username }}

     

       23
       23
       +
                           {% endif %}

     

       24
       24
       +
                       </h3>

     

       25
       25
       +
                       <div class="user-meta">

     

       26
       26
       +
                           {% if user_info.metadata.homepage %}

     

       27
       27
       +
                           <a href="{{ user_info.metadata.homepage }}" target="_blank">{{ user_info.metadata.homepage }}</a>

     

       28
       28
       +
                           {% endif %}

     

       29
       29
       +
                           {% if user_info.metadata.email %}

     

       30
       30
       +
                           <span class="separator">•</span>

     

       31
       31
       +
                           <a href="mailto:{{ user_info.metadata.email }}">{{ user_info.metadata.email }}</a>

     

       32
       32
       +
                           {% endif %}

     

       33
       33
       +
                           <span class="separator">•</span>

     

       34
       34
       +
                           <span class="post-count">{{ user_info.metadata.entry_count }} posts</span>

     

       35
       35
       +
                       </div>

     

       36
       36
       +
                   </div>

     

       37
       37
       +
               </div>

     

       38
       38
       +
               

     

       39
       39
       +
               {% if user_info.recent_entries %}

     

       40
       40
       +
               <div class="user-recent">

     

       41
       41
       +
                   <h4>Recent posts:</h4>

     

       42
       42
       +
                   <ul>

     

       43
       43
       +
                       {% for display_name, entry in user_info.recent_entries %}

     

       44
       44
       +
                       <li>

     

       45
       45
       +
                           <a href="{{ entry.link }}" target="_blank">{{ entry.title }}</a>

     

       46
       46
       +
                           <time datetime="{{ entry.updated or entry.published }}">

     

       47
       47
       +
                               ({{ (entry.updated or entry.published).strftime('%Y-%m-%d') }})

     

       48
       48
       +
                           </time>

     

       49
       49
       +
                       </li>

     

       50
       50
       +
                       {% endfor %}

     

       51
       51
       +
                   </ul>

     

       52
       52
       +
               </div>

     

       53
       53
       +
               {% endif %}

     

       54
       54
       +
           </article>

     

       55
       55
       +
           {% endfor %}

     

       56
       56
       +
       </div>

     

       57
       57
       +
       {% endblock %}

+230

src/thicket/thicket.py

···

       1
       1
       +
       """Main Thicket library class providing unified API."""

     

       2
       2
       +
       

     

       3
       3
       +
       import asyncio

     

       4
       4
       +
       from datetime import datetime

     

       5
       5
       +
       from pathlib import Path

     

       6
       6
       +
       from typing import Optional, Union

     

       7
       7
       +
       

     

       8
       8
       +
       from pydantic import HttpUrl

     

       9
       9
       +
       

     

       10
       10
       +
       from .core.feed_parser import FeedParser

     

       11
       11
       +
       from .core.git_store import GitStore

     

       12
       12
       +
       from .models import AtomEntry, ThicketConfig, UserConfig

     

       13
       13
       +
       from .subsystems.feeds import FeedManager

     

       14
       14
       +
       from .subsystems.links import LinkProcessor

     

       15
       15
       +
       from .subsystems.repository import RepositoryManager

     

       16
       16
       +
       from .subsystems.site import SiteGenerator

     

       17
       17
       +
       from .subsystems.users import UserManager

     

       18
       18
       +
       

     

       19
       19
       +
       

     

       20
       20
       +
       class Thicket:

     

       21
       21
       +
           """

     

       22
       22
       +
           Main Thicket class providing unified API for feed management.

     

       23
       23
       +
           

     

       24
       24
       +
           This class serves as the primary interface for all Thicket operations,

     

       25
       25
       +
           consolidating configuration, repository management, feed processing,

     

       26
       26
       +
           user management, link processing, and site generation.

     

       27
       27
       +
           """

     

       28
       28
       +
       

     

       29
       29
       +
           def __init__(self, config: Union[ThicketConfig, Path, str]):

     

       30
       30
       +
               """

     

       31
       31
       +
               Initialize Thicket with configuration.

     

       32
       32
       +
               

     

       33
       33
       +
               Args:

     

       34
       34
       +
                   config: Either a ThicketConfig object, or path to config file

     

       35
       35
       +
               """

     

       36
       36
       +
               if isinstance(config, (Path, str)):

     

       37
       37
       +
                   self.config = ThicketConfig.from_file(Path(config))

     

       38
       38
       +
               else:

     

       39
       39
       +
                   self.config = config

     

       40
       40
       +
                   

     

       41
       41
       +
               # Initialize subsystems

     

       42
       42
       +
               self._init_subsystems()

     

       43
       43
       +
       

     

       44
       44
       +
           def _init_subsystems(self):

     

       45
       45
       +
               """Initialize all subsystems."""

     

       46
       46
       +
               # Core components

     

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

     

       48
       48
       +
               self.feed_parser = FeedParser()

     

       49
       49
       +
               

     

       50
       50
       +
               # Subsystem managers

     

       51
       51
       +
               self.repository = RepositoryManager(self.git_store, self.config)

     

       52
       52
       +
               self.users = UserManager(self.git_store, self.config)

     

       53
       53
       +
               self.feeds = FeedManager(self.git_store, self.feed_parser, self.config)

     

       54
       54
       +
               self.links = LinkProcessor(self.git_store, self.config)

     

       55
       55
       +
               self.site = SiteGenerator(self.git_store, self.config)

     

       56
       56
       +
       

     

       57
       57
       +
           @classmethod

     

       58
       58
       +
           def create(cls, git_store: Path, cache_dir: Path, users: Optional[list[UserConfig]] = None) -> 'Thicket':

     

       59
       59
       +
               """

     

       60
       60
       +
               Create a new Thicket instance with minimal configuration.

     

       61
       61
       +
               

     

       62
       62
       +
               Args:

     

       63
       63
       +
                   git_store: Path to git repository

     

       64
       64
       +
                   cache_dir: Path to cache directory

     

       65
       65
       +
                   users: Optional list of user configurations

     

       66
       66
       +
                   

     

       67
       67
       +
               Returns:

     

       68
       68
       +
                   Configured Thicket instance

     

       69
       69
       +
               """

     

       70
       70
       +
               config = ThicketConfig(

     

       71
       71
       +
                   git_store=git_store,

     

       72
       72
       +
                   cache_dir=cache_dir,

     

       73
       73
       +
                   users=users or []

     

       74
       74
       +
               )

     

       75
       75
       +
               return cls(config)

     

       76
       76
       +
       

     

       77
       77
       +
           @classmethod

     

       78
       78
       +
           def from_config_file(cls, config_path: Path) -> 'Thicket':

     

       79
       79
       +
               """Load Thicket from configuration file."""

     

       80
       80
       +
               return cls(config_path)

     

       81
       81
       +
       

     

       82
       82
       +
           # User Management API

     

       83
       83
       +
           def add_user(self, username: str, feeds: list[str], **kwargs) -> UserConfig:

     

       84
       84
       +
               """Add a new user with feeds."""

     

       85
       85
       +
               return self.users.add_user(username, feeds, **kwargs)

     

       86
       86
       +
       

     

       87
       87
       +
           def get_user(self, username: str) -> Optional[UserConfig]:

     

       88
       88
       +
               """Get user configuration."""

     

       89
       89
       +
               return self.users.get_user(username)

     

       90
       90
       +
       

     

       91
       91
       +
           def list_users(self) -> list[UserConfig]:

     

       92
       92
       +
               """List all configured users."""

     

       93
       93
       +
               return self.users.list_users()

     

       94
       94
       +
       

     

       95
       95
       +
           def update_user(self, username: str, **kwargs) -> bool:

     

       96
       96
       +
               """Update user configuration."""

     

       97
       97
       +
               return self.users.update_user(username, **kwargs)

     

       98
       98
       +
       

     

       99
       99
       +
           def remove_user(self, username: str) -> bool:

     

       100
       100
       +
               """Remove a user and their data."""

     

       101
       101
       +
               return self.users.remove_user(username)

     

       102
       102
       +
       

     

       103
       103
       +
           # Feed Management API

     

       104
       104
       +
           async def sync_feeds(self, username: Optional[str] = None, progress_callback=None) -> dict:

     

       105
       105
       +
               """Sync feeds for user(s)."""

     

       106
       106
       +
               return await self.feeds.sync_feeds(username, progress_callback)

     

       107
       107
       +
       

     

       108
       108
       +
           async def sync_user_feeds(self, username: str, progress_callback=None) -> dict:

     

       109
       109
       +
               """Sync feeds for a specific user."""

     

       110
       110
       +
               return await self.feeds.sync_user_feeds(username, progress_callback)

     

       111
       111
       +
       

     

       112
       112
       +
           def get_entries(self, username: str, limit: Optional[int] = None) -> list[AtomEntry]:

     

       113
       113
       +
               """Get entries for a user."""

     

       114
       114
       +
               return self.feeds.get_entries(username, limit)

     

       115
       115
       +
       

     

       116
       116
       +
           def get_entry(self, username: str, entry_id: str) -> Optional[AtomEntry]:

     

       117
       117
       +
               """Get a specific entry."""

     

       118
       118
       +
               return self.feeds.get_entry(username, entry_id)

     

       119
       119
       +
       

     

       120
       120
       +
           def search_entries(self, query: str, username: Optional[str] = None, limit: Optional[int] = None) -> list[tuple[str, AtomEntry]]:

     

       121
       121
       +
               """Search entries across users."""

     

       122
       122
       +
               return self.feeds.search_entries(query, username, limit)

     

       123
       123
       +
       

     

       124
       124
       +
           # Repository Management API

     

       125
       125
       +
           def init_repository(self) -> bool:

     

       126
       126
       +
               """Initialize the git repository."""

     

       127
       127
       +
               return self.repository.init_repository()

     

       128
       128
       +
       

     

       129
       129
       +
           def commit_changes(self, message: str) -> bool:

     

       130
       130
       +
               """Commit all pending changes."""

     

       131
       131
       +
               return self.repository.commit_changes(message)

     

       132
       132
       +
       

     

       133
       133
       +
           def get_status(self) -> dict:

     

       134
       134
       +
               """Get repository status and statistics."""

     

       135
       135
       +
               return self.repository.get_status()

     

       136
       136
       +
       

     

       137
       137
       +
           def backup_repository(self, backup_path: Path) -> bool:

     

       138
       138
       +
               """Create a backup of the repository."""

     

       139
       139
       +
               return self.repository.backup_repository(backup_path)

     

       140
       140
       +
       

     

       141
       141
       +
           # Link Processing API

     

       142
       142
       +
           def process_links(self, username: Optional[str] = None) -> dict:

     

       143
       143
       +
               """Process and extract links from entries."""

     

       144
       144
       +
               return self.links.process_links(username)

     

       145
       145
       +
       

     

       146
       146
       +
           def get_links(self, username: Optional[str] = None) -> dict:

     

       147
       147
       +
               """Get processed links."""

     

       148
       148
       +
               return self.links.get_links(username)

     

       149
       149
       +
       

     

       150
       150
       +
           def find_references(self, url: str) -> list[tuple[str, AtomEntry]]:

     

       151
       151
       +
               """Find entries that reference a URL."""

     

       152
       152
       +
               return self.links.find_references(url)

     

       153
       153
       +
       

     

       154
       154
       +
           # Site Generation API

     

       155
       155
       +
           def generate_site(self, output_dir: Path, template_dir: Optional[Path] = None) -> bool:

     

       156
       156
       +
               """Generate static site."""

     

       157
       157
       +
               return self.site.generate_site(output_dir, template_dir)

     

       158
       158
       +
       

     

       159
       159
       +
           def generate_timeline(self, output_path: Path, limit: Optional[int] = None) -> bool:

     

       160
       160
       +
               """Generate timeline HTML."""

     

       161
       161
       +
               return self.site.generate_timeline(output_path, limit)

     

       162
       162
       +
       

     

       163
       163
       +
           def generate_user_pages(self, output_dir: Path) -> bool:

     

       164
       164
       +
               """Generate individual user pages."""

     

       165
       165
       +
               return self.site.generate_user_pages(output_dir)

     

       166
       166
       +
       

     

       167
       167
       +
           # Utility Methods

     

       168
       168
       +
           def get_stats(self) -> dict:

     

       169
       169
       +
               """Get comprehensive statistics."""

     

       170
       170
       +
               base_stats = self.repository.get_status()

     

       171
       171
       +
               feed_stats = self.feeds.get_stats()

     

       172
       172
       +
               link_stats = self.links.get_stats()

     

       173
       173
       +
               

     

       174
       174
       +
               return {

     

       175
       175
       +
                   **base_stats,

     

       176
       176
       +
                   **feed_stats,

     

       177
       177
       +
                   **link_stats,

     

       178
       178
       +
                   'config': {

     

       179
       179
       +
                       'git_store': str(self.config.git_store),

     

       180
       180
       +
                       'cache_dir': str(self.config.cache_dir),

     

       181
       181
       +
                       'total_users_configured': len(self.config.users),

     

       182
       182
       +
                   }

     

       183
       183
       +
               }

     

       184
       184
       +
       

     

       185
       185
       +
           async def full_sync(self, progress_callback=None) -> dict:

     

       186
       186
       +
               """Perform a complete sync: feeds -> links -> commit."""

     

       187
       187
       +
               results = {}

     

       188
       188
       +
               

     

       189
       189
       +
               # Sync feeds

     

       190
       190
       +
               results['feeds'] = await self.sync_feeds(progress_callback=progress_callback)

     

       191
       191
       +
               

     

       192
       192
       +
               # Process links

     

       193
       193
       +
               results['links'] = self.process_links()

     

       194
       194
       +
               

     

       195
       195
       +
               # Commit changes

     

       196
       196
       +
               message = f"Sync completed at {datetime.now().isoformat()}"

     

       197
       197
       +
               results['committed'] = self.commit_changes(message)

     

       198
       198
       +
               

     

       199
       199
       +
               return results

     

       200
       200
       +
       

     

       201
       201
       +
           def validate_config(self) -> list[str]:

     

       202
       202
       +
               """Validate configuration and return any errors."""

     

       203
       203
       +
               errors = []

     

       204
       204
       +
               

     

       205
       205
       +
               # Check paths exist

     

       206
       206
       +
               if not self.config.git_store.parent.exists():

     

       207
       207
       +
                   errors.append(f"Git store parent directory does not exist: {self.config.git_store.parent}")

     

       208
       208
       +
                   

     

       209
       209
       +
               if not self.config.cache_dir.parent.exists():

     

       210
       210
       +
                   errors.append(f"Cache directory parent does not exist: {self.config.cache_dir.parent}")

     

       211
       211
       +
               

     

       212
       212
       +
               # Validate user configs

     

       213
       213
       +
               for user in self.config.users:

     

       214
       214
       +
                   if not user.feeds:

     

       215
       215
       +
                       errors.append(f"User {user.username} has no feeds configured")

     

       216
       216
       +
                       

     

       217
       217
       +
                   for feed_url in user.feeds:

     

       218
       218
       +
                       # Basic URL validation is handled by pydantic

     

       219
       219
       +
                       pass

     

       220
       220
       +
                       

     

       221
       221
       +
               return errors

     

       222
       222
       +
       

     

       223
       223
       +
           def __enter__(self):

     

       224
       224
       +
               """Context manager entry."""

     

       225
       225
       +
               return self

     

       226
       226
       +
       

     

       227
       227
       +
           def __exit__(self, exc_type, exc_val, exc_tb):

     

       228
       228
       +
               """Context manager exit."""

     

       229
       229
       +
               # Could add cleanup logic here if needed

     

       230
       230
       +
               pass

+1 -1

src/thicket/utils/__init__.py

···

       1
       1
        
       """Utility modules for thicket."""

     

       2
       2
        
       

     

       3
       3
        
       # This module will contain shared utilities

     

       4
       4
       -
       # For now, it's empty but can be expanded with common functions
     

       4
       4
       +
       # For now, it's empty but can be expanded with common functions

tests/__init__.py

This is a binary file and will not be displayed.

-84

tests/conftest.py

···

       1
       1
       -
       """Test configuration and fixtures for thicket."""

     

       2
       2
       -
       

     

       3
       3
       -
       import tempfile

     

       4
       4
       -
       from pathlib import Path

     

       5
       5
       -
       

     

       6
       6
       -
       import pytest

     

       7
       7
       -
       

     

       8
       8
       -
       from thicket.models import ThicketConfig, UserConfig

     

       9
       9
       -
       

     

       10
       10
       -
       

     

       11
       11
       -
       @pytest.fixture

     

       12
       12
       -
       def temp_dir():

     

       13
       13
       -
           """Create a temporary directory for tests."""

     

       14
       14
       -
           with tempfile.TemporaryDirectory() as tmp_dir:

     

       15
       15
       -
               yield Path(tmp_dir)

     

       16
       16
       -
       

     

       17
       17
       -
       

     

       18
       18
       -
       @pytest.fixture

     

       19
       19
       -
       def sample_config(temp_dir):

     

       20
       20
       -
           """Create a sample configuration for testing."""

     

       21
       21
       -
           git_store = temp_dir / "git_store"

     

       22
       22
       -
           cache_dir = temp_dir / "cache"

     

       23
       23
       -
           

     

       24
       24
       -
           return ThicketConfig(

     

       25
       25
       -
               git_store=git_store,

     

       26
       26
       -
               cache_dir=cache_dir,

     

       27
       27
       -
               users=[

     

       28
       28
       -
                   UserConfig(

     

       29
       29
       -
                       username="testuser",

     

       30
       30
       -
                       feeds=["https://example.com/feed.xml"],

     

       31
       31
       -
                       email="test@example.com",

     

       32
       32
       -
                       display_name="Test User",

     

       33
       33
       -
                   )

     

       34
       34
       -
               ],

     

       35
       35
       -
           )

     

       36
       36
       -
       

     

       37
       37
       -
       

     

       38
       38
       -
       @pytest.fixture

     

       39
       39
       -
       def sample_atom_feed():

     

       40
       40
       -
           """Sample Atom feed XML for testing."""

     

       41
       41
       -
           return """<?xml version="1.0" encoding="utf-8"?>

     

       42
       42
       -
       <feed xmlns="http://www.w3.org/2005/Atom">

     

       43
       43
       -
         <title>Test Feed</title>

     

       44
       44
       -
         <link href="https://example.com/"/>

     

       45
       45
       -
         <updated>2025-01-01T00:00:00Z</updated>

     

       46
       46
       -
         <author>

     

       47
       47
       -
           <name>Test Author</name>

     

       48
       48
       -
           <email>author@example.com</email>

     

       49
       49
       -
         </author>

     

       50
       50
       -
         <id>https://example.com/</id>

     

       51
       51
       -
       

     

       52
       52
       -
         <entry>

     

       53
       53
       -
           <title>Test Entry</title>

     

       54
       54
       -
           <link href="https://example.com/entry/1"/>

     

       55
       55
       -
           <id>https://example.com/entry/1</id>

     

       56
       56
       -
           <updated>2025-01-01T00:00:00Z</updated>

     

       57
       57
       -
           <summary>This is a test entry.</summary>

     

       58
       58
       -
           <content type="html">

     

       59
       59
       -
             <![CDATA[<p>This is the content of the test entry.</p>]]>

     

       60
       60
       -
           </content>

     

       61
       61
       -
         </entry>

     

       62
       62
       -
       </feed>"""

     

       63
       63
       -
       

     

       64
       64
       -
       

     

       65
       65
       -
       @pytest.fixture

     

       66
       66
       -
       def sample_rss_feed():

     

       67
       67
       -
           """Sample RSS feed XML for testing."""

     

       68
       68
       -
           return """<?xml version="1.0" encoding="UTF-8"?>

     

       69
       69
       -
       <rss version="2.0">

     

       70
       70
       -
         <channel>

     

       71
       71
       -
           <title>Test RSS Feed</title>

     

       72
       72
       -
           <link>https://example.com/</link>

     

       73
       73
       -
           <description>Test RSS feed for testing</description>

     

       74
       74
       -
           <managingEditor>editor@example.com</managingEditor>

     

       75
       75
       -
           

     

       76
       76
       -
           <item>

     

       77
       77
       -
             <title>Test RSS Entry</title>

     

       78
       78
       -
             <link>https://example.com/rss/entry/1</link>

     

       79
       79
       -
             <description>This is a test RSS entry.</description>

     

       80
       80
       -
             <pubDate>Mon, 01 Jan 2025 00:00:00 GMT</pubDate>

     

       81
       81
       -
             <guid>https://example.com/rss/entry/1</guid>

     

       82
       82
       -
           </item>

     

       83
       83
       -
         </channel>

     

       84
       84
       -
       </rss>"""

-132

tests/test_feed_parser.py

···

       1
       1
       -
       """Tests for feed parser functionality."""

     

       2
       2
       -
       

     

       3
       3
       -
       import pytest

     

       4
       4
       -
       from pydantic import HttpUrl

     

       5
       5
       -
       

     

       6
       6
       -
       from thicket.core.feed_parser import FeedParser

     

       7
       7
       -
       from thicket.models import AtomEntry, FeedMetadata

     

       8
       8
       -
       

     

       9
       9
       -
       

     

       10
       10
       -
       class TestFeedParser:

     

       11
       11
       -
           """Test the FeedParser class."""

     

       12
       12
       -
       

     

       13
       13
       -
           def test_init(self):

     

       14
       14
       -
               """Test parser initialization."""

     

       15
       15
       -
               parser = FeedParser()

     

       16
       16
       -
               assert parser.user_agent == "thicket/0.1.0"

     

       17
       17
       -
               assert "a" in parser.allowed_tags

     

       18
       18
       -
               assert "href" in parser.allowed_attributes["a"]

     

       19
       19
       -
       

     

       20
       20
       -
           def test_parse_atom_feed(self, sample_atom_feed):

     

       21
       21
       -
               """Test parsing an Atom feed."""

     

       22
       22
       -
               parser = FeedParser()

     

       23
       23
       -
               metadata, entries = parser.parse_feed(sample_atom_feed)

     

       24
       24
       -
               

     

       25
       25
       -
               # Check metadata

     

       26
       26
       -
               assert isinstance(metadata, FeedMetadata)

     

       27
       27
       -
               assert metadata.title == "Test Feed"

     

       28
       28
       -
               assert metadata.author_name == "Test Author"

     

       29
       29
       -
               assert metadata.author_email == "author@example.com"

     

       30
       30
       -
               assert metadata.link == HttpUrl("https://example.com/")

     

       31
       31
       -
               

     

       32
       32
       -
               # Check entries

     

       33
       33
       -
               assert len(entries) == 1

     

       34
       34
       -
               entry = entries[0]

     

       35
       35
       -
               assert isinstance(entry, AtomEntry)

     

       36
       36
       -
               assert entry.title == "Test Entry"

     

       37
       37
       -
               assert entry.id == "https://example.com/entry/1"

     

       38
       38
       -
               assert entry.link == HttpUrl("https://example.com/entry/1")

     

       39
       39
       -
               assert entry.summary == "This is a test entry."

     

       40
       40
       -
               assert "<p>This is the content of the test entry.</p>" in entry.content

     

       41
       41
       -
       

     

       42
       42
       -
           def test_parse_rss_feed(self, sample_rss_feed):

     

       43
       43
       -
               """Test parsing an RSS feed."""

     

       44
       44
       -
               parser = FeedParser()

     

       45
       45
       -
               metadata, entries = parser.parse_feed(sample_rss_feed)

     

       46
       46
       -
               

     

       47
       47
       -
               # Check metadata

     

       48
       48
       -
               assert isinstance(metadata, FeedMetadata)

     

       49
       49
       -
               assert metadata.title == "Test RSS Feed"

     

       50
       50
       -
               assert metadata.link == HttpUrl("https://example.com/")

     

       51
       51
       -
               assert metadata.author_email == "editor@example.com"

     

       52
       52
       -
               

     

       53
       53
       -
               # Check entries

     

       54
       54
       -
               assert len(entries) == 1

     

       55
       55
       -
               entry = entries[0]

     

       56
       56
       -
               assert isinstance(entry, AtomEntry)

     

       57
       57
       -
               assert entry.title == "Test RSS Entry"

     

       58
       58
       -
               assert entry.id == "https://example.com/rss/entry/1"

     

       59
       59
       -
               assert entry.summary == "This is a test RSS entry."

     

       60
       60
       -
       

     

       61
       61
       -
           def test_sanitize_entry_id(self):

     

       62
       62
       -
               """Test entry ID sanitization."""

     

       63
       63
       -
               parser = FeedParser()

     

       64
       64
       -
               

     

       65
       65
       -
               # Test URL ID

     

       66
       66
       -
               url_id = "https://example.com/posts/2025/01/test-post"

     

       67
       67
       -
               sanitized = parser.sanitize_entry_id(url_id)

     

       68
       68
       -
               assert sanitized == "posts_2025_01_test-post"

     

       69
       69
       -
               

     

       70
       70
       -
               # Test problematic characters

     

       71
       71
       -
               bad_id = "test/with\\bad:chars|and<more>"

     

       72
       72
       -
               sanitized = parser.sanitize_entry_id(bad_id)

     

       73
       73
       -
               assert sanitized == "test_with_bad_chars_and_more_"

     

       74
       74
       -
               

     

       75
       75
       -
               # Test empty ID

     

       76
       76
       -
               empty_id = ""

     

       77
       77
       -
               sanitized = parser.sanitize_entry_id(empty_id)

     

       78
       78
       -
               assert sanitized == "entry"

     

       79
       79
       -
               

     

       80
       80
       -
               # Test very long ID

     

       81
       81
       -
               long_id = "a" * 300

     

       82
       82
       -
               sanitized = parser.sanitize_entry_id(long_id)

     

       83
       83
       -
               assert len(sanitized) == 200

     

       84
       84
       -
       

     

       85
       85
       -
           def test_sanitize_html(self):

     

       86
       86
       -
               """Test HTML sanitization."""

     

       87
       87
       -
               parser = FeedParser()

     

       88
       88
       -
               

     

       89
       89
       -
               # Test allowed tags

     

       90
       90
       -
               safe_html = "<p>This is <strong>safe</strong> HTML</p>"

     

       91
       91
       -
               sanitized = parser._sanitize_html(safe_html)

     

       92
       92
       -
               assert sanitized == safe_html

     

       93
       93
       -
               

     

       94
       94
       -
               # Test dangerous tags

     

       95
       95
       -
               dangerous_html = "<script>alert('xss')</script><p>Safe content</p>"

     

       96
       96
       -
               sanitized = parser._sanitize_html(dangerous_html)

     

       97
       97
       -
               assert "<script>" not in sanitized

     

       98
       98
       -
               assert "<p>Safe content</p>" in sanitized

     

       99
       99
       -
               

     

       100
       100
       -
               # Test attributes

     

       101
       101
       -
               html_with_attrs = '<a href="https://example.com" onclick="alert()">Link</a>'

     

       102
       102
       -
               sanitized = parser._sanitize_html(html_with_attrs)

     

       103
       103
       -
               assert 'href="https://example.com"' in sanitized

     

       104
       104
       -
               assert 'onclick' not in sanitized

     

       105
       105
       -
       

     

       106
       106
       -
           def test_extract_feed_metadata(self):

     

       107
       107
       -
               """Test feed metadata extraction."""

     

       108
       108
       -
               parser = FeedParser()

     

       109
       109
       -
               

     

       110
       110
       -
               # Test with feedparser parsed data

     

       111
       111
       -
               import feedparser

     

       112
       112
       -
               parsed = feedparser.parse("""<?xml version="1.0" encoding="utf-8"?>

     

       113
       113
       -
       <feed xmlns="http://www.w3.org/2005/Atom">

     

       114
       114
       -
         <title>Test Feed</title>

     

       115
       115
       -
         <link href="https://example.com/"/>

     

       116
       116
       -
         <author>

     

       117
       117
       -
           <name>Test Author</name>

     

       118
       118
       -
           <email>author@example.com</email>

     

       119
       119
       -
           <uri>https://example.com/about</uri>

     

       120
       120
       -
         </author>

     

       121
       121
       -
         <logo>https://example.com/logo.png</logo>

     

       122
       122
       -
         <icon>https://example.com/icon.png</icon>

     

       123
       123
       -
       </feed>""")

     

       124
       124
       -
               

     

       125
       125
       -
               metadata = parser._extract_feed_metadata(parsed.feed)

     

       126
       126
       -
               assert metadata.title == "Test Feed"

     

       127
       127
       -
               assert metadata.author_name == "Test Author"

     

       128
       128
       -
               assert metadata.author_email == "author@example.com"

     

       129
       129
       -
               assert metadata.author_uri == HttpUrl("https://example.com/about")

     

       130
       130
       -
               assert metadata.link == HttpUrl("https://example.com/")

     

       131
       131
       -
               assert metadata.logo == HttpUrl("https://example.com/logo.png")

     

       132
       132
       -
               assert metadata.icon == HttpUrl("https://example.com/icon.png")

-277

tests/test_git_store.py

···

       1
       1
       -
       """Tests for Git store functionality."""

     

       2
       2
       -
       

     

       3
       3
       -
       import json

     

       4
       4
       -
       from datetime import datetime

     

       5
       5
       -
       

     

       6
       6
       -
       import pytest

     

       7
       7
       -
       from pydantic import HttpUrl

     

       8
       8
       -
       

     

       9
       9
       -
       from thicket.core.git_store import GitStore

     

       10
       10
       -
       from thicket.models import AtomEntry, DuplicateMap, UserMetadata

     

       11
       11
       -
       

     

       12
       12
       -
       

     

       13
       13
       -
       class TestGitStore:

     

       14
       14
       -
           """Test the GitStore class."""

     

       15
       15
       -
       

     

       16
       16
       -
           def test_init_new_repo(self, temp_dir):

     

       17
       17
       -
               """Test initializing a new Git repository."""

     

       18
       18
       -
               repo_path = temp_dir / "test_repo"

     

       19
       19
       -
               store = GitStore(repo_path)

     

       20
       20
       -
               

     

       21
       21
       -
               assert store.repo_path == repo_path

     

       22
       22
       -
               assert store.repo is not None

     

       23
       23
       -
               assert repo_path.exists()

     

       24
       24
       -
               assert (repo_path / ".git").exists()

     

       25
       25
       -
               assert (repo_path / "index.json").exists()

     

       26
       26
       -
               assert (repo_path / "duplicates.json").exists()

     

       27
       27
       -
       

     

       28
       28
       -
           def test_init_existing_repo(self, temp_dir):

     

       29
       29
       -
               """Test initializing with existing repository."""

     

       30
       30
       -
               repo_path = temp_dir / "test_repo"

     

       31
       31
       -
               

     

       32
       32
       -
               # Create first store

     

       33
       33
       -
               store1 = GitStore(repo_path)

     

       34
       34
       -
               store1.add_user("testuser", display_name="Test User")

     

       35
       35
       -
               

     

       36
       36
       -
               # Create second store pointing to same repo

     

       37
       37
       -
               store2 = GitStore(repo_path)

     

       38
       38
       -
               user = store2.get_user("testuser")

     

       39
       39
       -
               

     

       40
       40
       -
               assert user is not None

     

       41
       41
       -
               assert user.username == "testuser"

     

       42
       42
       -
               assert user.display_name == "Test User"

     

       43
       43
       -
       

     

       44
       44
       -
           def test_add_user(self, temp_dir):

     

       45
       45
       -
               """Test adding a user to the Git store."""

     

       46
       46
       -
               store = GitStore(temp_dir / "test_repo")

     

       47
       47
       -
               

     

       48
       48
       -
               user = store.add_user(

     

       49
       49
       -
                   username="testuser",

     

       50
       50
       -
                   display_name="Test User",

     

       51
       51
       -
                   email="test@example.com",

     

       52
       52
       -
                   homepage="https://example.com",

     

       53
       53
       -
                   icon="https://example.com/icon.png",

     

       54
       54
       -
                   feeds=["https://example.com/feed.xml"],

     

       55
       55
       -
               )

     

       56
       56
       -
               

     

       57
       57
       -
               assert isinstance(user, UserMetadata)

     

       58
       58
       -
               assert user.username == "testuser"

     

       59
       59
       -
               assert user.display_name == "Test User"

     

       60
       60
       -
               assert user.email == "test@example.com"

     

       61
       61
       -
               assert user.homepage == "https://example.com"

     

       62
       62
       -
               assert user.icon == "https://example.com/icon.png"

     

       63
       63
       -
               assert user.feeds == ["https://example.com/feed.xml"]

     

       64
       64
       -
               assert user.directory == "testuser"

     

       65
       65
       -
               

     

       66
       66
       -
               # Check that user directory was created

     

       67
       67
       -
               user_dir = store.repo_path / "testuser"

     

       68
       68
       -
               assert user_dir.exists()

     

       69
       69
       -
               assert (user_dir / "metadata.json").exists()

     

       70
       70
       -
               

     

       71
       71
       -
               # Check metadata file content

     

       72
       72
       -
               with open(user_dir / "metadata.json") as f:

     

       73
       73
       -
                   metadata = json.load(f)

     

       74
       74
       -
               assert metadata["username"] == "testuser"

     

       75
       75
       -
               assert metadata["display_name"] == "Test User"

     

       76
       76
       -
       

     

       77
       77
       -
           def test_get_user(self, temp_dir):

     

       78
       78
       -
               """Test getting user metadata."""

     

       79
       79
       -
               store = GitStore(temp_dir / "test_repo")

     

       80
       80
       -
               

     

       81
       81
       -
               # Add user

     

       82
       82
       -
               store.add_user("testuser", display_name="Test User")

     

       83
       83
       -
               

     

       84
       84
       -
               # Get user

     

       85
       85
       -
               user = store.get_user("testuser")

     

       86
       86
       -
               assert user is not None

     

       87
       87
       -
               assert user.username == "testuser"

     

       88
       88
       -
               assert user.display_name == "Test User"

     

       89
       89
       -
               

     

       90
       90
       -
               # Try to get non-existent user

     

       91
       91
       -
               non_user = store.get_user("nonexistent")

     

       92
       92
       -
               assert non_user is None

     

       93
       93
       -
       

     

       94
       94
       -
           def test_store_entry(self, temp_dir):

     

       95
       95
       -
               """Test storing an entry."""

     

       96
       96
       -
               store = GitStore(temp_dir / "test_repo")

     

       97
       97
       -
               

     

       98
       98
       -
               # Add user first

     

       99
       99
       -
               store.add_user("testuser")

     

       100
       100
       -
               

     

       101
       101
       -
               # Create test entry

     

       102
       102
       -
               entry = AtomEntry(

     

       103
       103
       -
                   id="https://example.com/entry/1",

     

       104
       104
       -
                   title="Test Entry",

     

       105
       105
       -
                   link=HttpUrl("https://example.com/entry/1"),

     

       106
       106
       -
                   updated=datetime.now(),

     

       107
       107
       -
                   summary="Test entry summary",

     

       108
       108
       -
                   content="<p>Test content</p>",

     

       109
       109
       -
               )

     

       110
       110
       -
               

     

       111
       111
       -
               # Store entry

     

       112
       112
       -
               result = store.store_entry("testuser", entry)

     

       113
       113
       -
               assert result is True

     

       114
       114
       -
               

     

       115
       115
       -
               # Check that entry file was created

     

       116
       116
       -
               user_dir = store.repo_path / "testuser"

     

       117
       117
       -
               entry_files = list(user_dir.glob("*.json"))

     

       118
       118
       -
               entry_files = [f for f in entry_files if f.name != "metadata.json"]

     

       119
       119
       -
               assert len(entry_files) == 1

     

       120
       120
       -
               

     

       121
       121
       -
               # Check entry content

     

       122
       122
       -
               with open(entry_files[0]) as f:

     

       123
       123
       -
                   stored_entry = json.load(f)

     

       124
       124
       -
               assert stored_entry["title"] == "Test Entry"

     

       125
       125
       -
               assert stored_entry["id"] == "https://example.com/entry/1"

     

       126
       126
       -
       

     

       127
       127
       -
           def test_get_entry(self, temp_dir):

     

       128
       128
       -
               """Test retrieving an entry."""

     

       129
       129
       -
               store = GitStore(temp_dir / "test_repo")

     

       130
       130
       -
               

     

       131
       131
       -
               # Add user and entry

     

       132
       132
       -
               store.add_user("testuser")

     

       133
       133
       -
               entry = AtomEntry(

     

       134
       134
       -
                   id="https://example.com/entry/1",

     

       135
       135
       -
                   title="Test Entry",

     

       136
       136
       -
                   link=HttpUrl("https://example.com/entry/1"),

     

       137
       137
       -
                   updated=datetime.now(),

     

       138
       138
       -
               )

     

       139
       139
       -
               store.store_entry("testuser", entry)

     

       140
       140
       -
               

     

       141
       141
       -
               # Get entry

     

       142
       142
       -
               retrieved = store.get_entry("testuser", "https://example.com/entry/1")

     

       143
       143
       -
               assert retrieved is not None

     

       144
       144
       -
               assert retrieved.title == "Test Entry"

     

       145
       145
       -
               assert retrieved.id == "https://example.com/entry/1"

     

       146
       146
       -
               

     

       147
       147
       -
               # Try to get non-existent entry

     

       148
       148
       -
               non_entry = store.get_entry("testuser", "https://example.com/nonexistent")

     

       149
       149
       -
               assert non_entry is None

     

       150
       150
       -
       

     

       151
       151
       -
           def test_list_entries(self, temp_dir):

     

       152
       152
       -
               """Test listing entries for a user."""

     

       153
       153
       -
               store = GitStore(temp_dir / "test_repo")

     

       154
       154
       -
               

     

       155
       155
       -
               # Add user

     

       156
       156
       -
               store.add_user("testuser")

     

       157
       157
       -
               

     

       158
       158
       -
               # Add multiple entries

     

       159
       159
       -
               for i in range(3):

     

       160
       160
       -
                   entry = AtomEntry(

     

       161
       161
       -
                       id=f"https://example.com/entry/{i}",

     

       162
       162
       -
                       title=f"Test Entry {i}",

     

       163
       163
       -
                       link=HttpUrl(f"https://example.com/entry/{i}"),

     

       164
       164
       -
                       updated=datetime.now(),

     

       165
       165
       -
                   )

     

       166
       166
       -
                   store.store_entry("testuser", entry)

     

       167
       167
       -
               

     

       168
       168
       -
               # List all entries

     

       169
       169
       -
               entries = store.list_entries("testuser")

     

       170
       170
       -
               assert len(entries) == 3

     

       171
       171
       -
               

     

       172
       172
       -
               # List with limit

     

       173
       173
       -
               limited = store.list_entries("testuser", limit=2)

     

       174
       174
       -
               assert len(limited) == 2

     

       175
       175
       -
               

     

       176
       176
       -
               # List for non-existent user

     

       177
       177
       -
               none_entries = store.list_entries("nonexistent")

     

       178
       178
       -
               assert len(none_entries) == 0

     

       179
       179
       -
       

     

       180
       180
       -
           def test_duplicates(self, temp_dir):

     

       181
       181
       -
               """Test duplicate management."""

     

       182
       182
       -
               store = GitStore(temp_dir / "test_repo")

     

       183
       183
       -
               

     

       184
       184
       -
               # Get initial duplicates (should be empty)

     

       185
       185
       -
               duplicates = store.get_duplicates()

     

       186
       186
       -
               assert isinstance(duplicates, DuplicateMap)

     

       187
       187
       -
               assert len(duplicates.duplicates) == 0

     

       188
       188
       -
               

     

       189
       189
       -
               # Add duplicate

     

       190
       190
       -
               store.add_duplicate("https://example.com/dup", "https://example.com/canonical")

     

       191
       191
       -
               

     

       192
       192
       -
               # Check duplicate was added

     

       193
       193
       -
               duplicates = store.get_duplicates()

     

       194
       194
       -
               assert len(duplicates.duplicates) == 1

     

       195
       195
       -
               assert duplicates.is_duplicate("https://example.com/dup")

     

       196
       196
       -
               assert duplicates.get_canonical("https://example.com/dup") == "https://example.com/canonical"

     

       197
       197
       -
               

     

       198
       198
       -
               # Remove duplicate

     

       199
       199
       -
               result = store.remove_duplicate("https://example.com/dup")

     

       200
       200
       -
               assert result is True

     

       201
       201
       -
               

     

       202
       202
       -
               # Check duplicate was removed

     

       203
       203
       -
               duplicates = store.get_duplicates()

     

       204
       204
       -
               assert len(duplicates.duplicates) == 0

     

       205
       205
       -
               assert not duplicates.is_duplicate("https://example.com/dup")

     

       206
       206
       -
       

     

       207
       207
       -
           def test_search_entries(self, temp_dir):

     

       208
       208
       -
               """Test searching entries."""

     

       209
       209
       -
               store = GitStore(temp_dir / "test_repo")

     

       210
       210
       -
               

     

       211
       211
       -
               # Add user

     

       212
       212
       -
               store.add_user("testuser")

     

       213
       213
       -
               

     

       214
       214
       -
               # Add entries with different content

     

       215
       215
       -
               entries_data = [

     

       216
       216
       -
                   ("Test Python Programming", "Learning Python basics"),

     

       217
       217
       -
                   ("JavaScript Tutorial", "Advanced JavaScript concepts"),

     

       218
       218
       -
                   ("Python Web Development", "Building web apps with Python"),

     

       219
       219
       -
               ]

     

       220
       220
       -
               

     

       221
       221
       -
               for title, summary in entries_data:

     

       222
       222
       -
                   entry = AtomEntry(

     

       223
       223
       -
                       id=f"https://example.com/entry/{title.lower().replace(' ', '-')}",

     

       224
       224
       -
                       title=title,

     

       225
       225
       -
                       link=HttpUrl(f"https://example.com/entry/{title.lower().replace(' ', '-')}"),

     

       226
       226
       -
                       updated=datetime.now(),

     

       227
       227
       -
                       summary=summary,

     

       228
       228
       -
                   )

     

       229
       229
       -
                   store.store_entry("testuser", entry)

     

       230
       230
       -
               

     

       231
       231
       -
               # Search for Python entries

     

       232
       232
       -
               results = store.search_entries("Python")

     

       233
       233
       -
               assert len(results) == 2

     

       234
       234
       -
               

     

       235
       235
       -
               # Search for specific user

     

       236
       236
       -
               results = store.search_entries("Python", username="testuser")

     

       237
       237
       -
               assert len(results) == 2

     

       238
       238
       -
               

     

       239
       239
       -
               # Search with limit

     

       240
       240
       -
               results = store.search_entries("Python", limit=1)

     

       241
       241
       -
               assert len(results) == 1

     

       242
       242
       -
               

     

       243
       243
       -
               # Search for non-existent term

     

       244
       244
       -
               results = store.search_entries("NonExistent")

     

       245
       245
       -
               assert len(results) == 0

     

       246
       246
       -
       

     

       247
       247
       -
           def test_get_stats(self, temp_dir):

     

       248
       248
       -
               """Test getting repository statistics."""

     

       249
       249
       -
               store = GitStore(temp_dir / "test_repo")

     

       250
       250
       -
               

     

       251
       251
       -
               # Get initial stats

     

       252
       252
       -
               stats = store.get_stats()

     

       253
       253
       -
               assert stats["total_users"] == 0

     

       254
       254
       -
               assert stats["total_entries"] == 0

     

       255
       255
       -
               assert stats["total_duplicates"] == 0

     

       256
       256
       -
               

     

       257
       257
       -
               # Add user and entries

     

       258
       258
       -
               store.add_user("testuser")

     

       259
       259
       -
               for i in range(3):

     

       260
       260
       -
                   entry = AtomEntry(

     

       261
       261
       -
                       id=f"https://example.com/entry/{i}",

     

       262
       262
       -
                       title=f"Test Entry {i}",

     

       263
       263
       -
                       link=HttpUrl(f"https://example.com/entry/{i}"),

     

       264
       264
       -
                       updated=datetime.now(),

     

       265
       265
       -
                   )

     

       266
       266
       -
                   store.store_entry("testuser", entry)

     

       267
       267
       -
               

     

       268
       268
       -
               # Add duplicate

     

       269
       269
       -
               store.add_duplicate("https://example.com/dup", "https://example.com/canonical")

     

       270
       270
       -
               

     

       271
       271
       -
               # Get updated stats

     

       272
       272
       -
               stats = store.get_stats()

     

       273
       273
       -
               assert stats["total_users"] == 1

     

       274
       274
       -
               assert stats["total_entries"] == 3

     

       275
       275
       -
               assert stats["total_duplicates"] == 1

     

       276
       276
       -
               assert "last_updated" in stats

     

       277
       277
       -
               assert "repository_size" in stats

-353

tests/test_models.py

···

       1
       1
       -
       """Tests for pydantic models."""

     

       2
       2
       -
       

     

       3
       3
       -
       from datetime import datetime

     

       4
       4
       -
       from pathlib import Path

     

       5
       5
       -
       

     

       6
       6
       -
       import pytest

     

       7
       7
       -
       from pydantic import HttpUrl, ValidationError

     

       8
       8
       -
       

     

       9
       9
       -
       from thicket.models import (

     

       10
       10
       -
           AtomEntry,

     

       11
       11
       -
           DuplicateMap,

     

       12
       12
       -
           FeedMetadata,

     

       13
       13
       -
           ThicketConfig,

     

       14
       14
       -
           UserConfig,

     

       15
       15
       -
           UserMetadata,

     

       16
       16
       -
       )

     

       17
       17
       -
       

     

       18
       18
       -
       

     

       19
       19
       -
       class TestUserConfig:

     

       20
       20
       -
           """Test UserConfig model."""

     

       21
       21
       -
       

     

       22
       22
       -
           def test_valid_user_config(self):

     

       23
       23
       -
               """Test creating valid user config."""

     

       24
       24
       -
               config = UserConfig(

     

       25
       25
       -
                   username="testuser",

     

       26
       26
       -
                   feeds=["https://example.com/feed.xml"],

     

       27
       27
       -
                   email="test@example.com",

     

       28
       28
       -
                   homepage="https://example.com",

     

       29
       29
       -
                   display_name="Test User",

     

       30
       30
       -
               )

     

       31
       31
       -
               

     

       32
       32
       -
               assert config.username == "testuser"

     

       33
       33
       -
               assert len(config.feeds) == 1

     

       34
       34
       -
               assert config.feeds[0] == HttpUrl("https://example.com/feed.xml")

     

       35
       35
       -
               assert config.email == "test@example.com"

     

       36
       36
       -
               assert config.display_name == "Test User"

     

       37
       37
       -
       

     

       38
       38
       -
           def test_invalid_email(self):

     

       39
       39
       -
               """Test validation of invalid email."""

     

       40
       40
       -
               with pytest.raises(ValidationError):

     

       41
       41
       -
                   UserConfig(

     

       42
       42
       -
                       username="testuser",

     

       43
       43
       -
                       feeds=["https://example.com/feed.xml"],

     

       44
       44
       -
                       email="invalid-email",

     

       45
       45
       -
                   )

     

       46
       46
       -
       

     

       47
       47
       -
           def test_invalid_feed_url(self):

     

       48
       48
       -
               """Test validation of invalid feed URL."""

     

       49
       49
       -
               with pytest.raises(ValidationError):

     

       50
       50
       -
                   UserConfig(

     

       51
       51
       -
                       username="testuser",

     

       52
       52
       -
                       feeds=["not-a-url"],

     

       53
       53
       -
                   )

     

       54
       54
       -
       

     

       55
       55
       -
           def test_optional_fields(self):

     

       56
       56
       -
               """Test optional fields with None values."""

     

       57
       57
       -
               config = UserConfig(

     

       58
       58
       -
                   username="testuser",

     

       59
       59
       -
                   feeds=["https://example.com/feed.xml"],

     

       60
       60
       -
               )

     

       61
       61
       -
               

     

       62
       62
       -
               assert config.email is None

     

       63
       63
       -
               assert config.homepage is None

     

       64
       64
       -
               assert config.icon is None

     

       65
       65
       -
               assert config.display_name is None

     

       66
       66
       -
       

     

       67
       67
       -
       

     

       68
       68
       -
       class TestThicketConfig:

     

       69
       69
       -
           """Test ThicketConfig model."""

     

       70
       70
       -
       

     

       71
       71
       -
           def test_valid_config(self, temp_dir):

     

       72
       72
       -
               """Test creating valid configuration."""

     

       73
       73
       -
               config = ThicketConfig(

     

       74
       74
       -
                   git_store=temp_dir / "git_store",

     

       75
       75
       -
                   cache_dir=temp_dir / "cache",

     

       76
       76
       -
                   users=[

     

       77
       77
       -
                       UserConfig(

     

       78
       78
       -
                           username="testuser",

     

       79
       79
       -
                           feeds=["https://example.com/feed.xml"],

     

       80
       80
       -
                       )

     

       81
       81
       -
                   ],

     

       82
       82
       -
               )

     

       83
       83
       -
               

     

       84
       84
       -
               assert config.git_store == temp_dir / "git_store"

     

       85
       85
       -
               assert config.cache_dir == temp_dir / "cache"

     

       86
       86
       -
               assert len(config.users) == 1

     

       87
       87
       -
               assert config.users[0].username == "testuser"

     

       88
       88
       -
       

     

       89
       89
       -
           def test_find_user(self, temp_dir):

     

       90
       90
       -
               """Test finding user by username."""

     

       91
       91
       -
               config = ThicketConfig(

     

       92
       92
       -
                   git_store=temp_dir / "git_store",

     

       93
       93
       -
                   cache_dir=temp_dir / "cache",

     

       94
       94
       -
                   users=[

     

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

     

       96
       96
       -
                       UserConfig(username="user2", feeds=["https://example.com/feed2.xml"]),

     

       97
       97
       -
                   ],

     

       98
       98
       -
               )

     

       99
       99
       -
               

     

       100
       100
       -
               user = config.find_user("user1")

     

       101
       101
       -
               assert user is not None

     

       102
       102
       -
               assert user.username == "user1"

     

       103
       103
       -
               

     

       104
       104
       -
               non_user = config.find_user("nonexistent")

     

       105
       105
       -
               assert non_user is None

     

       106
       106
       -
       

     

       107
       107
       -
           def test_add_user(self, temp_dir):

     

       108
       108
       -
               """Test adding a new user."""

     

       109
       109
       -
               config = ThicketConfig(

     

       110
       110
       -
                   git_store=temp_dir / "git_store",

     

       111
       111
       -
                   cache_dir=temp_dir / "cache",

     

       112
       112
       -
                   users=[],

     

       113
       113
       -
               )

     

       114
       114
       -
               

     

       115
       115
       -
               new_user = UserConfig(

     

       116
       116
       -
                   username="newuser",

     

       117
       117
       -
                   feeds=["https://example.com/feed.xml"],

     

       118
       118
       -
               )

     

       119
       119
       -
               

     

       120
       120
       -
               config.add_user(new_user)

     

       121
       121
       -
               assert len(config.users) == 1

     

       122
       122
       -
               assert config.users[0].username == "newuser"

     

       123
       123
       -
       

     

       124
       124
       -
           def test_add_feed_to_user(self, temp_dir):

     

       125
       125
       -
               """Test adding feed to existing user."""

     

       126
       126
       -
               config = ThicketConfig(

     

       127
       127
       -
                   git_store=temp_dir / "git_store",

     

       128
       128
       -
                   cache_dir=temp_dir / "cache",

     

       129
       129
       -
                   users=[

     

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

     

       131
       131
       -
                   ],

     

       132
       132
       -
               )

     

       133
       133
       -
               

     

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

     

       135
       135
       -
               assert result is True

     

       136
       136
       -
               

     

       137
       137
       -
               user = config.find_user("testuser")

     

       138
       138
       -
               assert len(user.feeds) == 2

     

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

     

       140
       140
       -
               

     

       141
       141
       -
               # Test adding to non-existent user

     

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

     

       143
       143
       -
               assert result is False

     

       144
       144
       -
       

     

       145
       145
       -
       

     

       146
       146
       -
       class TestAtomEntry:

     

       147
       147
       -
           """Test AtomEntry model."""

     

       148
       148
       -
       

     

       149
       149
       -
           def test_valid_entry(self):

     

       150
       150
       -
               """Test creating valid Atom entry."""

     

       151
       151
       -
               entry = AtomEntry(

     

       152
       152
       -
                   id="https://example.com/entry/1",

     

       153
       153
       -
                   title="Test Entry",

     

       154
       154
       -
                   link=HttpUrl("https://example.com/entry/1"),

     

       155
       155
       -
                   updated=datetime.now(),

     

       156
       156
       -
                   published=datetime.now(),

     

       157
       157
       -
                   summary="Test summary",

     

       158
       158
       -
                   content="<p>Test content</p>",

     

       159
       159
       -
                   content_type="html",

     

       160
       160
       -
                   author={"name": "Test Author"},

     

       161
       161
       -
                   categories=["test", "example"],

     

       162
       162
       -
               )

     

       163
       163
       -
               

     

       164
       164
       -
               assert entry.id == "https://example.com/entry/1"

     

       165
       165
       -
               assert entry.title == "Test Entry"

     

       166
       166
       -
               assert entry.summary == "Test summary"

     

       167
       167
       -
               assert entry.content == "<p>Test content</p>"

     

       168
       168
       -
               assert entry.content_type == "html"

     

       169
       169
       -
               assert entry.author["name"] == "Test Author"

     

       170
       170
       -
               assert "test" in entry.categories

     

       171
       171
       -
       

     

       172
       172
       -
           def test_minimal_entry(self):

     

       173
       173
       -
               """Test creating minimal Atom entry."""

     

       174
       174
       -
               entry = AtomEntry(

     

       175
       175
       -
                   id="https://example.com/entry/1",

     

       176
       176
       -
                   title="Test Entry",

     

       177
       177
       -
                   link=HttpUrl("https://example.com/entry/1"),

     

       178
       178
       -
                   updated=datetime.now(),

     

       179
       179
       -
               )

     

       180
       180
       -
               

     

       181
       181
       -
               assert entry.id == "https://example.com/entry/1"

     

       182
       182
       -
               assert entry.title == "Test Entry"

     

       183
       183
       -
               assert entry.published is None

     

       184
       184
       -
               assert entry.summary is None

     

       185
       185
       -
               assert entry.content is None

     

       186
       186
       -
               assert entry.content_type == "html"  # default

     

       187
       187
       -
               assert entry.author is None

     

       188
       188
       -
               assert entry.categories == []

     

       189
       189
       -
       

     

       190
       190
       -
       

     

       191
       191
       -
       class TestDuplicateMap:

     

       192
       192
       -
           """Test DuplicateMap model."""

     

       193
       193
       -
       

     

       194
       194
       -
           def test_empty_duplicates(self):

     

       195
       195
       -
               """Test empty duplicate map."""

     

       196
       196
       -
               dup_map = DuplicateMap()

     

       197
       197
       -
               assert len(dup_map.duplicates) == 0

     

       198
       198
       -
               assert not dup_map.is_duplicate("test")

     

       199
       199
       -
               assert dup_map.get_canonical("test") == "test"

     

       200
       200
       -
       

     

       201
       201
       -
           def test_add_duplicate(self):

     

       202
       202
       -
               """Test adding duplicate mapping."""

     

       203
       203
       -
               dup_map = DuplicateMap()

     

       204
       204
       -
               dup_map.add_duplicate("dup1", "canonical1")

     

       205
       205
       -
               

     

       206
       206
       -
               assert len(dup_map.duplicates) == 1

     

       207
       207
       -
               assert dup_map.is_duplicate("dup1")

     

       208
       208
       -
               assert dup_map.get_canonical("dup1") == "canonical1"

     

       209
       209
       -
               assert dup_map.get_canonical("canonical1") == "canonical1"

     

       210
       210
       -
       

     

       211
       211
       -
           def test_remove_duplicate(self):

     

       212
       212
       -
               """Test removing duplicate mapping."""

     

       213
       213
       -
               dup_map = DuplicateMap()

     

       214
       214
       -
               dup_map.add_duplicate("dup1", "canonical1")

     

       215
       215
       -
               

     

       216
       216
       -
               result = dup_map.remove_duplicate("dup1")

     

       217
       217
       -
               assert result is True

     

       218
       218
       -
               assert len(dup_map.duplicates) == 0

     

       219
       219
       -
               assert not dup_map.is_duplicate("dup1")

     

       220
       220
       -
               

     

       221
       221
       -
               # Test removing non-existent duplicate

     

       222
       222
       -
               result = dup_map.remove_duplicate("nonexistent")

     

       223
       223
       -
               assert result is False

     

       224
       224
       -
       

     

       225
       225
       -
           def test_get_duplicates_for_canonical(self):

     

       226
       226
       -
               """Test getting all duplicates for a canonical ID."""

     

       227
       227
       -
               dup_map = DuplicateMap()

     

       228
       228
       -
               dup_map.add_duplicate("dup1", "canonical1")

     

       229
       229
       -
               dup_map.add_duplicate("dup2", "canonical1")

     

       230
       230
       -
               dup_map.add_duplicate("dup3", "canonical2")

     

       231
       231
       -
               

     

       232
       232
       -
               dups = dup_map.get_duplicates_for_canonical("canonical1")

     

       233
       233
       -
               assert len(dups) == 2

     

       234
       234
       -
               assert "dup1" in dups

     

       235
       235
       -
               assert "dup2" in dups

     

       236
       236
       -
               

     

       237
       237
       -
               dups = dup_map.get_duplicates_for_canonical("canonical2")

     

       238
       238
       -
               assert len(dups) == 1

     

       239
       239
       -
               assert "dup3" in dups

     

       240
       240
       -
               

     

       241
       241
       -
               dups = dup_map.get_duplicates_for_canonical("nonexistent")

     

       242
       242
       -
               assert len(dups) == 0

     

       243
       243
       -
       

     

       244
       244
       -
       

     

       245
       245
       -
       class TestFeedMetadata:

     

       246
       246
       -
           """Test FeedMetadata model."""

     

       247
       247
       -
       

     

       248
       248
       -
           def test_valid_metadata(self):

     

       249
       249
       -
               """Test creating valid feed metadata."""

     

       250
       250
       -
               metadata = FeedMetadata(

     

       251
       251
       -
                   title="Test Feed",

     

       252
       252
       -
                   author_name="Test Author",

     

       253
       253
       -
                   author_email="author@example.com",

     

       254
       254
       -
                   author_uri=HttpUrl("https://example.com/author"),

     

       255
       255
       -
                   link=HttpUrl("https://example.com"),

     

       256
       256
       -
                   description="Test description",

     

       257
       257
       -
               )

     

       258
       258
       -
               

     

       259
       259
       -
               assert metadata.title == "Test Feed"

     

       260
       260
       -
               assert metadata.author_name == "Test Author"

     

       261
       261
       -
               assert metadata.author_email == "author@example.com"

     

       262
       262
       -
               assert metadata.link == HttpUrl("https://example.com")

     

       263
       263
       -
       

     

       264
       264
       -
           def test_to_user_config(self):

     

       265
       265
       -
               """Test converting metadata to user config."""

     

       266
       266
       -
               metadata = FeedMetadata(

     

       267
       267
       -
                   title="Test Feed",

     

       268
       268
       -
                   author_name="Test Author",

     

       269
       269
       -
                   author_email="author@example.com",

     

       270
       270
       -
                   author_uri=HttpUrl("https://example.com/author"),

     

       271
       271
       -
                   link=HttpUrl("https://example.com"),

     

       272
       272
       -
                   logo=HttpUrl("https://example.com/logo.png"),

     

       273
       273
       -
               )

     

       274
       274
       -
               

     

       275
       275
       -
               feed_url = HttpUrl("https://example.com/feed.xml")

     

       276
       276
       -
               user_config = metadata.to_user_config("testuser", feed_url)

     

       277
       277
       -
               

     

       278
       278
       -
               assert user_config.username == "testuser"

     

       279
       279
       -
               assert user_config.feeds == [feed_url]

     

       280
       280
       -
               assert user_config.display_name == "Test Author"

     

       281
       281
       -
               assert user_config.email == "author@example.com"

     

       282
       282
       -
               assert user_config.homepage == HttpUrl("https://example.com/author")

     

       283
       283
       -
               assert user_config.icon == HttpUrl("https://example.com/logo.png")

     

       284
       284
       -
       

     

       285
       285
       -
           def test_to_user_config_fallbacks(self):

     

       286
       286
       -
               """Test fallback logic in to_user_config."""

     

       287
       287
       -
               metadata = FeedMetadata(

     

       288
       288
       -
                   title="Test Feed",

     

       289
       289
       -
                   link=HttpUrl("https://example.com"),

     

       290
       290
       -
                   icon=HttpUrl("https://example.com/icon.png"),

     

       291
       291
       -
               )

     

       292
       292
       -
               

     

       293
       293
       -
               feed_url = HttpUrl("https://example.com/feed.xml")

     

       294
       294
       -
               user_config = metadata.to_user_config("testuser", feed_url)

     

       295
       295
       -
               

     

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

     

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

     

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

     

       299
       299
       -
               assert user_config.email is None

     

       300
       300
       -
       

     

       301
       301
       -
       

     

       302
       302
       -
       class TestUserMetadata:

     

       303
       303
       -
           """Test UserMetadata model."""

     

       304
       304
       -
       

     

       305
       305
       -
           def test_valid_metadata(self):

     

       306
       306
       -
               """Test creating valid user metadata."""

     

       307
       307
       -
               now = datetime.now()

     

       308
       308
       -
               metadata = UserMetadata(

     

       309
       309
       -
                   username="testuser",

     

       310
       310
       -
                   directory="testuser",

     

       311
       311
       -
                   created=now,

     

       312
       312
       -
                   last_updated=now,

     

       313
       313
       -
                   feeds=["https://example.com/feed.xml"],

     

       314
       314
       -
                   entry_count=5,

     

       315
       315
       -
               )

     

       316
       316
       -
               

     

       317
       317
       -
               assert metadata.username == "testuser"

     

       318
       318
       -
               assert metadata.directory == "testuser"

     

       319
       319
       -
               assert metadata.entry_count == 5

     

       320
       320
       -
               assert len(metadata.feeds) == 1

     

       321
       321
       -
       

     

       322
       322
       -
           def test_update_timestamp(self):

     

       323
       323
       -
               """Test updating timestamp."""

     

       324
       324
       -
               now = datetime.now()

     

       325
       325
       -
               metadata = UserMetadata(

     

       326
       326
       -
                   username="testuser",

     

       327
       327
       -
                   directory="testuser",

     

       328
       328
       -
                   created=now,

     

       329
       329
       -
                   last_updated=now,

     

       330
       330
       -
               )

     

       331
       331
       -
               

     

       332
       332
       -
               original_time = metadata.last_updated

     

       333
       333
       -
               metadata.update_timestamp()

     

       334
       334
       -
               

     

       335
       335
       -
               assert metadata.last_updated > original_time

     

       336
       336
       -
       

     

       337
       337
       -
           def test_increment_entry_count(self):

     

       338
       338
       -
               """Test incrementing entry count."""

     

       339
       339
       -
               metadata = UserMetadata(

     

       340
       340
       -
                   username="testuser",

     

       341
       341
       -
                   directory="testuser",

     

       342
       342
       -
                   created=datetime.now(),

     

       343
       343
       -
                   last_updated=datetime.now(),

     

       344
       344
       -
                   entry_count=5,

     

       345
       345
       -
               )

     

       346
       346
       -
               

     

       347
       347
       -
               original_count = metadata.entry_count

     

       348
       348
       -
               original_time = metadata.last_updated

     

       349
       349
       -
               

     

       350
       350
       -
               metadata.increment_entry_count(3)

     

       351
       351
       -
               

     

       352
       352
       -
               assert metadata.entry_count == original_count + 3

     

       353
       353
       -
               assert metadata.last_updated > original_time

+1105

uv.lock

···

       1
       1
       +
       version = 1

     

       2
       2
       +
       revision = 2

     

       3
       3
       +
       requires-python = ">=3.9"

     

       4
       4
       +
       resolution-markers = [

     

       5
       5
       +
           "python_full_version >= '3.10'",

     

       6
       6
       +
           "python_full_version < '3.10'",

     

       7
       7
       +
       ]

     

       8
       8
       +
       

     

       9
       9
       +
       [[package]]

     

       10
       10
       +
       name = "annotated-types"

     

       11
       11
       +
       version = "0.7.0"

     

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

     

       13
       13
       +
       sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }

     

       14
       14
       +
       wheels = [

     

       15
       15
       +
           { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },

     

       16
       16
       +
       ]

     

       17
       17
       +
       

     

       18
       18
       +
       [[package]]

     

       19
       19
       +
       name = "anyio"

     

       20
       20
       +
       version = "4.9.0"

     

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

     

       22
       22
       +
       dependencies = [

     

       23
       23
       +
           { name = "exceptiongroup", marker = "python_full_version < '3.11'" },

     

       24
       24
       +
           { name = "idna" },

     

       25
       25
       +
           { name = "sniffio" },

     

       26
       26
       +
           { name = "typing-extensions", marker = "python_full_version < '3.13'" },

     

       27
       27
       +
       ]

     

       28
       28
       +
       sdist = { url = "https://files.pythonhosted.org/packages/95/7d/4c1bd541d4dffa1b52bd83fb8527089e097a106fc90b467a7313b105f840/anyio-4.9.0.tar.gz", hash = "sha256:673c0c244e15788651a4ff38710fea9675823028a6f08a5eda409e0c9840a028", size = 190949, upload-time = "2025-03-17T00:02:54.77Z" }

     

       29
       29
       +
       wheels = [

     

       30
       30
       +
           { url = "https://files.pythonhosted.org/packages/a1/ee/48ca1a7c89ffec8b6a0c5d02b89c305671d5ffd8d3c94acf8b8c408575bb/anyio-4.9.0-py3-none-any.whl", hash = "sha256:9f76d541cad6e36af7beb62e978876f3b41e3e04f2c1fbf0884604c0a9c4d93c", size = 100916, upload-time = "2025-03-17T00:02:52.713Z" },

     

       31
       31
       +
       ]

     

       32
       32
       +
       

     

       33
       33
       +
       [[package]]

     

       34
       34
       +
       name = "black"

     

       35
       35
       +
       version = "25.1.0"

     

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

     

       37
       37
       +
       dependencies = [

     

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

     

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

     

       40
       40
       +
           { name = "mypy-extensions" },

     

       41
       41
       +
           { name = "packaging" },

     

       42
       42
       +
           { name = "pathspec" },

     

       43
       43
       +
           { name = "platformdirs" },

     

       44
       44
       +
           { name = "tomli", marker = "python_full_version < '3.11'" },

     

       45
       45
       +
           { name = "typing-extensions", marker = "python_full_version < '3.11'" },

     

       46
       46
       +
       ]

     

       47
       47
       +
       sdist = { url = "https://files.pythonhosted.org/packages/94/49/26a7b0f3f35da4b5a65f081943b7bcd22d7002f5f0fb8098ec1ff21cb6ef/black-25.1.0.tar.gz", hash = "sha256:33496d5cd1222ad73391352b4ae8da15253c5de89b93a80b3e2c8d9a19ec2666", size = 649449, upload-time = "2025-01-29T04:15:40.373Z" }

     

       48
       48
       +
       wheels = [

     

       49
       49
       +
           { url = "https://files.pythonhosted.org/packages/4d/3b/4ba3f93ac8d90410423fdd31d7541ada9bcee1df32fb90d26de41ed40e1d/black-25.1.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:759e7ec1e050a15f89b770cefbf91ebee8917aac5c20483bc2d80a6c3a04df32", size = 1629419, upload-time = "2025-01-29T05:37:06.642Z" },

     

       50
       50
       +
           { url = "https://files.pythonhosted.org/packages/b4/02/0bde0485146a8a5e694daed47561785e8b77a0466ccc1f3e485d5ef2925e/black-25.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0e519ecf93120f34243e6b0054db49c00a35f84f195d5bce7e9f5cfc578fc2da", size = 1461080, upload-time = "2025-01-29T05:37:09.321Z" },

     

       51
       51
       +
           { url = "https://files.pythonhosted.org/packages/52/0e/abdf75183c830eaca7589144ff96d49bce73d7ec6ad12ef62185cc0f79a2/black-25.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:055e59b198df7ac0b7efca5ad7ff2516bca343276c466be72eb04a3bcc1f82d7", size = 1766886, upload-time = "2025-01-29T04:18:24.432Z" },

     

       52
       52
       +
           { url = "https://files.pythonhosted.org/packages/dc/a6/97d8bb65b1d8a41f8a6736222ba0a334db7b7b77b8023ab4568288f23973/black-25.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:db8ea9917d6f8fc62abd90d944920d95e73c83a5ee3383493e35d271aca872e9", size = 1419404, upload-time = "2025-01-29T04:19:04.296Z" },

     

       53
       53
       +
           { url = "https://files.pythonhosted.org/packages/7e/4f/87f596aca05c3ce5b94b8663dbfe242a12843caaa82dd3f85f1ffdc3f177/black-25.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a39337598244de4bae26475f77dda852ea00a93bd4c728e09eacd827ec929df0", size = 1614372, upload-time = "2025-01-29T05:37:11.71Z" },

     

       54
       54
       +
           { url = "https://files.pythonhosted.org/packages/e7/d0/2c34c36190b741c59c901e56ab7f6e54dad8df05a6272a9747ecef7c6036/black-25.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:96c1c7cd856bba8e20094e36e0f948718dc688dba4a9d78c3adde52b9e6c2299", size = 1442865, upload-time = "2025-01-29T05:37:14.309Z" },

     

       55
       55
       +
           { url = "https://files.pythonhosted.org/packages/21/d4/7518c72262468430ead45cf22bd86c883a6448b9eb43672765d69a8f1248/black-25.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bce2e264d59c91e52d8000d507eb20a9aca4a778731a08cfff7e5ac4a4bb7096", size = 1749699, upload-time = "2025-01-29T04:18:17.688Z" },

     

       56
       56
       +
           { url = "https://files.pythonhosted.org/packages/58/db/4f5beb989b547f79096e035c4981ceb36ac2b552d0ac5f2620e941501c99/black-25.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:172b1dbff09f86ce6f4eb8edf9dede08b1fce58ba194c87d7a4f1a5aa2f5b3c2", size = 1428028, upload-time = "2025-01-29T04:18:51.711Z" },

     

       57
       57
       +
           { url = "https://files.pythonhosted.org/packages/83/71/3fe4741df7adf015ad8dfa082dd36c94ca86bb21f25608eb247b4afb15b2/black-25.1.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4b60580e829091e6f9238c848ea6750efed72140b91b048770b64e74fe04908b", size = 1650988, upload-time = "2025-01-29T05:37:16.707Z" },

     

       58
       58
       +
           { url = "https://files.pythonhosted.org/packages/13/f3/89aac8a83d73937ccd39bbe8fc6ac8860c11cfa0af5b1c96d081facac844/black-25.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1e2978f6df243b155ef5fa7e558a43037c3079093ed5d10fd84c43900f2d8ecc", size = 1453985, upload-time = "2025-01-29T05:37:18.273Z" },

     

       59
       59
       +
           { url = "https://files.pythonhosted.org/packages/6f/22/b99efca33f1f3a1d2552c714b1e1b5ae92efac6c43e790ad539a163d1754/black-25.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3b48735872ec535027d979e8dcb20bf4f70b5ac75a8ea99f127c106a7d7aba9f", size = 1783816, upload-time = "2025-01-29T04:18:33.823Z" },

     

       60
       60
       +
           { url = "https://files.pythonhosted.org/packages/18/7e/a27c3ad3822b6f2e0e00d63d58ff6299a99a5b3aee69fa77cd4b0076b261/black-25.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:ea0213189960bda9cf99be5b8c8ce66bb054af5e9e861249cd23471bd7b0b3ba", size = 1440860, upload-time = "2025-01-29T04:19:12.944Z" },

     

       61
       61
       +
           { url = "https://files.pythonhosted.org/packages/98/87/0edf98916640efa5d0696e1abb0a8357b52e69e82322628f25bf14d263d1/black-25.1.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8f0b18a02996a836cc9c9c78e5babec10930862827b1b724ddfe98ccf2f2fe4f", size = 1650673, upload-time = "2025-01-29T05:37:20.574Z" },

     

       62
       62
       +
           { url = "https://files.pythonhosted.org/packages/52/e5/f7bf17207cf87fa6e9b676576749c6b6ed0d70f179a3d812c997870291c3/black-25.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:afebb7098bfbc70037a053b91ae8437c3857482d3a690fefc03e9ff7aa9a5fd3", size = 1453190, upload-time = "2025-01-29T05:37:22.106Z" },

     

       63
       63
       +
           { url = "https://files.pythonhosted.org/packages/e3/ee/adda3d46d4a9120772fae6de454c8495603c37c4c3b9c60f25b1ab6401fe/black-25.1.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:030b9759066a4ee5e5aca28c3c77f9c64789cdd4de8ac1df642c40b708be6171", size = 1782926, upload-time = "2025-01-29T04:18:58.564Z" },

     

       64
       64
       +
           { url = "https://files.pythonhosted.org/packages/cc/64/94eb5f45dcb997d2082f097a3944cfc7fe87e071907f677e80788a2d7b7a/black-25.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:a22f402b410566e2d1c950708c77ebf5ebd5d0d88a6a2e87c86d9fb48afa0d18", size = 1442613, upload-time = "2025-01-29T04:19:27.63Z" },

     

       65
       65
       +
           { url = "https://files.pythonhosted.org/packages/d3/b6/ae7507470a4830dbbfe875c701e84a4a5fb9183d1497834871a715716a92/black-25.1.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:a1ee0a0c330f7b5130ce0caed9936a904793576ef4d2b98c40835d6a65afa6a0", size = 1628593, upload-time = "2025-01-29T05:37:23.672Z" },

     

       66
       66
       +
           { url = "https://files.pythonhosted.org/packages/24/c1/ae36fa59a59f9363017ed397750a0cd79a470490860bc7713967d89cdd31/black-25.1.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f3df5f1bf91d36002b0a75389ca8663510cf0531cca8aa5c1ef695b46d98655f", size = 1460000, upload-time = "2025-01-29T05:37:25.829Z" },

     

       67
       67
       +
           { url = "https://files.pythonhosted.org/packages/ac/b6/98f832e7a6c49aa3a464760c67c7856363aa644f2f3c74cf7d624168607e/black-25.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d9e6827d563a2c820772b32ce8a42828dc6790f095f441beef18f96aa6f8294e", size = 1765963, upload-time = "2025-01-29T04:18:38.116Z" },

     

       68
       68
       +
           { url = "https://files.pythonhosted.org/packages/ce/e9/2cb0a017eb7024f70e0d2e9bdb8c5a5b078c5740c7f8816065d06f04c557/black-25.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:bacabb307dca5ebaf9c118d2d2f6903da0d62c9faa82bd21a33eecc319559355", size = 1419419, upload-time = "2025-01-29T04:18:30.191Z" },

     

       69
       69
       +
           { url = "https://files.pythonhosted.org/packages/09/71/54e999902aed72baf26bca0d50781b01838251a462612966e9fc4891eadd/black-25.1.0-py3-none-any.whl", hash = "sha256:95e8176dae143ba9097f351d174fdaf0ccd29efb414b362ae3fd72bf0f710717", size = 207646, upload-time = "2025-01-29T04:15:38.082Z" },

     

       70
       70
       +
       ]

     

       71
       71
       +
       

     

       72
       72
       +
       [[package]]

     

       73
       73
       +
       name = "bleach"

     

       74
       74
       +
       version = "6.2.0"

     

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

     

       76
       76
       +
       dependencies = [

     

       77
       77
       +
           { name = "webencodings" },

     

       78
       78
       +
       ]

     

       79
       79
       +
       sdist = { url = "https://files.pythonhosted.org/packages/76/9a/0e33f5054c54d349ea62c277191c020c2d6ef1d65ab2cb1993f91ec846d1/bleach-6.2.0.tar.gz", hash = "sha256:123e894118b8a599fd80d3ec1a6d4cc7ce4e5882b1317a7e1ba69b56e95f991f", size = 203083, upload-time = "2024-10-29T18:30:40.477Z" }

     

       80
       80
       +
       wheels = [

     

       81
       81
       +
           { url = "https://files.pythonhosted.org/packages/fc/55/96142937f66150805c25c4d0f31ee4132fd33497753400734f9dfdcbdc66/bleach-6.2.0-py3-none-any.whl", hash = "sha256:117d9c6097a7c3d22fd578fcd8d35ff1e125df6736f554da4e432fdd63f31e5e", size = 163406, upload-time = "2024-10-29T18:30:38.186Z" },

     

       82
       82
       +
       ]

     

       83
       83
       +
       

     

       84
       84
       +
       [[package]]

     

       85
       85
       +
       name = "certifi"

     

       86
       86
       +
       version = "2025.7.14"

     

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

     

       88
       88
       +
       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" }

     

       89
       89
       +
       wheels = [

     

       90
       90
       +
           { 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" },

     

       91
       91
       +
       ]

     

       92
       92
       +
       

     

       93
       93
       +
       [[package]]

     

       94
       94
       +
       name = "click"

     

       95
       95
       +
       version = "8.1.8"

     

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

     

       97
       97
       +
       resolution-markers = [

     

       98
       98
       +
           "python_full_version < '3.10'",

     

       99
       99
       +
       ]

     

       100
       100
       +
       dependencies = [

     

       101
       101
       +
           { name = "colorama", marker = "python_full_version < '3.10' and sys_platform == 'win32'" },

     

       102
       102
       +
       ]

     

       103
       103
       +
       sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", hash = "sha256:ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a", size = 226593, upload-time = "2024-12-21T18:38:44.339Z" }

     

       104
       104
       +
       wheels = [

     

       105
       105
       +
           { url = "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl", hash = "sha256:63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2", size = 98188, upload-time = "2024-12-21T18:38:41.666Z" },

     

       106
       106
       +
       ]

     

       107
       107
       +
       

     

       108
       108
       +
       [[package]]

     

       109
       109
       +
       name = "click"

     

       110
       110
       +
       version = "8.2.1"

     

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

     

       112
       112
       +
       resolution-markers = [

     

       113
       113
       +
           "python_full_version >= '3.10'",

     

       114
       114
       +
       ]

     

       115
       115
       +
       dependencies = [

     

       116
       116
       +
           { name = "colorama", marker = "python_full_version >= '3.10' and sys_platform == 'win32'" },

     

       117
       117
       +
       ]

     

       118
       118
       +
       sdist = { url = "https://files.pythonhosted.org/packages/60/6c/8ca2efa64cf75a977a0d7fac081354553ebe483345c734fb6b6515d96bbc/click-8.2.1.tar.gz", hash = "sha256:27c491cc05d968d271d5a1db13e3b5a184636d9d930f148c50b038f0d0646202", size = 286342, upload-time = "2025-05-20T23:19:49.832Z" }

     

       119
       119
       +
       wheels = [

     

       120
       120
       +
           { url = "https://files.pythonhosted.org/packages/85/32/10bb5764d90a8eee674e9dc6f4db6a0ab47c8c4d0d83c27f7c39ac415a4d/click-8.2.1-py3-none-any.whl", hash = "sha256:61a3265b914e850b85317d0b3109c7f8cd35a670f963866005d6ef1d5175a12b", size = 102215, upload-time = "2025-05-20T23:19:47.796Z" },

     

       121
       121
       +
       ]

     

       122
       122
       +
       

     

       123
       123
       +
       [[package]]

     

       124
       124
       +
       name = "colorama"

     

       125
       125
       +
       version = "0.4.6"

     

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

     

       127
       127
       +
       sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }

     

       128
       128
       +
       wheels = [

     

       129
       129
       +
           { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },

     

       130
       130
       +
       ]

     

       131
       131
       +
       

     

       132
       132
       +
       [[package]]

     

       133
       133
       +
       name = "coverage"

     

       134
       134
       +
       version = "7.9.2"

     

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

     

       136
       136
       +
       sdist = { url = "https://files.pythonhosted.org/packages/04/b7/c0465ca253df10a9e8dae0692a4ae6e9726d245390aaef92360e1d6d3832/coverage-7.9.2.tar.gz", hash = "sha256:997024fa51e3290264ffd7492ec97d0690293ccd2b45a6cd7d82d945a4a80c8b", size = 813556, upload-time = "2025-07-03T10:54:15.101Z" }

     

       137
       137
       +
       wheels = [

     

       138
       138
       +
           { url = "https://files.pythonhosted.org/packages/a1/0d/5c2114fd776c207bd55068ae8dc1bef63ecd1b767b3389984a8e58f2b926/coverage-7.9.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:66283a192a14a3854b2e7f3418d7db05cdf411012ab7ff5db98ff3b181e1f912", size = 212039, upload-time = "2025-07-03T10:52:38.955Z" },

     

       139
       139
       +
           { url = "https://files.pythonhosted.org/packages/cf/ad/dc51f40492dc2d5fcd31bb44577bc0cc8920757d6bc5d3e4293146524ef9/coverage-7.9.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4e01d138540ef34fcf35c1aa24d06c3de2a4cffa349e29a10056544f35cca15f", size = 212428, upload-time = "2025-07-03T10:52:41.36Z" },

     

       140
       140
       +
           { url = "https://files.pythonhosted.org/packages/a2/a3/55cb3ff1b36f00df04439c3993d8529193cdf165a2467bf1402539070f16/coverage-7.9.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f22627c1fe2745ee98d3ab87679ca73a97e75ca75eb5faee48660d060875465f", size = 241534, upload-time = "2025-07-03T10:52:42.956Z" },

     

       141
       141
       +
           { url = "https://files.pythonhosted.org/packages/eb/c9/a8410b91b6be4f6e9c2e9f0dce93749b6b40b751d7065b4410bf89cb654b/coverage-7.9.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4b1c2d8363247b46bd51f393f86c94096e64a1cf6906803fa8d5a9d03784bdbf", size = 239408, upload-time = "2025-07-03T10:52:44.199Z" },

     

       142
       142
       +
           { url = "https://files.pythonhosted.org/packages/ff/c4/6f3e56d467c612b9070ae71d5d3b114c0b899b5788e1ca3c93068ccb7018/coverage-7.9.2-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c10c882b114faf82dbd33e876d0cbd5e1d1ebc0d2a74ceef642c6152f3f4d547", size = 240552, upload-time = "2025-07-03T10:52:45.477Z" },

     

       143
       143
       +
           { url = "https://files.pythonhosted.org/packages/fd/20/04eda789d15af1ce79bce5cc5fd64057c3a0ac08fd0576377a3096c24663/coverage-7.9.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:de3c0378bdf7066c3988d66cd5232d161e933b87103b014ab1b0b4676098fa45", size = 240464, upload-time = "2025-07-03T10:52:46.809Z" },

     

       144
       144
       +
           { url = "https://files.pythonhosted.org/packages/a9/5a/217b32c94cc1a0b90f253514815332d08ec0812194a1ce9cca97dda1cd20/coverage-7.9.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:1e2f097eae0e5991e7623958a24ced3282676c93c013dde41399ff63e230fcf2", size = 239134, upload-time = "2025-07-03T10:52:48.149Z" },

     

       145
       145
       +
           { url = "https://files.pythonhosted.org/packages/34/73/1d019c48f413465eb5d3b6898b6279e87141c80049f7dbf73fd020138549/coverage-7.9.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:28dc1f67e83a14e7079b6cea4d314bc8b24d1aed42d3582ff89c0295f09b181e", size = 239405, upload-time = "2025-07-03T10:52:49.687Z" },

     

       146
       146
       +
           { url = "https://files.pythonhosted.org/packages/49/6c/a2beca7aa2595dad0c0d3f350382c381c92400efe5261e2631f734a0e3fe/coverage-7.9.2-cp310-cp310-win32.whl", hash = "sha256:bf7d773da6af9e10dbddacbf4e5cab13d06d0ed93561d44dae0188a42c65be7e", size = 214519, upload-time = "2025-07-03T10:52:51.036Z" },

     

       147
       147
       +
           { url = "https://files.pythonhosted.org/packages/fc/c8/91e5e4a21f9a51e2c7cdd86e587ae01a4fcff06fc3fa8cde4d6f7cf68df4/coverage-7.9.2-cp310-cp310-win_amd64.whl", hash = "sha256:0c0378ba787681ab1897f7c89b415bd56b0b2d9a47e5a3d8dc0ea55aac118d6c", size = 215400, upload-time = "2025-07-03T10:52:52.313Z" },

     

       148
       148
       +
           { url = "https://files.pythonhosted.org/packages/39/40/916786453bcfafa4c788abee4ccd6f592b5b5eca0cd61a32a4e5a7ef6e02/coverage-7.9.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a7a56a2964a9687b6aba5b5ced6971af308ef6f79a91043c05dd4ee3ebc3e9ba", size = 212152, upload-time = "2025-07-03T10:52:53.562Z" },

     

       149
       149
       +
           { url = "https://files.pythonhosted.org/packages/9f/66/cc13bae303284b546a030762957322bbbff1ee6b6cb8dc70a40f8a78512f/coverage-7.9.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:123d589f32c11d9be7fe2e66d823a236fe759b0096f5db3fb1b75b2fa414a4fa", size = 212540, upload-time = "2025-07-03T10:52:55.196Z" },

     

       150
       150
       +
           { url = "https://files.pythonhosted.org/packages/0f/3c/d56a764b2e5a3d43257c36af4a62c379df44636817bb5f89265de4bf8bd7/coverage-7.9.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:333b2e0ca576a7dbd66e85ab402e35c03b0b22f525eed82681c4b866e2e2653a", size = 245097, upload-time = "2025-07-03T10:52:56.509Z" },

     

       151
       151
       +
           { url = "https://files.pythonhosted.org/packages/b1/46/bd064ea8b3c94eb4ca5d90e34d15b806cba091ffb2b8e89a0d7066c45791/coverage-7.9.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:326802760da234baf9f2f85a39e4a4b5861b94f6c8d95251f699e4f73b1835dc", size = 242812, upload-time = "2025-07-03T10:52:57.842Z" },

     

       152
       152
       +
           { url = "https://files.pythonhosted.org/packages/43/02/d91992c2b29bc7afb729463bc918ebe5f361be7f1daae93375a5759d1e28/coverage-7.9.2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:19e7be4cfec248df38ce40968c95d3952fbffd57b400d4b9bb580f28179556d2", size = 244617, upload-time = "2025-07-03T10:52:59.239Z" },

     

       153
       153
       +
           { url = "https://files.pythonhosted.org/packages/b7/4f/8fadff6bf56595a16d2d6e33415841b0163ac660873ed9a4e9046194f779/coverage-7.9.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0b4a4cb73b9f2b891c1788711408ef9707666501ba23684387277ededab1097c", size = 244263, upload-time = "2025-07-03T10:53:00.601Z" },

     

       154
       154
       +
           { url = "https://files.pythonhosted.org/packages/9b/d2/e0be7446a2bba11739edb9f9ba4eff30b30d8257370e237418eb44a14d11/coverage-7.9.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:2c8937fa16c8c9fbbd9f118588756e7bcdc7e16a470766a9aef912dd3f117dbd", size = 242314, upload-time = "2025-07-03T10:53:01.932Z" },

     

       155
       155
       +
           { url = "https://files.pythonhosted.org/packages/9d/7d/dcbac9345000121b8b57a3094c2dfcf1ccc52d8a14a40c1d4bc89f936f80/coverage-7.9.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:42da2280c4d30c57a9b578bafd1d4494fa6c056d4c419d9689e66d775539be74", size = 242904, upload-time = "2025-07-03T10:53:03.478Z" },

     

       156
       156
       +
           { url = "https://files.pythonhosted.org/packages/41/58/11e8db0a0c0510cf31bbbdc8caf5d74a358b696302a45948d7c768dfd1cf/coverage-7.9.2-cp311-cp311-win32.whl", hash = "sha256:14fa8d3da147f5fdf9d298cacc18791818f3f1a9f542c8958b80c228320e90c6", size = 214553, upload-time = "2025-07-03T10:53:05.174Z" },

     

       157
       157
       +
           { url = "https://files.pythonhosted.org/packages/3a/7d/751794ec8907a15e257136e48dc1021b1f671220ecccfd6c4eaf30802714/coverage-7.9.2-cp311-cp311-win_amd64.whl", hash = "sha256:549cab4892fc82004f9739963163fd3aac7a7b0df430669b75b86d293d2df2a7", size = 215441, upload-time = "2025-07-03T10:53:06.472Z" },

     

       158
       158
       +
           { url = "https://files.pythonhosted.org/packages/62/5b/34abcedf7b946c1c9e15b44f326cb5b0da852885312b30e916f674913428/coverage-7.9.2-cp311-cp311-win_arm64.whl", hash = "sha256:c2667a2b913e307f06aa4e5677f01a9746cd08e4b35e14ebcde6420a9ebb4c62", size = 213873, upload-time = "2025-07-03T10:53:07.699Z" },

     

       159
       159
       +
           { url = "https://files.pythonhosted.org/packages/53/d7/7deefc6fd4f0f1d4c58051f4004e366afc9e7ab60217ac393f247a1de70a/coverage-7.9.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ae9eb07f1cfacd9cfe8eaee6f4ff4b8a289a668c39c165cd0c8548484920ffc0", size = 212344, upload-time = "2025-07-03T10:53:09.3Z" },

     

       160
       160
       +
           { url = "https://files.pythonhosted.org/packages/95/0c/ee03c95d32be4d519e6a02e601267769ce2e9a91fc8faa1b540e3626c680/coverage-7.9.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9ce85551f9a1119f02adc46d3014b5ee3f765deac166acf20dbb851ceb79b6f3", size = 212580, upload-time = "2025-07-03T10:53:11.52Z" },

     

       161
       161
       +
           { url = "https://files.pythonhosted.org/packages/8b/9f/826fa4b544b27620086211b87a52ca67592622e1f3af9e0a62c87aea153a/coverage-7.9.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f8f6389ac977c5fb322e0e38885fbbf901743f79d47f50db706e7644dcdcb6e1", size = 246383, upload-time = "2025-07-03T10:53:13.134Z" },

     

       162
       162
       +
           { url = "https://files.pythonhosted.org/packages/7f/b3/4477aafe2a546427b58b9c540665feff874f4db651f4d3cb21b308b3a6d2/coverage-7.9.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ff0d9eae8cdfcd58fe7893b88993723583a6ce4dfbfd9f29e001922544f95615", size = 243400, upload-time = "2025-07-03T10:53:14.614Z" },

     

       163
       163
       +
           { url = "https://files.pythonhosted.org/packages/f8/c2/efffa43778490c226d9d434827702f2dfbc8041d79101a795f11cbb2cf1e/coverage-7.9.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fae939811e14e53ed8a9818dad51d434a41ee09df9305663735f2e2d2d7d959b", size = 245591, upload-time = "2025-07-03T10:53:15.872Z" },

     

       164
       164
       +
           { url = "https://files.pythonhosted.org/packages/c6/e7/a59888e882c9a5f0192d8627a30ae57910d5d449c80229b55e7643c078c4/coverage-7.9.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:31991156251ec202c798501e0a42bbdf2169dcb0f137b1f5c0f4267f3fc68ef9", size = 245402, upload-time = "2025-07-03T10:53:17.124Z" },

     

       165
       165
       +
           { url = "https://files.pythonhosted.org/packages/92/a5/72fcd653ae3d214927edc100ce67440ed8a0a1e3576b8d5e6d066ed239db/coverage-7.9.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:d0d67963f9cbfc7c7f96d4ac74ed60ecbebd2ea6eeb51887af0f8dce205e545f", size = 243583, upload-time = "2025-07-03T10:53:18.781Z" },

     

       166
       166
       +
           { url = "https://files.pythonhosted.org/packages/5c/f5/84e70e4df28f4a131d580d7d510aa1ffd95037293da66fd20d446090a13b/coverage-7.9.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:49b752a2858b10580969ec6af6f090a9a440a64a301ac1528d7ca5f7ed497f4d", size = 244815, upload-time = "2025-07-03T10:53:20.168Z" },

     

       167
       167
       +
           { url = "https://files.pythonhosted.org/packages/39/e7/d73d7cbdbd09fdcf4642655ae843ad403d9cbda55d725721965f3580a314/coverage-7.9.2-cp312-cp312-win32.whl", hash = "sha256:88d7598b8ee130f32f8a43198ee02edd16d7f77692fa056cb779616bbea1b355", size = 214719, upload-time = "2025-07-03T10:53:21.521Z" },

     

       168
       168
       +
           { url = "https://files.pythonhosted.org/packages/9f/d6/7486dcc3474e2e6ad26a2af2db7e7c162ccd889c4c68fa14ea8ec189c9e9/coverage-7.9.2-cp312-cp312-win_amd64.whl", hash = "sha256:9dfb070f830739ee49d7c83e4941cc767e503e4394fdecb3b54bfdac1d7662c0", size = 215509, upload-time = "2025-07-03T10:53:22.853Z" },

     

       169
       169
       +
           { url = "https://files.pythonhosted.org/packages/b7/34/0439f1ae2593b0346164d907cdf96a529b40b7721a45fdcf8b03c95fcd90/coverage-7.9.2-cp312-cp312-win_arm64.whl", hash = "sha256:4e2c058aef613e79df00e86b6d42a641c877211384ce5bd07585ed7ba71ab31b", size = 213910, upload-time = "2025-07-03T10:53:24.472Z" },

     

       170
       170
       +
           { url = "https://files.pythonhosted.org/packages/94/9d/7a8edf7acbcaa5e5c489a646226bed9591ee1c5e6a84733c0140e9ce1ae1/coverage-7.9.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:985abe7f242e0d7bba228ab01070fde1d6c8fa12f142e43debe9ed1dde686038", size = 212367, upload-time = "2025-07-03T10:53:25.811Z" },

     

       171
       171
       +
           { url = "https://files.pythonhosted.org/packages/e8/9e/5cd6f130150712301f7e40fb5865c1bc27b97689ec57297e568d972eec3c/coverage-7.9.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:82c3939264a76d44fde7f213924021ed31f55ef28111a19649fec90c0f109e6d", size = 212632, upload-time = "2025-07-03T10:53:27.075Z" },

     

       172
       172
       +
           { url = "https://files.pythonhosted.org/packages/a8/de/6287a2c2036f9fd991c61cefa8c64e57390e30c894ad3aa52fac4c1e14a8/coverage-7.9.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ae5d563e970dbe04382f736ec214ef48103d1b875967c89d83c6e3f21706d5b3", size = 245793, upload-time = "2025-07-03T10:53:28.408Z" },

     

       173
       173
       +
           { url = "https://files.pythonhosted.org/packages/06/cc/9b5a9961d8160e3cb0b558c71f8051fe08aa2dd4b502ee937225da564ed1/coverage-7.9.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bdd612e59baed2a93c8843c9a7cb902260f181370f1d772f4842987535071d14", size = 243006, upload-time = "2025-07-03T10:53:29.754Z" },

     

       174
       174
       +
           { url = "https://files.pythonhosted.org/packages/49/d9/4616b787d9f597d6443f5588619c1c9f659e1f5fc9eebf63699eb6d34b78/coverage-7.9.2-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:256ea87cb2a1ed992bcdfc349d8042dcea1b80436f4ddf6e246d6bee4b5d73b6", size = 244990, upload-time = "2025-07-03T10:53:31.098Z" },

     

       175
       175
       +
           { url = "https://files.pythonhosted.org/packages/48/83/801cdc10f137b2d02b005a761661649ffa60eb173dcdaeb77f571e4dc192/coverage-7.9.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f44ae036b63c8ea432f610534a2668b0c3aee810e7037ab9d8ff6883de480f5b", size = 245157, upload-time = "2025-07-03T10:53:32.717Z" },

     

       176
       176
       +
           { url = "https://files.pythonhosted.org/packages/c8/a4/41911ed7e9d3ceb0ffb019e7635468df7499f5cc3edca5f7dfc078e9c5ec/coverage-7.9.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:82d76ad87c932935417a19b10cfe7abb15fd3f923cfe47dbdaa74ef4e503752d", size = 243128, upload-time = "2025-07-03T10:53:34.009Z" },

     

       177
       177
       +
           { url = "https://files.pythonhosted.org/packages/10/41/344543b71d31ac9cb00a664d5d0c9ef134a0fe87cb7d8430003b20fa0b7d/coverage-7.9.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:619317bb86de4193debc712b9e59d5cffd91dc1d178627ab2a77b9870deb2868", size = 244511, upload-time = "2025-07-03T10:53:35.434Z" },

     

       178
       178
       +
           { url = "https://files.pythonhosted.org/packages/d5/81/3b68c77e4812105e2a060f6946ba9e6f898ddcdc0d2bfc8b4b152a9ae522/coverage-7.9.2-cp313-cp313-win32.whl", hash = "sha256:0a07757de9feb1dfafd16ab651e0f628fd7ce551604d1bf23e47e1ddca93f08a", size = 214765, upload-time = "2025-07-03T10:53:36.787Z" },

     

       179
       179
       +
           { url = "https://files.pythonhosted.org/packages/06/a2/7fac400f6a346bb1a4004eb2a76fbff0e242cd48926a2ce37a22a6a1d917/coverage-7.9.2-cp313-cp313-win_amd64.whl", hash = "sha256:115db3d1f4d3f35f5bb021e270edd85011934ff97c8797216b62f461dd69374b", size = 215536, upload-time = "2025-07-03T10:53:38.188Z" },

     

       180
       180
       +
           { url = "https://files.pythonhosted.org/packages/08/47/2c6c215452b4f90d87017e61ea0fd9e0486bb734cb515e3de56e2c32075f/coverage-7.9.2-cp313-cp313-win_arm64.whl", hash = "sha256:48f82f889c80af8b2a7bb6e158d95a3fbec6a3453a1004d04e4f3b5945a02694", size = 213943, upload-time = "2025-07-03T10:53:39.492Z" },

     

       181
       181
       +
           { url = "https://files.pythonhosted.org/packages/a3/46/e211e942b22d6af5e0f323faa8a9bc7c447a1cf1923b64c47523f36ed488/coverage-7.9.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:55a28954545f9d2f96870b40f6c3386a59ba8ed50caf2d949676dac3ecab99f5", size = 213088, upload-time = "2025-07-03T10:53:40.874Z" },

     

       182
       182
       +
           { url = "https://files.pythonhosted.org/packages/d2/2f/762551f97e124442eccd907bf8b0de54348635b8866a73567eb4e6417acf/coverage-7.9.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cdef6504637731a63c133bb2e6f0f0214e2748495ec15fe42d1e219d1b133f0b", size = 213298, upload-time = "2025-07-03T10:53:42.218Z" },

     

       183
       183
       +
           { url = "https://files.pythonhosted.org/packages/7a/b7/76d2d132b7baf7360ed69be0bcab968f151fa31abe6d067f0384439d9edb/coverage-7.9.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bcd5ebe66c7a97273d5d2ddd4ad0ed2e706b39630ed4b53e713d360626c3dbb3", size = 256541, upload-time = "2025-07-03T10:53:43.823Z" },

     

       184
       184
       +
           { url = "https://files.pythonhosted.org/packages/a0/17/392b219837d7ad47d8e5974ce5f8dc3deb9f99a53b3bd4d123602f960c81/coverage-7.9.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9303aed20872d7a3c9cb39c5d2b9bdbe44e3a9a1aecb52920f7e7495410dfab8", size = 252761, upload-time = "2025-07-03T10:53:45.19Z" },

     

       185
       185
       +
           { url = "https://files.pythonhosted.org/packages/d5/77/4256d3577fe1b0daa8d3836a1ebe68eaa07dd2cbaf20cf5ab1115d6949d4/coverage-7.9.2-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc18ea9e417a04d1920a9a76fe9ebd2f43ca505b81994598482f938d5c315f46", size = 254917, upload-time = "2025-07-03T10:53:46.931Z" },

     

       186
       186
       +
           { url = "https://files.pythonhosted.org/packages/53/99/fc1a008eef1805e1ddb123cf17af864743354479ea5129a8f838c433cc2c/coverage-7.9.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6406cff19880aaaadc932152242523e892faff224da29e241ce2fca329866584", size = 256147, upload-time = "2025-07-03T10:53:48.289Z" },

     

       187
       187
       +
           { url = "https://files.pythonhosted.org/packages/92/c0/f63bf667e18b7f88c2bdb3160870e277c4874ced87e21426128d70aa741f/coverage-7.9.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:2d0d4f6ecdf37fcc19c88fec3e2277d5dee740fb51ffdd69b9579b8c31e4232e", size = 254261, upload-time = "2025-07-03T10:53:49.99Z" },

     

       188
       188
       +
           { url = "https://files.pythonhosted.org/packages/8c/32/37dd1c42ce3016ff8ec9e4b607650d2e34845c0585d3518b2a93b4830c1a/coverage-7.9.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c33624f50cf8de418ab2b4d6ca9eda96dc45b2c4231336bac91454520e8d1fac", size = 255099, upload-time = "2025-07-03T10:53:51.354Z" },

     

       189
       189
       +
           { url = "https://files.pythonhosted.org/packages/da/2e/af6b86f7c95441ce82f035b3affe1cd147f727bbd92f563be35e2d585683/coverage-7.9.2-cp313-cp313t-win32.whl", hash = "sha256:1df6b76e737c6a92210eebcb2390af59a141f9e9430210595251fbaf02d46926", size = 215440, upload-time = "2025-07-03T10:53:52.808Z" },

     

       190
       190
       +
           { url = "https://files.pythonhosted.org/packages/4d/bb/8a785d91b308867f6b2e36e41c569b367c00b70c17f54b13ac29bcd2d8c8/coverage-7.9.2-cp313-cp313t-win_amd64.whl", hash = "sha256:f5fd54310b92741ebe00d9c0d1d7b2b27463952c022da6d47c175d246a98d1bd", size = 216537, upload-time = "2025-07-03T10:53:54.273Z" },

     

       191
       191
       +
           { url = "https://files.pythonhosted.org/packages/1d/a0/a6bffb5e0f41a47279fd45a8f3155bf193f77990ae1c30f9c224b61cacb0/coverage-7.9.2-cp313-cp313t-win_arm64.whl", hash = "sha256:c48c2375287108c887ee87d13b4070a381c6537d30e8487b24ec721bf2a781cb", size = 214398, upload-time = "2025-07-03T10:53:56.715Z" },

     

       192
       192
       +
           { url = "https://files.pythonhosted.org/packages/62/ab/b4b06662ccaa00ca7bbee967b7035a33a58b41efb92d8c89a6c523a2ccd5/coverage-7.9.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:ddc39510ac922a5c4c27849b739f875d3e1d9e590d1e7b64c98dadf037a16cce", size = 212037, upload-time = "2025-07-03T10:53:58.055Z" },

     

       193
       193
       +
           { url = "https://files.pythonhosted.org/packages/bb/5e/04619995657acc898d15bfad42b510344b3a74d4d5bc34f2e279d46c781c/coverage-7.9.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a535c0c7364acd55229749c2b3e5eebf141865de3a8f697076a3291985f02d30", size = 212412, upload-time = "2025-07-03T10:53:59.451Z" },

     

       194
       194
       +
           { url = "https://files.pythonhosted.org/packages/14/e7/1465710224dc6d31c534e7714cbd907210622a044adc81c810e72eea873f/coverage-7.9.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:df0f9ef28e0f20c767ccdccfc5ae5f83a6f4a2fbdfbcbcc8487a8a78771168c8", size = 241164, upload-time = "2025-07-03T10:54:00.852Z" },

     

       195
       195
       +
           { url = "https://files.pythonhosted.org/packages/ab/f2/44c6fbd2794afeb9ab6c0a14d3c088ab1dae3dff3df2624609981237bbb4/coverage-7.9.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2f3da12e0ccbcb348969221d29441ac714bbddc4d74e13923d3d5a7a0bebef7a", size = 239032, upload-time = "2025-07-03T10:54:02.25Z" },

     

       196
       196
       +
           { url = "https://files.pythonhosted.org/packages/6a/d2/7a79845429c0aa2e6788bc45c26a2e3052fa91082c9ea1dea56fb531952c/coverage-7.9.2-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0a17eaf46f56ae0f870f14a3cbc2e4632fe3771eab7f687eda1ee59b73d09fe4", size = 240148, upload-time = "2025-07-03T10:54:03.618Z" },

     

       197
       197
       +
           { url = "https://files.pythonhosted.org/packages/9c/7d/2731d1b4c9c672d82d30d218224dfc62939cf3800bc8aba0258fefb191f5/coverage-7.9.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:669135a9d25df55d1ed56a11bf555f37c922cf08d80799d4f65d77d7d6123fcf", size = 239875, upload-time = "2025-07-03T10:54:05.022Z" },

     

       198
       198
       +
           { url = "https://files.pythonhosted.org/packages/1b/83/685958715429a9da09cf172c15750ca5c795dd7259466f2645403696557b/coverage-7.9.2-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:9d3a700304d01a627df9db4322dc082a0ce1e8fc74ac238e2af39ced4c083193", size = 238127, upload-time = "2025-07-03T10:54:06.366Z" },

     

       199
       199
       +
           { url = "https://files.pythonhosted.org/packages/34/ff/161a4313308b3783126790adfae1970adbe4886fda8788792e435249910a/coverage-7.9.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:71ae8b53855644a0b1579d4041304ddc9995c7b21c8a1f16753c4d8903b4dfed", size = 239064, upload-time = "2025-07-03T10:54:07.878Z" },

     

       200
       200
       +
           { url = "https://files.pythonhosted.org/packages/17/14/fe33f41b2e80811021de059621f44c01ebe4d6b08bdb82d54a514488e933/coverage-7.9.2-cp39-cp39-win32.whl", hash = "sha256:dd7a57b33b5cf27acb491e890720af45db05589a80c1ffc798462a765be6d4d7", size = 214522, upload-time = "2025-07-03T10:54:09.331Z" },

     

       201
       201
       +
           { url = "https://files.pythonhosted.org/packages/6e/30/63d850ec31b5c6f6a7b4e853016375b846258300320eda29376e2786ceeb/coverage-7.9.2-cp39-cp39-win_amd64.whl", hash = "sha256:f65bb452e579d5540c8b37ec105dd54d8b9307b07bcaa186818c104ffda22441", size = 215419, upload-time = "2025-07-03T10:54:10.681Z" },

     

       202
       202
       +
           { url = "https://files.pythonhosted.org/packages/d7/85/f8bbefac27d286386961c25515431482a425967e23d3698b75a250872924/coverage-7.9.2-pp39.pp310.pp311-none-any.whl", hash = "sha256:8a1166db2fb62473285bcb092f586e081e92656c7dfa8e9f62b4d39d7e6b5050", size = 204013, upload-time = "2025-07-03T10:54:12.084Z" },

     

       203
       203
       +
           { url = "https://files.pythonhosted.org/packages/3c/38/bbe2e63902847cf79036ecc75550d0698af31c91c7575352eb25190d0fb3/coverage-7.9.2-py3-none-any.whl", hash = "sha256:e425cd5b00f6fc0ed7cdbd766c70be8baab4b7839e4d4fe5fac48581dd968ea4", size = 204005, upload-time = "2025-07-03T10:54:13.491Z" },

     

       204
       204
       +
       ]

     

       205
       205
       +
       

     

       206
       206
       +
       [package.optional-dependencies]

     

       207
       207
       +
       toml = [

     

       208
       208
       +
           { name = "tomli", marker = "python_full_version <= '3.11'" },

     

       209
       209
       +
       ]

     

       210
       210
       +
       

     

       211
       211
       +
       [[package]]

     

       212
       212
       +
       name = "dnspython"

     

       213
       213
       +
       version = "2.7.0"

     

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

     

       215
       215
       +
       sdist = { url = "https://files.pythonhosted.org/packages/b5/4a/263763cb2ba3816dd94b08ad3a33d5fdae34ecb856678773cc40a3605829/dnspython-2.7.0.tar.gz", hash = "sha256:ce9c432eda0dc91cf618a5cedf1a4e142651196bbcd2c80e89ed5a907e5cfaf1", size = 345197, upload-time = "2024-10-05T20:14:59.362Z" }

     

       216
       216
       +
       wheels = [

     

       217
       217
       +
           { url = "https://files.pythonhosted.org/packages/68/1b/e0a87d256e40e8c888847551b20a017a6b98139178505dc7ffb96f04e954/dnspython-2.7.0-py3-none-any.whl", hash = "sha256:b4c34b7d10b51bcc3a5071e7b8dee77939f1e878477eeecc965e9835f63c6c86", size = 313632, upload-time = "2024-10-05T20:14:57.687Z" },

     

       218
       218
       +
       ]

     

       219
       219
       +
       

     

       220
       220
       +
       [[package]]

     

       221
       221
       +
       name = "email-validator"

     

       222
       222
       +
       version = "2.2.0"

     

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

     

       224
       224
       +
       dependencies = [

     

       225
       225
       +
           { name = "dnspython" },

     

       226
       226
       +
           { name = "idna" },

     

       227
       227
       +
       ]

     

       228
       228
       +
       sdist = { url = "https://files.pythonhosted.org/packages/48/ce/13508a1ec3f8bb981ae4ca79ea40384becc868bfae97fd1c942bb3a001b1/email_validator-2.2.0.tar.gz", hash = "sha256:cb690f344c617a714f22e66ae771445a1ceb46821152df8e165c5f9a364582b7", size = 48967, upload-time = "2024-06-20T11:30:30.034Z" }

     

       229
       229
       +
       wheels = [

     

       230
       230
       +
           { url = "https://files.pythonhosted.org/packages/d7/ee/bf0adb559ad3c786f12bcbc9296b3f5675f529199bef03e2df281fa1fadb/email_validator-2.2.0-py3-none-any.whl", hash = "sha256:561977c2d73ce3611850a06fa56b414621e0c8faa9d66f2611407d87465da631", size = 33521, upload-time = "2024-06-20T11:30:28.248Z" },

     

       231
       231
       +
       ]

     

       232
       232
       +
       

     

       233
       233
       +
       [[package]]

     

       234
       234
       +
       name = "exceptiongroup"

     

       235
       235
       +
       version = "1.3.0"

     

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

     

       237
       237
       +
       dependencies = [

     

       238
       238
       +
           { name = "typing-extensions", marker = "python_full_version < '3.13'" },

     

       239
       239
       +
       ]

     

       240
       240
       +
       sdist = { url = "https://files.pythonhosted.org/packages/0b/9f/a65090624ecf468cdca03533906e7c69ed7588582240cfe7cc9e770b50eb/exceptiongroup-1.3.0.tar.gz", hash = "sha256:b241f5885f560bc56a59ee63ca4c6a8bfa46ae4ad651af316d4e81817bb9fd88", size = 29749, upload-time = "2025-05-10T17:42:51.123Z" }

     

       241
       241
       +
       wheels = [

     

       242
       242
       +
           { url = "https://files.pythonhosted.org/packages/36/f4/c6e662dade71f56cd2f3735141b265c3c79293c109549c1e6933b0651ffc/exceptiongroup-1.3.0-py3-none-any.whl", hash = "sha256:4d111e6e0c13d0644cad6ddaa7ed0261a0b36971f6d23e7ec9b4b9097da78a10", size = 16674, upload-time = "2025-05-10T17:42:49.33Z" },

     

       243
       243
       +
       ]

     

       244
       244
       +
       

     

       245
       245
       +
       [[package]]

     

       246
       246
       +
       name = "feedparser"

     

       247
       247
       +
       version = "6.0.11"

     

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

     

       249
       249
       +
       dependencies = [

     

       250
       250
       +
           { name = "sgmllib3k" },

     

       251
       251
       +
       ]

     

       252
       252
       +
       sdist = { url = "https://files.pythonhosted.org/packages/ff/aa/7af346ebeb42a76bf108027fe7f3328bb4e57a3a96e53e21fd9ef9dd6dd0/feedparser-6.0.11.tar.gz", hash = "sha256:c9d0407b64c6f2a065d0ebb292c2b35c01050cc0dc33757461aaabdc4c4184d5", size = 286197, upload-time = "2023-12-10T16:03:20.854Z" }

     

       253
       253
       +
       wheels = [

     

       254
       254
       +
           { url = "https://files.pythonhosted.org/packages/7c/d4/8c31aad9cc18f451c49f7f9cfb5799dadffc88177f7917bc90a66459b1d7/feedparser-6.0.11-py3-none-any.whl", hash = "sha256:0be7ee7b395572b19ebeb1d6aafb0028dee11169f1c934e0ed67d54992f4ad45", size = 81343, upload-time = "2023-12-10T16:03:19.484Z" },

     

       255
       255
       +
       ]

     

       256
       256
       +
       

     

       257
       257
       +
       [[package]]

     

       258
       258
       +
       name = "gitdb"

     

       259
       259
       +
       version = "4.0.12"

     

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

     

       261
       261
       +
       dependencies = [

     

       262
       262
       +
           { name = "smmap" },

     

       263
       263
       +
       ]

     

       264
       264
       +
       sdist = { url = "https://files.pythonhosted.org/packages/72/94/63b0fc47eb32792c7ba1fe1b694daec9a63620db1e313033d18140c2320a/gitdb-4.0.12.tar.gz", hash = "sha256:5ef71f855d191a3326fcfbc0d5da835f26b13fbcba60c32c21091c349ffdb571", size = 394684, upload-time = "2025-01-02T07:20:46.413Z" }

     

       265
       265
       +
       wheels = [

     

       266
       266
       +
           { url = "https://files.pythonhosted.org/packages/a0/61/5c78b91c3143ed5c14207f463aecfc8f9dbb5092fb2869baf37c273b2705/gitdb-4.0.12-py3-none-any.whl", hash = "sha256:67073e15955400952c6565cc3e707c554a4eea2e428946f7a4c162fab9bd9bcf", size = 62794, upload-time = "2025-01-02T07:20:43.624Z" },

     

       267
       267
       +
       ]

     

       268
       268
       +
       

     

       269
       269
       +
       [[package]]

     

       270
       270
       +
       name = "gitpython"

     

       271
       271
       +
       version = "3.1.44"

     

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

     

       273
       273
       +
       dependencies = [

     

       274
       274
       +
           { name = "gitdb" },

     

       275
       275
       +
       ]

     

       276
       276
       +
       sdist = { url = "https://files.pythonhosted.org/packages/c0/89/37df0b71473153574a5cdef8f242de422a0f5d26d7a9e231e6f169b4ad14/gitpython-3.1.44.tar.gz", hash = "sha256:c87e30b26253bf5418b01b0660f818967f3c503193838337fe5e573331249269", size = 214196, upload-time = "2025-01-02T07:32:43.59Z" }

     

       277
       277
       +
       wheels = [

     

       278
       278
       +
           { url = "https://files.pythonhosted.org/packages/1d/9a/4114a9057db2f1462d5c8f8390ab7383925fe1ac012eaa42402ad65c2963/GitPython-3.1.44-py3-none-any.whl", hash = "sha256:9e0e10cda9bed1ee64bc9a6de50e7e38a9c9943241cd7f585f6df3ed28011110", size = 207599, upload-time = "2025-01-02T07:32:40.731Z" },

     

       279
       279
       +
       ]

     

       280
       280
       +
       

     

       281
       281
       +
       [[package]]

     

       282
       282
       +
       name = "h11"

     

       283
       283
       +
       version = "0.16.0"

     

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

     

       285
       285
       +
       sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }

     

       286
       286
       +
       wheels = [

     

       287
       287
       +
           { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },

     

       288
       288
       +
       ]

     

       289
       289
       +
       

     

       290
       290
       +
       [[package]]

     

       291
       291
       +
       name = "httpcore"

     

       292
       292
       +
       version = "1.0.9"

     

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

     

       294
       294
       +
       dependencies = [

     

       295
       295
       +
           { name = "certifi" },

     

       296
       296
       +
           { name = "h11" },

     

       297
       297
       +
       ]

     

       298
       298
       +
       sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }

     

       299
       299
       +
       wheels = [

     

       300
       300
       +
           { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },

     

       301
       301
       +
       ]

     

       302
       302
       +
       

     

       303
       303
       +
       [[package]]

     

       304
       304
       +
       name = "httpx"

     

       305
       305
       +
       version = "0.28.1"

     

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

     

       307
       307
       +
       dependencies = [

     

       308
       308
       +
           { name = "anyio" },

     

       309
       309
       +
           { name = "certifi" },

     

       310
       310
       +
           { name = "httpcore" },

     

       311
       311
       +
           { name = "idna" },

     

       312
       312
       +
       ]

     

       313
       313
       +
       sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }

     

       314
       314
       +
       wheels = [

     

       315
       315
       +
           { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },

     

       316
       316
       +
       ]

     

       317
       317
       +
       

     

       318
       318
       +
       [[package]]

     

       319
       319
       +
       name = "idna"

     

       320
       320
       +
       version = "3.10"

     

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

     

       322
       322
       +
       sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490, upload-time = "2024-09-15T18:07:39.745Z" }

     

       323
       323
       +
       wheels = [

     

       324
       324
       +
           { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442, upload-time = "2024-09-15T18:07:37.964Z" },

     

       325
       325
       +
       ]

     

       326
       326
       +
       

     

       327
       327
       +
       [[package]]

     

       328
       328
       +
       name = "iniconfig"

     

       329
       329
       +
       version = "2.1.0"

     

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

     

       331
       331
       +
       sdist = { url = "https://files.pythonhosted.org/packages/f2/97/ebf4da567aa6827c909642694d71c9fcf53e5b504f2d96afea02718862f3/iniconfig-2.1.0.tar.gz", hash = "sha256:3abbd2e30b36733fee78f9c7f7308f2d0050e88f0087fd25c2645f63c773e1c7", size = 4793, upload-time = "2025-03-19T20:09:59.721Z" }

     

       332
       332
       +
       wheels = [

     

       333
       333
       +
           { url = "https://files.pythonhosted.org/packages/2c/e1/e6716421ea10d38022b952c159d5161ca1193197fb744506875fbb87ea7b/iniconfig-2.1.0-py3-none-any.whl", hash = "sha256:9deba5723312380e77435581c6bf4935c94cbfab9b1ed33ef8d238ea168eb760", size = 6050, upload-time = "2025-03-19T20:10:01.071Z" },

     

       334
       334
       +
       ]

     

       335
       335
       +
       

     

       336
       336
       +
       [[package]]

     

       337
       337
       +
       name = "jinja2"

     

       338
       338
       +
       version = "3.1.6"

     

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

     

       340
       340
       +
       dependencies = [

     

       341
       341
       +
           { name = "markupsafe" },

     

       342
       342
       +
       ]

     

       343
       343
       +
       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" }

     

       344
       344
       +
       wheels = [

     

       345
       345
       +
           { 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" },

     

       346
       346
       +
       ]

     

       347
       347
       +
       

     

       348
       348
       +
       [[package]]

     

       349
       349
       +
       name = "markdown-it-py"

     

       350
       350
       +
       version = "3.0.0"

     

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

     

       352
       352
       +
       dependencies = [

     

       353
       353
       +
           { name = "mdurl" },

     

       354
       354
       +
       ]

     

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

     

       356
       356
       +
       wheels = [

     

       357
       357
       +
           { 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" },

     

       358
       358
       +
       ]

     

       359
       359
       +
       

     

       360
       360
       +
       [[package]]

     

       361
       361
       +
       name = "markupsafe"

     

       362
       362
       +
       version = "3.0.2"

     

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

     

       364
       364
       +
       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" }

     

       365
       365
       +
       wheels = [

     

       366
       366
       +
           { 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" },

     

       367
       367
       +
           { 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" },

     

       368
       368
       +
           { 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" },

     

       369
       369
       +
           { 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" },

     

       370
       370
       +
           { 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" },

     

       371
       371
       +
           { 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" },

     

       372
       372
       +
           { 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" },

     

       373
       373
       +
           { 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" },

     

       374
       374
       +
           { 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" },

     

       375
       375
       +
           { 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" },

     

       376
       376
       +
           { 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" },

     

       377
       377
       +
           { 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" },

     

       378
       378
       +
           { 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" },

     

       379
       379
       +
           { 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" },

     

       380
       380
       +
           { 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" },

     

       381
       381
       +
           { 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" },

     

       382
       382
       +
           { 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" },

     

       383
       383
       +
           { 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" },

     

       384
       384
       +
           { 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" },

     

       385
       385
       +
           { 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" },

     

       386
       386
       +
           { 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" },

     

       387
       387
       +
           { 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" },

     

       388
       388
       +
           { 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" },

     

       389
       389
       +
           { 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" },

     

       390
       390
       +
           { 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" },

     

       391
       391
       +
           { 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" },

     

       392
       392
       +
           { 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" },

     

       393
       393
       +
           { 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" },

     

       394
       394
       +
           { 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" },

     

       395
       395
       +
           { 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" },

     

       396
       396
       +
           { 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" },

     

       397
       397
       +
           { 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" },

     

       398
       398
       +
           { 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" },

     

       399
       399
       +
           { 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" },

     

       400
       400
       +
           { 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" },

     

       401
       401
       +
           { 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" },

     

       402
       402
       +
           { 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" },

     

       403
       403
       +
           { 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" },

     

       404
       404
       +
           { 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" },

     

       405
       405
       +
           { 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" },

     

       406
       406
       +
           { 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" },

     

       407
       407
       +
           { 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" },

     

       408
       408
       +
           { 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" },

     

       409
       409
       +
           { 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" },

     

       410
       410
       +
           { 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" },

     

       411
       411
       +
           { 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" },

     

       412
       412
       +
           { 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" },

     

       413
       413
       +
           { 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" },

     

       414
       414
       +
           { 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" },

     

       415
       415
       +
           { 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" },

     

       416
       416
       +
           { 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" },

     

       417
       417
       +
           { 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" },

     

       418
       418
       +
           { 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" },

     

       419
       419
       +
           { 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" },

     

       420
       420
       +
           { 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" },

     

       421
       421
       +
           { 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" },

     

       422
       422
       +
           { 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" },

     

       423
       423
       +
           { 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" },

     

       424
       424
       +
           { 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" },

     

       425
       425
       +
           { 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" },

     

       426
       426
       +
       ]

     

       427
       427
       +
       

     

       428
       428
       +
       [[package]]

     

       429
       429
       +
       name = "mdurl"

     

       430
       430
       +
       version = "0.1.2"

     

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

     

       432
       432
       +
       sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" }

     

       433
       433
       +
       wheels = [

     

       434
       434
       +
           { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },

     

       435
       435
       +
       ]

     

       436
       436
       +
       

     

       437
       437
       +
       [[package]]

     

       438
       438
       +
       name = "mypy"

     

       439
       439
       +
       version = "1.17.0"

     

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

     

       441
       441
       +
       dependencies = [

     

       442
       442
       +
           { name = "mypy-extensions" },

     

       443
       443
       +
           { name = "pathspec" },

     

       444
       444
       +
           { name = "tomli", marker = "python_full_version < '3.11'" },

     

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

     

       446
       446
       +
       ]

     

       447
       447
       +
       sdist = { url = "https://files.pythonhosted.org/packages/1e/e3/034322d5a779685218ed69286c32faa505247f1f096251ef66c8fd203b08/mypy-1.17.0.tar.gz", hash = "sha256:e5d7ccc08ba089c06e2f5629c660388ef1fee708444f1dee0b9203fa031dee03", size = 3352114, upload-time = "2025-07-14T20:34:30.181Z" }

     

       448
       448
       +
       wheels = [

     

       449
       449
       +
           { url = "https://files.pythonhosted.org/packages/6a/31/e762baa3b73905c856d45ab77b4af850e8159dffffd86a52879539a08c6b/mypy-1.17.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:f8e08de6138043108b3b18f09d3f817a4783912e48828ab397ecf183135d84d6", size = 10998313, upload-time = "2025-07-14T20:33:24.519Z" },

     

       450
       450
       +
           { url = "https://files.pythonhosted.org/packages/1c/c1/25b2f0d46fb7e0b5e2bee61ec3a47fe13eff9e3c2f2234f144858bbe6485/mypy-1.17.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ce4a17920ec144647d448fc43725b5873548b1aae6c603225626747ededf582d", size = 10128922, upload-time = "2025-07-14T20:34:06.414Z" },

     

       451
       451
       +
           { url = "https://files.pythonhosted.org/packages/02/78/6d646603a57aa8a2886df1b8881fe777ea60f28098790c1089230cd9c61d/mypy-1.17.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6ff25d151cc057fdddb1cb1881ef36e9c41fa2a5e78d8dd71bee6e4dcd2bc05b", size = 11913524, upload-time = "2025-07-14T20:33:19.109Z" },

     

       452
       452
       +
           { url = "https://files.pythonhosted.org/packages/4f/19/dae6c55e87ee426fb76980f7e78484450cad1c01c55a1dc4e91c930bea01/mypy-1.17.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:93468cf29aa9a132bceb103bd8475f78cacde2b1b9a94fd978d50d4bdf616c9a", size = 12650527, upload-time = "2025-07-14T20:32:44.095Z" },

     

       453
       453
       +
           { url = "https://files.pythonhosted.org/packages/86/e1/f916845a235235a6c1e4d4d065a3930113767001d491b8b2e1b61ca56647/mypy-1.17.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:98189382b310f16343151f65dd7e6867386d3e35f7878c45cfa11383d175d91f", size = 12897284, upload-time = "2025-07-14T20:33:38.168Z" },

     

       454
       454
       +
           { url = "https://files.pythonhosted.org/packages/ae/dc/414760708a4ea1b096bd214d26a24e30ac5e917ef293bc33cdb6fe22d2da/mypy-1.17.0-cp310-cp310-win_amd64.whl", hash = "sha256:c004135a300ab06a045c1c0d8e3f10215e71d7b4f5bb9a42ab80236364429937", size = 9506493, upload-time = "2025-07-14T20:34:01.093Z" },

     

       455
       455
       +
           { url = "https://files.pythonhosted.org/packages/d4/24/82efb502b0b0f661c49aa21cfe3e1999ddf64bf5500fc03b5a1536a39d39/mypy-1.17.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9d4fe5c72fd262d9c2c91c1117d16aac555e05f5beb2bae6a755274c6eec42be", size = 10914150, upload-time = "2025-07-14T20:31:51.985Z" },

     

       456
       456
       +
           { url = "https://files.pythonhosted.org/packages/03/96/8ef9a6ff8cedadff4400e2254689ca1dc4b420b92c55255b44573de10c54/mypy-1.17.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d96b196e5c16f41b4f7736840e8455958e832871990c7ba26bf58175e357ed61", size = 10039845, upload-time = "2025-07-14T20:32:30.527Z" },

     

       457
       457
       +
           { url = "https://files.pythonhosted.org/packages/df/32/7ce359a56be779d38021d07941cfbb099b41411d72d827230a36203dbb81/mypy-1.17.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:73a0ff2dd10337ceb521c080d4147755ee302dcde6e1a913babd59473904615f", size = 11837246, upload-time = "2025-07-14T20:32:01.28Z" },

     

       458
       458
       +
           { url = "https://files.pythonhosted.org/packages/82/16/b775047054de4d8dbd668df9137707e54b07fe18c7923839cd1e524bf756/mypy-1.17.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:24cfcc1179c4447854e9e406d3af0f77736d631ec87d31c6281ecd5025df625d", size = 12571106, upload-time = "2025-07-14T20:34:26.942Z" },

     

       459
       459
       +
           { url = "https://files.pythonhosted.org/packages/a1/cf/fa33eaf29a606102c8d9ffa45a386a04c2203d9ad18bf4eef3e20c43ebc8/mypy-1.17.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3c56f180ff6430e6373db7a1d569317675b0a451caf5fef6ce4ab365f5f2f6c3", size = 12759960, upload-time = "2025-07-14T20:33:42.882Z" },

     

       460
       460
       +
           { url = "https://files.pythonhosted.org/packages/94/75/3f5a29209f27e739ca57e6350bc6b783a38c7621bdf9cac3ab8a08665801/mypy-1.17.0-cp311-cp311-win_amd64.whl", hash = "sha256:eafaf8b9252734400f9b77df98b4eee3d2eecab16104680d51341c75702cad70", size = 9503888, upload-time = "2025-07-14T20:32:34.392Z" },

     

       461
       461
       +
           { url = "https://files.pythonhosted.org/packages/12/e9/e6824ed620bbf51d3bf4d6cbbe4953e83eaf31a448d1b3cfb3620ccb641c/mypy-1.17.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f986f1cab8dbec39ba6e0eaa42d4d3ac6686516a5d3dccd64be095db05ebc6bb", size = 11086395, upload-time = "2025-07-14T20:34:11.452Z" },

     

       462
       462
       +
           { url = "https://files.pythonhosted.org/packages/ba/51/a4afd1ae279707953be175d303f04a5a7bd7e28dc62463ad29c1c857927e/mypy-1.17.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:51e455a54d199dd6e931cd7ea987d061c2afbaf0960f7f66deef47c90d1b304d", size = 10120052, upload-time = "2025-07-14T20:33:09.897Z" },

     

       463
       463
       +
           { url = "https://files.pythonhosted.org/packages/8a/71/19adfeac926ba8205f1d1466d0d360d07b46486bf64360c54cb5a2bd86a8/mypy-1.17.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3204d773bab5ff4ebbd1f8efa11b498027cd57017c003ae970f310e5b96be8d8", size = 11861806, upload-time = "2025-07-14T20:32:16.028Z" },

     

       464
       464
       +
           { url = "https://files.pythonhosted.org/packages/0b/64/d6120eca3835baf7179e6797a0b61d6c47e0bc2324b1f6819d8428d5b9ba/mypy-1.17.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1051df7ec0886fa246a530ae917c473491e9a0ba6938cfd0ec2abc1076495c3e", size = 12744371, upload-time = "2025-07-14T20:33:33.503Z" },

     

       465
       465
       +
           { url = "https://files.pythonhosted.org/packages/1f/dc/56f53b5255a166f5bd0f137eed960e5065f2744509dfe69474ff0ba772a5/mypy-1.17.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f773c6d14dcc108a5b141b4456b0871df638eb411a89cd1c0c001fc4a9d08fc8", size = 12914558, upload-time = "2025-07-14T20:33:56.961Z" },

     

       466
       466
       +
           { url = "https://files.pythonhosted.org/packages/69/ac/070bad311171badc9add2910e7f89271695a25c136de24bbafc7eded56d5/mypy-1.17.0-cp312-cp312-win_amd64.whl", hash = "sha256:1619a485fd0e9c959b943c7b519ed26b712de3002d7de43154a489a2d0fd817d", size = 9585447, upload-time = "2025-07-14T20:32:20.594Z" },

     

       467
       467
       +
           { url = "https://files.pythonhosted.org/packages/be/7b/5f8ab461369b9e62157072156935cec9d272196556bdc7c2ff5f4c7c0f9b/mypy-1.17.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:2c41aa59211e49d717d92b3bb1238c06d387c9325d3122085113c79118bebb06", size = 11070019, upload-time = "2025-07-14T20:32:07.99Z" },

     

       468
       468
       +
           { url = "https://files.pythonhosted.org/packages/9c/f8/c49c9e5a2ac0badcc54beb24e774d2499748302c9568f7f09e8730e953fa/mypy-1.17.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0e69db1fb65b3114f98c753e3930a00514f5b68794ba80590eb02090d54a5d4a", size = 10114457, upload-time = "2025-07-14T20:33:47.285Z" },

     

       469
       469
       +
           { url = "https://files.pythonhosted.org/packages/89/0c/fb3f9c939ad9beed3e328008b3fb90b20fda2cddc0f7e4c20dbefefc3b33/mypy-1.17.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:03ba330b76710f83d6ac500053f7727270b6b8553b0423348ffb3af6f2f7b889", size = 11857838, upload-time = "2025-07-14T20:33:14.462Z" },

     

       470
       470
       +
           { url = "https://files.pythonhosted.org/packages/4c/66/85607ab5137d65e4f54d9797b77d5a038ef34f714929cf8ad30b03f628df/mypy-1.17.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:037bc0f0b124ce46bfde955c647f3e395c6174476a968c0f22c95a8d2f589bba", size = 12731358, upload-time = "2025-07-14T20:32:25.579Z" },

     

       471
       471
       +
           { url = "https://files.pythonhosted.org/packages/73/d0/341dbbfb35ce53d01f8f2969facbb66486cee9804048bf6c01b048127501/mypy-1.17.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:c38876106cb6132259683632b287238858bd58de267d80defb6f418e9ee50658", size = 12917480, upload-time = "2025-07-14T20:34:21.868Z" },

     

       472
       472
       +
           { url = "https://files.pythonhosted.org/packages/64/63/70c8b7dbfc520089ac48d01367a97e8acd734f65bd07813081f508a8c94c/mypy-1.17.0-cp313-cp313-win_amd64.whl", hash = "sha256:d30ba01c0f151998f367506fab31c2ac4527e6a7b2690107c7a7f9e3cb419a9c", size = 9589666, upload-time = "2025-07-14T20:34:16.841Z" },

     

       473
       473
       +
           { url = "https://files.pythonhosted.org/packages/9f/a0/6263dd11941231f688f0a8f2faf90ceac1dc243d148d314a089d2fe25108/mypy-1.17.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:63e751f1b5ab51d6f3d219fe3a2fe4523eaa387d854ad06906c63883fde5b1ab", size = 10988185, upload-time = "2025-07-14T20:33:04.797Z" },

     

       474
       474
       +
           { url = "https://files.pythonhosted.org/packages/02/13/b8f16d6b0dc80277129559c8e7dbc9011241a0da8f60d031edb0e6e9ac8f/mypy-1.17.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f7fb09d05e0f1c329a36dcd30e27564a3555717cde87301fae4fb542402ddfad", size = 10120169, upload-time = "2025-07-14T20:32:38.84Z" },

     

       475
       475
       +
           { url = "https://files.pythonhosted.org/packages/14/ef/978ba79df0d65af680e20d43121363cf643eb79b04bf3880d01fc8afeb6f/mypy-1.17.0-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b72c34ce05ac3a1361ae2ebb50757fb6e3624032d91488d93544e9f82db0ed6c", size = 11918121, upload-time = "2025-07-14T20:33:52.328Z" },

     

       476
       476
       +
           { url = "https://files.pythonhosted.org/packages/f4/10/55ef70b104151a0d8280474f05268ff0a2a79be8d788d5e647257d121309/mypy-1.17.0-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:434ad499ad8dde8b2f6391ddfa982f41cb07ccda8e3c67781b1bfd4e5f9450a8", size = 12648821, upload-time = "2025-07-14T20:32:59.631Z" },

     

       477
       477
       +
           { url = "https://files.pythonhosted.org/packages/26/8c/7781fcd2e1eef48fbedd3a422c21fe300a8e03ed5be2eb4bd10246a77f4e/mypy-1.17.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:f105f61a5eff52e137fd73bee32958b2add9d9f0a856f17314018646af838e97", size = 12896955, upload-time = "2025-07-14T20:32:49.543Z" },

     

       478
       478
       +
           { url = "https://files.pythonhosted.org/packages/78/13/03ac759dabe86e98ca7b6681f114f90ee03f3ff8365a57049d311bd4a4e3/mypy-1.17.0-cp39-cp39-win_amd64.whl", hash = "sha256:ba06254a5a22729853209550d80f94e28690d5530c661f9416a68ac097b13fc4", size = 9512957, upload-time = "2025-07-14T20:33:28.619Z" },

     

       479
       479
       +
           { url = "https://files.pythonhosted.org/packages/e3/fc/ee058cc4316f219078464555873e99d170bde1d9569abd833300dbeb484a/mypy-1.17.0-py3-none-any.whl", hash = "sha256:15d9d0018237ab058e5de3d8fce61b6fa72cc59cc78fd91f1b474bce12abf496", size = 2283195, upload-time = "2025-07-14T20:31:54.753Z" },

     

       480
       480
       +
       ]

     

       481
       481
       +
       

     

       482
       482
       +
       [[package]]

     

       483
       483
       +
       name = "mypy-extensions"

     

       484
       484
       +
       version = "1.1.0"

     

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

     

       486
       486
       +
       sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343, upload-time = "2025-04-22T14:54:24.164Z" }

     

       487
       487
       +
       wheels = [

     

       488
       488
       +
           { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" },

     

       489
       489
       +
       ]

     

       490
       490
       +
       

     

       491
       491
       +
       [[package]]

     

       492
       492
       +
       name = "packaging"

     

       493
       493
       +
       version = "25.0"

     

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

     

       495
       495
       +
       sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" }

     

       496
       496
       +
       wheels = [

     

       497
       497
       +
           { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" },

     

       498
       498
       +
       ]

     

       499
       499
       +
       

     

       500
       500
       +
       [[package]]

     

       501
       501
       +
       name = "pathspec"

     

       502
       502
       +
       version = "0.12.1"

     

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

     

       504
       504
       +
       sdist = { url = "https://files.pythonhosted.org/packages/ca/bc/f35b8446f4531a7cb215605d100cd88b7ac6f44ab3fc94870c120ab3adbf/pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712", size = 51043, upload-time = "2023-12-10T22:30:45Z" }

     

       505
       505
       +
       wheels = [

     

       506
       506
       +
           { url = "https://files.pythonhosted.org/packages/cc/20/ff623b09d963f88bfde16306a54e12ee5ea43e9b597108672ff3a408aad6/pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08", size = 31191, upload-time = "2023-12-10T22:30:43.14Z" },

     

       507
       507
       +
       ]

     

       508
       508
       +
       

     

       509
       509
       +
       [[package]]

     

       510
       510
       +
       name = "pendulum"

     

       511
       511
       +
       version = "3.1.0"

     

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

     

       513
       513
       +
       dependencies = [

     

       514
       514
       +
           { name = "python-dateutil" },

     

       515
       515
       +
           { name = "tzdata" },

     

       516
       516
       +
       ]

     

       517
       517
       +
       sdist = { url = "https://files.pythonhosted.org/packages/23/7c/009c12b86c7cc6c403aec80f8a4308598dfc5995e5c523a5491faaa3952e/pendulum-3.1.0.tar.gz", hash = "sha256:66f96303560f41d097bee7d2dc98ffca716fbb3a832c4b3062034c2d45865015", size = 85930, upload-time = "2025-04-19T14:30:01.675Z" }

     

       518
       518
       +
       wheels = [

     

       519
       519
       +
           { url = "https://files.pythonhosted.org/packages/b4/d8/398cd27903a6899d0ae47b896d88e0b15849fc334931a6732e7ce3be9a45/pendulum-3.1.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:aa545a59e6517cf43597455a6fb44daa4a6e08473d67a7ad34e4fa951efb9620", size = 338637, upload-time = "2025-04-19T14:00:56.429Z" },

     

       520
       520
       +
           { url = "https://files.pythonhosted.org/packages/aa/9d/a125554919c6db14e189393254c7781ee98ed5a121b6c05652d353b03c12/pendulum-3.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:299df2da6c490ede86bb8d58c65e33d7a2a42479d21475a54b467b03ccb88531", size = 326003, upload-time = "2025-04-19T14:00:58.192Z" },

     

       521
       521
       +
           { url = "https://files.pythonhosted.org/packages/53/9f/43a5a902f904e06252c259c2f6cf2dceafbb25aef158df08f79c0089dfd7/pendulum-3.1.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dbaa66e3ab179a2746eec67462f852a5d555bd709c25030aef38477468dd008e", size = 344335, upload-time = "2025-04-19T14:00:59.985Z" },

     

       522
       522
       +
           { url = "https://files.pythonhosted.org/packages/ca/24/00fcd6abd1f7623d2bbcca048b45f01aa8bb6b647e0477c3a8ea6094335c/pendulum-3.1.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c3907ab3744c32e339c358d88ec80cd35fa2d4b25c77a3c67e6b39e99b7090c5", size = 382169, upload-time = "2025-04-19T14:01:01.411Z" },

     

       523
       523
       +
           { url = "https://files.pythonhosted.org/packages/32/bc/20a87f24c26c6c4daf3c69311208b28130b4d19c006da16efc0e55715963/pendulum-3.1.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8244958c5bc4ed1c47ee84b098ddd95287a3fc59e569ca6e2b664c6396138ec4", size = 436675, upload-time = "2025-04-19T14:01:03.068Z" },

     

       524
       524
       +
           { url = "https://files.pythonhosted.org/packages/1d/eb/3b1818a796408a250b8e6cfaa5372b991c0cbec768e02e0f9a226755383d/pendulum-3.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ca5722b3993b85ff7dfced48d86b318f863c359877b6badf1a3601e35199ef8f", size = 353728, upload-time = "2025-04-19T14:01:04.483Z" },

     

       525
       525
       +
           { url = "https://files.pythonhosted.org/packages/36/23/755ef61f863b2777925171a59509540205b561a9e07ee7de0b5be9226bea/pendulum-3.1.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:5b77a3dc010eea1a4916ef3771163d808bfc3e02b894c37df311287f18e5b764", size = 524465, upload-time = "2025-04-19T14:01:05.865Z" },

     

       526
       526
       +
           { url = "https://files.pythonhosted.org/packages/07/1f/a3e5f08890d13d93eee725778bfeaa233db5c55463e526857dffbc1a47e4/pendulum-3.1.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:2d6e1eff4a15fdb8fb3867c5469e691c2465eef002a6a541c47b48a390ff4cf4", size = 525690, upload-time = "2025-04-19T14:01:07.707Z" },

     

       527
       527
       +
           { url = "https://files.pythonhosted.org/packages/43/c5/bf8ce472b81e8f5f074e8ba39899d288acce417c2c4a9ec7486d56970e28/pendulum-3.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:73de43ec85b46ac75db848c8e2f3f5d086e90b11cd9c7f029e14c8d748d920e2", size = 260356, upload-time = "2025-04-19T14:01:09.339Z" },

     

       528
       528
       +
           { url = "https://files.pythonhosted.org/packages/5e/6e/d28d3c22e6708b819a94c05bd05a3dfaed5c685379e8b6dc4b34b473b942/pendulum-3.1.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:61a03d14f8c64d13b2f7d5859e4b4053c4a7d3b02339f6c71f3e4606bfd67423", size = 338596, upload-time = "2025-04-19T14:01:11.306Z" },

     

       529
       529
       +
           { url = "https://files.pythonhosted.org/packages/e1/e6/43324d58021d463c2eeb6146b169d2c935f2f840f9e45ac2d500453d954c/pendulum-3.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e674ed2d158afa5c361e60f1f67872dc55b492a10cacdaa7fcd7b7da5f158f24", size = 325854, upload-time = "2025-04-19T14:01:13.156Z" },

     

       530
       530
       +
           { url = "https://files.pythonhosted.org/packages/b0/a7/d2ae79b960bfdea94dab67e2f118697b08bc9e98eb6bd8d32c4d99240da3/pendulum-3.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7c75377eb16e58bbe7e03ea89eeea49be6fc5de0934a4aef0e263f8b4fa71bc2", size = 344334, upload-time = "2025-04-19T14:01:15.151Z" },

     

       531
       531
       +
           { url = "https://files.pythonhosted.org/packages/96/94/941f071212e23c29aae7def891fb636930c648386e059ce09ea0dcd43933/pendulum-3.1.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:656b8b0ce070f0f2e5e2668247d3c783c55336534aa1f13bd0969535878955e1", size = 382259, upload-time = "2025-04-19T14:01:16.924Z" },

     

       532
       532
       +
           { url = "https://files.pythonhosted.org/packages/51/ad/a78a701656aec00d16fee636704445c23ca11617a0bfe7c3848d1caa5157/pendulum-3.1.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:48962903e6c1afe1f13548cb6252666056086c107d59e3d64795c58c9298bc2e", size = 436361, upload-time = "2025-04-19T14:01:18.796Z" },

     

       533
       533
       +
           { url = "https://files.pythonhosted.org/packages/da/93/83f59ccbf4435c29dca8c63a6560fcbe4783079a468a5f91d9f886fd21f0/pendulum-3.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d364ec3f8e65010fefd4b0aaf7be5eb97e5df761b107a06f5e743b7c3f52c311", size = 353653, upload-time = "2025-04-19T14:01:20.159Z" },

     

       534
       534
       +
           { url = "https://files.pythonhosted.org/packages/6f/0f/42d6644ec6339b41066f594e52d286162aecd2e9735aaf994d7e00c9e09d/pendulum-3.1.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:dd52caffc2afb86612ec43bbeb226f204ea12ebff9f3d12f900a7d3097210fcc", size = 524567, upload-time = "2025-04-19T14:01:21.457Z" },

     

       535
       535
       +
           { url = "https://files.pythonhosted.org/packages/de/45/d84d909202755ab9d3379e5481fdf70f53344ebefbd68d6f5803ddde98a6/pendulum-3.1.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:d439fccaa35c91f686bd59d30604dab01e8b5c1d0dd66e81648c432fd3f8a539", size = 525571, upload-time = "2025-04-19T14:01:23.329Z" },

     

       536
       536
       +
           { url = "https://files.pythonhosted.org/packages/0d/e0/4de160773ce3c2f7843c310db19dd919a0cd02cc1c0384866f63b18a6251/pendulum-3.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:43288773a86d9c5c0ddb645f88f615ff6bd12fd1410b34323662beccb18f3b49", size = 260259, upload-time = "2025-04-19T14:01:24.689Z" },

     

       537
       537
       +
           { url = "https://files.pythonhosted.org/packages/c1/7f/ffa278f78112c6c6e5130a702042f52aab5c649ae2edf814df07810bbba5/pendulum-3.1.0-cp311-cp311-win_arm64.whl", hash = "sha256:569ea5072ae0f11d625e03b36d865f8037b76e838a3b621f6967314193896a11", size = 253899, upload-time = "2025-04-19T14:01:26.442Z" },

     

       538
       538
       +
           { url = "https://files.pythonhosted.org/packages/7a/d7/b1bfe15a742f2c2713acb1fdc7dc3594ff46ef9418ac6a96fcb12a6ba60b/pendulum-3.1.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:4dfd53e7583ccae138be86d6c0a0b324c7547df2afcec1876943c4d481cf9608", size = 336209, upload-time = "2025-04-19T14:01:27.815Z" },

     

       539
       539
       +
           { url = "https://files.pythonhosted.org/packages/eb/87/0392da0c603c828b926d9f7097fbdddaafc01388cb8a00888635d04758c3/pendulum-3.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6a6e06a28f3a7d696546347805536f6f38be458cb79de4f80754430696bea9e6", size = 323130, upload-time = "2025-04-19T14:01:29.336Z" },

     

       540
       540
       +
           { url = "https://files.pythonhosted.org/packages/c0/61/95f1eec25796be6dddf71440ee16ec1fd0c573fc61a73bd1ef6daacd529a/pendulum-3.1.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7e68d6a51880708084afd8958af42dc8c5e819a70a6c6ae903b1c4bfc61e0f25", size = 341509, upload-time = "2025-04-19T14:01:31.1Z" },

     

       541
       541
       +
           { url = "https://files.pythonhosted.org/packages/b5/7b/eb0f5e6aa87d5e1b467a1611009dbdc92f0f72425ebf07669bfadd8885a6/pendulum-3.1.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9e3f1e5da39a7ea7119efda1dd96b529748c1566f8a983412d0908455d606942", size = 378674, upload-time = "2025-04-19T14:01:32.974Z" },

     

       542
       542
       +
           { url = "https://files.pythonhosted.org/packages/29/68/5a4c1b5de3e54e16cab21d2ec88f9cd3f18599e96cc90a441c0b0ab6b03f/pendulum-3.1.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e9af1e5eeddb4ebbe1b1c9afb9fd8077d73416ade42dd61264b3f3b87742e0bb", size = 436133, upload-time = "2025-04-19T14:01:34.349Z" },

     

       543
       543
       +
           { url = "https://files.pythonhosted.org/packages/87/5d/f7a1d693e5c0f789185117d5c1d5bee104f5b0d9fbf061d715fb61c840a8/pendulum-3.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:20f74aa8029a42e327bfc150472e0e4d2358fa5d795f70460160ba81b94b6945", size = 351232, upload-time = "2025-04-19T14:01:35.669Z" },

     

       544
       544
       +
           { url = "https://files.pythonhosted.org/packages/30/77/c97617eb31f1d0554edb073201a294019b9e0a9bd2f73c68e6d8d048cd6b/pendulum-3.1.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:cf6229e5ee70c2660148523f46c472e677654d0097bec010d6730f08312a4931", size = 521562, upload-time = "2025-04-19T14:01:37.05Z" },

     

       545
       545
       +
           { url = "https://files.pythonhosted.org/packages/76/22/0d0ef3393303877e757b848ecef8a9a8c7627e17e7590af82d14633b2cd1/pendulum-3.1.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:350cabb23bf1aec7c7694b915d3030bff53a2ad4aeabc8c8c0d807c8194113d6", size = 523221, upload-time = "2025-04-19T14:01:38.444Z" },

     

       546
       546
       +
           { url = "https://files.pythonhosted.org/packages/99/f3/aefb579aa3cebd6f2866b205fc7a60d33e9a696e9e629024752107dc3cf5/pendulum-3.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:42959341e843077c41d47420f28c3631de054abd64da83f9b956519b5c7a06a7", size = 260502, upload-time = "2025-04-19T14:01:39.814Z" },

     

       547
       547
       +
           { url = "https://files.pythonhosted.org/packages/02/74/4332b5d6e34c63d4df8e8eab2249e74c05513b1477757463f7fdca99e9be/pendulum-3.1.0-cp312-cp312-win_arm64.whl", hash = "sha256:006758e2125da2e624493324dfd5d7d1b02b0c44bc39358e18bf0f66d0767f5f", size = 253089, upload-time = "2025-04-19T14:01:41.171Z" },

     

       548
       548
       +
           { url = "https://files.pythonhosted.org/packages/8e/1f/af928ba4aa403dac9569f787adcf024005e7654433d71f7a84e608716837/pendulum-3.1.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:28658b0baf4b30eb31d096a375983cfed033e60c0a7bbe94fa23f06cd779b50b", size = 336209, upload-time = "2025-04-19T14:01:42.775Z" },

     

       549
       549
       +
           { url = "https://files.pythonhosted.org/packages/b6/16/b010643007ba964c397da7fa622924423883c1bbff1a53f9d1022cd7f024/pendulum-3.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:b114dcb99ce511cb8f5495c7b6f0056b2c3dba444ef1ea6e48030d7371bd531a", size = 323132, upload-time = "2025-04-19T14:01:44.577Z" },

     

       550
       550
       +
           { url = "https://files.pythonhosted.org/packages/64/19/c3c47aeecb5d9bceb0e89faafd800d39809b696c5b7bba8ec8370ad5052c/pendulum-3.1.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2404a6a54c80252ea393291f0b7f35525a61abae3d795407f34e118a8f133a18", size = 341509, upload-time = "2025-04-19T14:01:46.084Z" },

     

       551
       551
       +
           { url = "https://files.pythonhosted.org/packages/38/cf/c06921ff6b860ff7e62e70b8e5d4dc70e36f5abb66d168bd64d51760bc4e/pendulum-3.1.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d06999790d9ee9962a1627e469f98568bf7ad1085553fa3c30ed08b3944a14d7", size = 378674, upload-time = "2025-04-19T14:01:47.727Z" },

     

       552
       552
       +
           { url = "https://files.pythonhosted.org/packages/62/0b/a43953b9eba11e82612b033ac5133f716f1b76b6108a65da6f408b3cc016/pendulum-3.1.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:94751c52f6b7c306734d1044c2c6067a474237e1e5afa2f665d1fbcbbbcf24b3", size = 436133, upload-time = "2025-04-19T14:01:49.126Z" },

     

       553
       553
       +
           { url = "https://files.pythonhosted.org/packages/eb/a0/ec3d70b3b96e23ae1d039f132af35e17704c22a8250d1887aaefea4d78a6/pendulum-3.1.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5553ac27be05e997ec26d7f004cf72788f4ce11fe60bb80dda604a64055b29d0", size = 351232, upload-time = "2025-04-19T14:01:50.575Z" },

     

       554
       554
       +
           { url = "https://files.pythonhosted.org/packages/f4/97/aba23f1716b82f6951ba2b1c9178a2d107d1e66c102762a9bf19988547ea/pendulum-3.1.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:f8dee234ca6142bf0514368d01a72945a44685aaa2fc4c14c98d09da9437b620", size = 521563, upload-time = "2025-04-19T14:01:51.9Z" },

     

       555
       555
       +
           { url = "https://files.pythonhosted.org/packages/01/33/2c0d5216cc53d16db0c4b3d510f141ee0a540937f8675948541190fbd48b/pendulum-3.1.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:7378084fe54faab4ee481897a00b710876f2e901ded6221671e827a253e643f2", size = 523221, upload-time = "2025-04-19T14:01:53.275Z" },

     

       556
       556
       +
           { url = "https://files.pythonhosted.org/packages/51/89/8de955c339c31aeae77fd86d3225509b998c81875e9dba28cb88b8cbf4b3/pendulum-3.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:8539db7ae2c8da430ac2515079e288948c8ebf7eb1edd3e8281b5cdf433040d6", size = 260501, upload-time = "2025-04-19T14:01:54.749Z" },

     

       557
       557
       +
           { url = "https://files.pythonhosted.org/packages/15/c3/226a3837363e94f8722461848feec18bfdd7d5172564d53aa3c3397ff01e/pendulum-3.1.0-cp313-cp313-win_arm64.whl", hash = "sha256:1ce26a608e1f7387cd393fba2a129507c4900958d4f47b90757ec17656856571", size = 253087, upload-time = "2025-04-19T14:01:55.998Z" },

     

       558
       558
       +
           { url = "https://files.pythonhosted.org/packages/c9/eb/e128af9e1a216c17b932f8c7f1f927f97cd8fd71d6e60148e1c69ad2bcf4/pendulum-3.1.0-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:2504df1a7ff8e0827781a601ff399bfcad23e7b7943f87ef33db02c11131f5e8", size = 339467, upload-time = "2025-04-19T14:01:57.346Z" },

     

       559
       559
       +
           { url = "https://files.pythonhosted.org/packages/2f/c3/a7f515c6dbe89f2d92216ccd9a2e31dd657767d7f64177da1579092a41e3/pendulum-3.1.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:4041a7156695499b6676ed092f27e17760db2341bf350f6c5ea9137dd2cfd3f6", size = 326898, upload-time = "2025-04-19T14:01:58.789Z" },

     

       560
       560
       +
           { url = "https://files.pythonhosted.org/packages/15/da/80774350340e9d06789460b6e8def2d497cffe09334a8911be8d226caec5/pendulum-3.1.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:87b277e9177651d6af8500b95f0af1e3c1769064f2353c06f638d3c1e065063e", size = 344866, upload-time = "2025-04-19T14:02:00.688Z" },

     

       561
       561
       +
           { url = "https://files.pythonhosted.org/packages/55/cf/771d1fee8d14abefbccbed99622c6f26e33b839b8964a18188b4f9159bf1/pendulum-3.1.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:784cf82b676118816fb81ea6bcbdf8f3b0c49aa74fcb895647ef7f8046093471", size = 382902, upload-time = "2025-04-19T14:02:02.077Z" },

     

       562
       562
       +
           { url = "https://files.pythonhosted.org/packages/bd/95/0660ae5dbe9212c99fbccb27ca64361018600aa954fab95641653a39ce36/pendulum-3.1.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9e44277a391fa5ad2e9ce02b1b24fd9489cb2a371ae2459eddb238301d31204d", size = 437782, upload-time = "2025-04-19T14:02:03.984Z" },

     

       563
       563
       +
           { url = "https://files.pythonhosted.org/packages/04/1f/007dff40bb0325ae91eba3d4d6ce911945d808f87d3cebaa4556ca07f35d/pendulum-3.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6a7d0bca8cca92d60734b64fa4fa58b17b8ec1f55112bf77d00ee65248d19177", size = 354462, upload-time = "2025-04-19T14:02:05.831Z" },

     

       564
       564
       +
           { url = "https://files.pythonhosted.org/packages/e6/cc/8d2ed88beab1622623e321bd1f754eee174bb97e6ffcd34ceb9cce87a4ea/pendulum-3.1.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:bfac5e02faee02c180444e722c298690688ec1c3dfa1aab65fb4e0e3825d84ed", size = 525009, upload-time = "2025-04-19T14:02:07.231Z" },

     

       565
       565
       +
           { url = "https://files.pythonhosted.org/packages/44/c0/a503df53796b0dc1dae7d50573d936f86f8f482cf4acd9adbbd2a30ef817/pendulum-3.1.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:e0da70941b062220e734c2c510ad30daa60aca1a37e893f1baa0da065ffa4c72", size = 526351, upload-time = "2025-04-19T14:02:08.619Z" },

     

       566
       566
       +
           { url = "https://files.pythonhosted.org/packages/c6/bc/1fbc57b2e482a0ee3b5a0759c4b3b5127f0401cdce4afef111a3b6179d8d/pendulum-3.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:300a237fb81028edb9604d4d1bb205b80515fd22ab9c1a4c55014d07869122f8", size = 260813, upload-time = "2025-04-19T14:02:10.677Z" },

     

       567
       567
       +
           { url = "https://files.pythonhosted.org/packages/66/10/3258c084653606d2be2c7168998eda4a57cf1559cecb43cf1100000fda5f/pendulum-3.1.0-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:d2cac744940299d8da41a3ed941aa1e02b5abbc9ae2c525f3aa2ae30c28a86b5", size = 339442, upload-time = "2025-04-19T14:02:12.512Z" },

     

       568
       568
       +
           { url = "https://files.pythonhosted.org/packages/98/d5/98a1a10cd1cfb3390fbf070864e9a10de8e70a9d4509832132f4d900d655/pendulum-3.1.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:ffb39c3f3906a9c9a108fa98e5556f18b52d2c6451984bbfe2f14436ec4fc9d4", size = 326609, upload-time = "2025-04-19T14:02:13.838Z" },

     

       569
       569
       +
           { url = "https://files.pythonhosted.org/packages/0a/2e/448abdebc11b9c54e190d273cb084162643199fc184cb1bb6bff7900e67f/pendulum-3.1.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ebe18b1c2eb364064cc4a68a65900f1465cac47d0891dab82341766bcc05b40c", size = 344777, upload-time = "2025-04-19T14:02:15.512Z" },

     

       570
       570
       +
           { url = "https://files.pythonhosted.org/packages/ed/91/ee857bbd51168bf08b89c3a4705c920725eee0f830ccc513b8370f6ce71d/pendulum-3.1.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a9e9b28a35cec9fcd90f224b4878456129a057dbd694fc8266a9393834804995", size = 354404, upload-time = "2025-04-19T14:02:16.91Z" },

     

       571
       571
       +
           { url = "https://files.pythonhosted.org/packages/bc/d4/e63a57df65e2b2d10f3aa917a4069be9abf5ac7d56d11336e0510742d8a6/pendulum-3.1.0-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:a3be19b73a9c6a866724419295482f817727e635ccc82f07ae6f818943a1ee96", size = 524948, upload-time = "2025-04-19T14:02:18.808Z" },

     

       572
       572
       +
           { url = "https://files.pythonhosted.org/packages/93/87/04e74600c5a5674e5f341b8888b530a9de9b84b31889f80fac3bee3e9e87/pendulum-3.1.0-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:24a53b523819bda4c70245687a589b5ea88711f7caac4be5f276d843fe63076b", size = 526340, upload-time = "2025-04-19T14:02:20.242Z" },

     

       573
       573
       +
           { url = "https://files.pythonhosted.org/packages/48/27/d3577a5f6f7d1fbf1138d87ce21ebab363c78642513b991d1c424d658d09/pendulum-3.1.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:bd701789414fbd0be3c75f46803f31e91140c23821e4bcb0fa2bddcdd051c425", size = 261089, upload-time = "2025-04-19T14:02:21.631Z" },

     

       574
       574
       +
           { url = "https://files.pythonhosted.org/packages/53/8f/6620b0df6acdd8c020ec4f5907e3deb8c6d46970568299b66eed9b5f53b4/pendulum-3.1.0-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:0803639fc98e03f74d0b83955a2800bcee1c99b0700638aae9ab7ceb1a7dcca3", size = 340056, upload-time = "2025-04-19T14:02:23.041Z" },

     

       575
       575
       +
           { url = "https://files.pythonhosted.org/packages/dd/90/957491643cff9d97764e443bd0ef7c5c549e733e306159d6ca8ab4034fb5/pendulum-3.1.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:4cceff50503ef9cb021e53a238f867c9843b4dd55859582d682f3c9e52460699", size = 327095, upload-time = "2025-04-19T14:02:24.866Z" },

     

       576
       576
       +
           { url = "https://files.pythonhosted.org/packages/fe/f2/550855e0285671278f763963b2470f437d340759aaef927fedb204e58fb0/pendulum-3.1.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c2cf8adcf3030eef78c3cd82afd9948cd1a4ae1a9450e9ac128b9e744c42825f", size = 345131, upload-time = "2025-04-19T14:02:26.332Z" },

     

       577
       577
       +
           { url = "https://files.pythonhosted.org/packages/b4/8f/938b83fe3e1450f4b04d1f96e8b2c288e07ad6b942260fef24cfd98cc3d0/pendulum-3.1.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e5bce0f71c10e983e1c39e1eb37b9a5f5c2aa0c15a36edaaa0a844fb1fbc7bbb", size = 354886, upload-time = "2025-04-19T14:02:28.205Z" },

     

       578
       578
       +
           { url = "https://files.pythonhosted.org/packages/d9/aa/0e3c231a7e35b362226204d7276a47c0e225aa59b30c7c9cd2a8e2660967/pendulum-3.1.0-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:c1354be2df38f031ac6a985949b6541be7d39dd7e44c8804f4bc9a39dea9f3bb", size = 525344, upload-time = "2025-04-19T14:02:30.116Z" },

     

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

     

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

     

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

     

       582
       582
       +
       ]

     

       583
       583
       +
       

     

       584
       584
       +
       [[package]]

     

       585
       585
       +
       name = "platformdirs"

     

       586
       586
       +
       version = "4.3.8"

     

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

     

       588
       588
       +
       sdist = { url = "https://files.pythonhosted.org/packages/fe/8b/3c73abc9c759ecd3f1f7ceff6685840859e8070c4d947c93fae71f6a0bf2/platformdirs-4.3.8.tar.gz", hash = "sha256:3d512d96e16bcb959a814c9f348431070822a6496326a4be0911c40b5a74c2bc", size = 21362, upload-time = "2025-05-07T22:47:42.121Z" }

     

       589
       589
       +
       wheels = [

     

       590
       590
       +
           { url = "https://files.pythonhosted.org/packages/fe/39/979e8e21520d4e47a0bbe349e2713c0aac6f3d853d0e5b34d76206c439aa/platformdirs-4.3.8-py3-none-any.whl", hash = "sha256:ff7059bb7eb1179e2685604f4aaf157cfd9535242bd23742eadc3c13542139b4", size = 18567, upload-time = "2025-05-07T22:47:40.376Z" },

     

       591
       591
       +
       ]

     

       592
       592
       +
       

     

       593
       593
       +
       [[package]]

     

       594
       594
       +
       name = "pluggy"

     

       595
       595
       +
       version = "1.6.0"

     

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

     

       597
       597
       +
       sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }

     

       598
       598
       +
       wheels = [

     

       599
       599
       +
           { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },

     

       600
       600
       +
       ]

     

       601
       601
       +
       

     

       602
       602
       +
       [[package]]

     

       603
       603
       +
       name = "pydantic"

     

       604
       604
       +
       version = "2.11.7"

     

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

     

       606
       606
       +
       dependencies = [

     

       607
       607
       +
           { name = "annotated-types" },

     

       608
       608
       +
           { name = "pydantic-core" },

     

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

     

       610
       610
       +
           { name = "typing-inspection" },

     

       611
       611
       +
       ]

     

       612
       612
       +
       sdist = { url = "https://files.pythonhosted.org/packages/00/dd/4325abf92c39ba8623b5af936ddb36ffcfe0beae70405d456ab1fb2f5b8c/pydantic-2.11.7.tar.gz", hash = "sha256:d989c3c6cb79469287b1569f7447a17848c998458d49ebe294e975b9baf0f0db", size = 788350, upload-time = "2025-06-14T08:33:17.137Z" }

     

       613
       613
       +
       wheels = [

     

       614
       614
       +
           { url = "https://files.pythonhosted.org/packages/6a/c0/ec2b1c8712ca690e5d61979dee872603e92b8a32f94cc1b72d53beab008a/pydantic-2.11.7-py3-none-any.whl", hash = "sha256:dde5df002701f6de26248661f6835bbe296a47bf73990135c7d07ce741b9623b", size = 444782, upload-time = "2025-06-14T08:33:14.905Z" },

     

       615
       615
       +
       ]

     

       616
       616
       +
       

     

       617
       617
       +
       [[package]]

     

       618
       618
       +
       name = "pydantic-core"

     

       619
       619
       +
       version = "2.33.2"

     

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

     

       621
       621
       +
       dependencies = [

     

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

     

       623
       623
       +
       ]

     

       624
       624
       +
       sdist = { url = "https://files.pythonhosted.org/packages/ad/88/5f2260bdfae97aabf98f1778d43f69574390ad787afb646292a638c923d4/pydantic_core-2.33.2.tar.gz", hash = "sha256:7cb8bc3605c29176e1b105350d2e6474142d7c1bd1d9327c4a9bdb46bf827acc", size = 435195, upload-time = "2025-04-23T18:33:52.104Z" }

     

       625
       625
       +
       wheels = [

     

       626
       626
       +
           { url = "https://files.pythonhosted.org/packages/e5/92/b31726561b5dae176c2d2c2dc43a9c5bfba5d32f96f8b4c0a600dd492447/pydantic_core-2.33.2-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:2b3d326aaef0c0399d9afffeb6367d5e26ddc24d351dbc9c636840ac355dc5d8", size = 2028817, upload-time = "2025-04-23T18:30:43.919Z" },

     

       627
       627
       +
           { url = "https://files.pythonhosted.org/packages/a3/44/3f0b95fafdaca04a483c4e685fe437c6891001bf3ce8b2fded82b9ea3aa1/pydantic_core-2.33.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0e5b2671f05ba48b94cb90ce55d8bdcaaedb8ba00cc5359f6810fc918713983d", size = 1861357, upload-time = "2025-04-23T18:30:46.372Z" },

     

       628
       628
       +
           { url = "https://files.pythonhosted.org/packages/30/97/e8f13b55766234caae05372826e8e4b3b96e7b248be3157f53237682e43c/pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0069c9acc3f3981b9ff4cdfaf088e98d83440a4c7ea1bc07460af3d4dc22e72d", size = 1898011, upload-time = "2025-04-23T18:30:47.591Z" },

     

       629
       629
       +
           { url = "https://files.pythonhosted.org/packages/9b/a3/99c48cf7bafc991cc3ee66fd544c0aae8dc907b752f1dad2d79b1b5a471f/pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d53b22f2032c42eaaf025f7c40c2e3b94568ae077a606f006d206a463bc69572", size = 1982730, upload-time = "2025-04-23T18:30:49.328Z" },

     

       630
       630
       +
           { url = "https://files.pythonhosted.org/packages/de/8e/a5b882ec4307010a840fb8b58bd9bf65d1840c92eae7534c7441709bf54b/pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0405262705a123b7ce9f0b92f123334d67b70fd1f20a9372b907ce1080c7ba02", size = 2136178, upload-time = "2025-04-23T18:30:50.907Z" },

     

       631
       631
       +
           { url = "https://files.pythonhosted.org/packages/e4/bb/71e35fc3ed05af6834e890edb75968e2802fe98778971ab5cba20a162315/pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4b25d91e288e2c4e0662b8038a28c6a07eaac3e196cfc4ff69de4ea3db992a1b", size = 2736462, upload-time = "2025-04-23T18:30:52.083Z" },

     

       632
       632
       +
           { url = "https://files.pythonhosted.org/packages/31/0d/c8f7593e6bc7066289bbc366f2235701dcbebcd1ff0ef8e64f6f239fb47d/pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6bdfe4b3789761f3bcb4b1ddf33355a71079858958e3a552f16d5af19768fef2", size = 2005652, upload-time = "2025-04-23T18:30:53.389Z" },

     

       633
       633
       +
           { url = "https://files.pythonhosted.org/packages/d2/7a/996d8bd75f3eda405e3dd219ff5ff0a283cd8e34add39d8ef9157e722867/pydantic_core-2.33.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:efec8db3266b76ef9607c2c4c419bdb06bf335ae433b80816089ea7585816f6a", size = 2113306, upload-time = "2025-04-23T18:30:54.661Z" },

     

       634
       634
       +
           { url = "https://files.pythonhosted.org/packages/ff/84/daf2a6fb2db40ffda6578a7e8c5a6e9c8affb251a05c233ae37098118788/pydantic_core-2.33.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:031c57d67ca86902726e0fae2214ce6770bbe2f710dc33063187a68744a5ecac", size = 2073720, upload-time = "2025-04-23T18:30:56.11Z" },

     

       635
       635
       +
           { url = "https://files.pythonhosted.org/packages/77/fb/2258da019f4825128445ae79456a5499c032b55849dbd5bed78c95ccf163/pydantic_core-2.33.2-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:f8de619080e944347f5f20de29a975c2d815d9ddd8be9b9b7268e2e3ef68605a", size = 2244915, upload-time = "2025-04-23T18:30:57.501Z" },

     

       636
       636
       +
           { url = "https://files.pythonhosted.org/packages/d8/7a/925ff73756031289468326e355b6fa8316960d0d65f8b5d6b3a3e7866de7/pydantic_core-2.33.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:73662edf539e72a9440129f231ed3757faab89630d291b784ca99237fb94db2b", size = 2241884, upload-time = "2025-04-23T18:30:58.867Z" },

     

       637
       637
       +
           { url = "https://files.pythonhosted.org/packages/0b/b0/249ee6d2646f1cdadcb813805fe76265745c4010cf20a8eba7b0e639d9b2/pydantic_core-2.33.2-cp310-cp310-win32.whl", hash = "sha256:0a39979dcbb70998b0e505fb1556a1d550a0781463ce84ebf915ba293ccb7e22", size = 1910496, upload-time = "2025-04-23T18:31:00.078Z" },

     

       638
       638
       +
           { url = "https://files.pythonhosted.org/packages/66/ff/172ba8f12a42d4b552917aa65d1f2328990d3ccfc01d5b7c943ec084299f/pydantic_core-2.33.2-cp310-cp310-win_amd64.whl", hash = "sha256:b0379a2b24882fef529ec3b4987cb5d003b9cda32256024e6fe1586ac45fc640", size = 1955019, upload-time = "2025-04-23T18:31:01.335Z" },

     

       639
       639
       +
           { url = "https://files.pythonhosted.org/packages/3f/8d/71db63483d518cbbf290261a1fc2839d17ff89fce7089e08cad07ccfce67/pydantic_core-2.33.2-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:4c5b0a576fb381edd6d27f0a85915c6daf2f8138dc5c267a57c08a62900758c7", size = 2028584, upload-time = "2025-04-23T18:31:03.106Z" },

     

       640
       640
       +
           { url = "https://files.pythonhosted.org/packages/24/2f/3cfa7244ae292dd850989f328722d2aef313f74ffc471184dc509e1e4e5a/pydantic_core-2.33.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e799c050df38a639db758c617ec771fd8fb7a5f8eaaa4b27b101f266b216a246", size = 1855071, upload-time = "2025-04-23T18:31:04.621Z" },

     

       641
       641
       +
           { url = "https://files.pythonhosted.org/packages/b3/d3/4ae42d33f5e3f50dd467761304be2fa0a9417fbf09735bc2cce003480f2a/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dc46a01bf8d62f227d5ecee74178ffc448ff4e5197c756331f71efcc66dc980f", size = 1897823, upload-time = "2025-04-23T18:31:06.377Z" },

     

       642
       642
       +
           { url = "https://files.pythonhosted.org/packages/f4/f3/aa5976e8352b7695ff808599794b1fba2a9ae2ee954a3426855935799488/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a144d4f717285c6d9234a66778059f33a89096dfb9b39117663fd8413d582dcc", size = 1983792, upload-time = "2025-04-23T18:31:07.93Z" },

     

       643
       643
       +
           { url = "https://files.pythonhosted.org/packages/d5/7a/cda9b5a23c552037717f2b2a5257e9b2bfe45e687386df9591eff7b46d28/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:73cf6373c21bc80b2e0dc88444f41ae60b2f070ed02095754eb5a01df12256de", size = 2136338, upload-time = "2025-04-23T18:31:09.283Z" },

     

       644
       644
       +
           { url = "https://files.pythonhosted.org/packages/2b/9f/b8f9ec8dd1417eb9da784e91e1667d58a2a4a7b7b34cf4af765ef663a7e5/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3dc625f4aa79713512d1976fe9f0bc99f706a9dee21dfd1810b4bbbf228d0e8a", size = 2730998, upload-time = "2025-04-23T18:31:11.7Z" },

     

       645
       645
       +
           { url = "https://files.pythonhosted.org/packages/47/bc/cd720e078576bdb8255d5032c5d63ee5c0bf4b7173dd955185a1d658c456/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:881b21b5549499972441da4758d662aeea93f1923f953e9cbaff14b8b9565aef", size = 2003200, upload-time = "2025-04-23T18:31:13.536Z" },

     

       646
       646
       +
           { url = "https://files.pythonhosted.org/packages/ca/22/3602b895ee2cd29d11a2b349372446ae9727c32e78a94b3d588a40fdf187/pydantic_core-2.33.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:bdc25f3681f7b78572699569514036afe3c243bc3059d3942624e936ec93450e", size = 2113890, upload-time = "2025-04-23T18:31:15.011Z" },

     

       647
       647
       +
           { url = "https://files.pythonhosted.org/packages/ff/e6/e3c5908c03cf00d629eb38393a98fccc38ee0ce8ecce32f69fc7d7b558a7/pydantic_core-2.33.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:fe5b32187cbc0c862ee201ad66c30cf218e5ed468ec8dc1cf49dec66e160cc4d", size = 2073359, upload-time = "2025-04-23T18:31:16.393Z" },

     

       648
       648
       +
           { url = "https://files.pythonhosted.org/packages/12/e7/6a36a07c59ebefc8777d1ffdaf5ae71b06b21952582e4b07eba88a421c79/pydantic_core-2.33.2-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:bc7aee6f634a6f4a95676fcb5d6559a2c2a390330098dba5e5a5f28a2e4ada30", size = 2245883, upload-time = "2025-04-23T18:31:17.892Z" },

     

       649
       649
       +
           { url = "https://files.pythonhosted.org/packages/16/3f/59b3187aaa6cc0c1e6616e8045b284de2b6a87b027cce2ffcea073adf1d2/pydantic_core-2.33.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:235f45e5dbcccf6bd99f9f472858849f73d11120d76ea8707115415f8e5ebebf", size = 2241074, upload-time = "2025-04-23T18:31:19.205Z" },

     

       650
       650
       +
           { url = "https://files.pythonhosted.org/packages/e0/ed/55532bb88f674d5d8f67ab121a2a13c385df382de2a1677f30ad385f7438/pydantic_core-2.33.2-cp311-cp311-win32.whl", hash = "sha256:6368900c2d3ef09b69cb0b913f9f8263b03786e5b2a387706c5afb66800efd51", size = 1910538, upload-time = "2025-04-23T18:31:20.541Z" },

     

       651
       651
       +
           { url = "https://files.pythonhosted.org/packages/fe/1b/25b7cccd4519c0b23c2dd636ad39d381abf113085ce4f7bec2b0dc755eb1/pydantic_core-2.33.2-cp311-cp311-win_amd64.whl", hash = "sha256:1e063337ef9e9820c77acc768546325ebe04ee38b08703244c1309cccc4f1bab", size = 1952909, upload-time = "2025-04-23T18:31:22.371Z" },

     

       652
       652
       +
           { url = "https://files.pythonhosted.org/packages/49/a9/d809358e49126438055884c4366a1f6227f0f84f635a9014e2deb9b9de54/pydantic_core-2.33.2-cp311-cp311-win_arm64.whl", hash = "sha256:6b99022f1d19bc32a4c2a0d544fc9a76e3be90f0b3f4af413f87d38749300e65", size = 1897786, upload-time = "2025-04-23T18:31:24.161Z" },

     

       653
       653
       +
           { url = "https://files.pythonhosted.org/packages/18/8a/2b41c97f554ec8c71f2a8a5f85cb56a8b0956addfe8b0efb5b3d77e8bdc3/pydantic_core-2.33.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a7ec89dc587667f22b6a0b6579c249fca9026ce7c333fc142ba42411fa243cdc", size = 2009000, upload-time = "2025-04-23T18:31:25.863Z" },

     

       654
       654
       +
           { url = "https://files.pythonhosted.org/packages/a1/02/6224312aacb3c8ecbaa959897af57181fb6cf3a3d7917fd44d0f2917e6f2/pydantic_core-2.33.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3c6db6e52c6d70aa0d00d45cdb9b40f0433b96380071ea80b09277dba021ddf7", size = 1847996, upload-time = "2025-04-23T18:31:27.341Z" },

     

       655
       655
       +
           { url = "https://files.pythonhosted.org/packages/d6/46/6dcdf084a523dbe0a0be59d054734b86a981726f221f4562aed313dbcb49/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e61206137cbc65e6d5256e1166f88331d3b6238e082d9f74613b9b765fb9025", size = 1880957, upload-time = "2025-04-23T18:31:28.956Z" },

     

       656
       656
       +
           { url = "https://files.pythonhosted.org/packages/ec/6b/1ec2c03837ac00886ba8160ce041ce4e325b41d06a034adbef11339ae422/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:eb8c529b2819c37140eb51b914153063d27ed88e3bdc31b71198a198e921e011", size = 1964199, upload-time = "2025-04-23T18:31:31.025Z" },

     

       657
       657
       +
           { url = "https://files.pythonhosted.org/packages/2d/1d/6bf34d6adb9debd9136bd197ca72642203ce9aaaa85cfcbfcf20f9696e83/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c52b02ad8b4e2cf14ca7b3d918f3eb0ee91e63b3167c32591e57c4317e134f8f", size = 2120296, upload-time = "2025-04-23T18:31:32.514Z" },

     

       658
       658
       +
           { url = "https://files.pythonhosted.org/packages/e0/94/2bd0aaf5a591e974b32a9f7123f16637776c304471a0ab33cf263cf5591a/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:96081f1605125ba0855dfda83f6f3df5ec90c61195421ba72223de35ccfb2f88", size = 2676109, upload-time = "2025-04-23T18:31:33.958Z" },

     

       659
       659
       +
           { url = "https://files.pythonhosted.org/packages/f9/41/4b043778cf9c4285d59742281a769eac371b9e47e35f98ad321349cc5d61/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f57a69461af2a5fa6e6bbd7a5f60d3b7e6cebb687f55106933188e79ad155c1", size = 2002028, upload-time = "2025-04-23T18:31:39.095Z" },

     

       660
       660
       +
           { url = "https://files.pythonhosted.org/packages/cb/d5/7bb781bf2748ce3d03af04d5c969fa1308880e1dca35a9bd94e1a96a922e/pydantic_core-2.33.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:572c7e6c8bb4774d2ac88929e3d1f12bc45714ae5ee6d9a788a9fb35e60bb04b", size = 2100044, upload-time = "2025-04-23T18:31:41.034Z" },

     

       661
       661
       +
           { url = "https://files.pythonhosted.org/packages/fe/36/def5e53e1eb0ad896785702a5bbfd25eed546cdcf4087ad285021a90ed53/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:db4b41f9bd95fbe5acd76d89920336ba96f03e149097365afe1cb092fceb89a1", size = 2058881, upload-time = "2025-04-23T18:31:42.757Z" },

     

       662
       662
       +
           { url = "https://files.pythonhosted.org/packages/01/6c/57f8d70b2ee57fc3dc8b9610315949837fa8c11d86927b9bb044f8705419/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:fa854f5cf7e33842a892e5c73f45327760bc7bc516339fda888c75ae60edaeb6", size = 2227034, upload-time = "2025-04-23T18:31:44.304Z" },

     

       663
       663
       +
           { url = "https://files.pythonhosted.org/packages/27/b9/9c17f0396a82b3d5cbea4c24d742083422639e7bb1d5bf600e12cb176a13/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:5f483cfb75ff703095c59e365360cb73e00185e01aaea067cd19acffd2ab20ea", size = 2234187, upload-time = "2025-04-23T18:31:45.891Z" },

     

       664
       664
       +
           { url = "https://files.pythonhosted.org/packages/b0/6a/adf5734ffd52bf86d865093ad70b2ce543415e0e356f6cacabbc0d9ad910/pydantic_core-2.33.2-cp312-cp312-win32.whl", hash = "sha256:9cb1da0f5a471435a7bc7e439b8a728e8b61e59784b2af70d7c169f8dd8ae290", size = 1892628, upload-time = "2025-04-23T18:31:47.819Z" },

     

       665
       665
       +
           { url = "https://files.pythonhosted.org/packages/43/e4/5479fecb3606c1368d496a825d8411e126133c41224c1e7238be58b87d7e/pydantic_core-2.33.2-cp312-cp312-win_amd64.whl", hash = "sha256:f941635f2a3d96b2973e867144fde513665c87f13fe0e193c158ac51bfaaa7b2", size = 1955866, upload-time = "2025-04-23T18:31:49.635Z" },

     

       666
       666
       +
           { url = "https://files.pythonhosted.org/packages/0d/24/8b11e8b3e2be9dd82df4b11408a67c61bb4dc4f8e11b5b0fc888b38118b5/pydantic_core-2.33.2-cp312-cp312-win_arm64.whl", hash = "sha256:cca3868ddfaccfbc4bfb1d608e2ccaaebe0ae628e1416aeb9c4d88c001bb45ab", size = 1888894, upload-time = "2025-04-23T18:31:51.609Z" },

     

       667
       667
       +
           { url = "https://files.pythonhosted.org/packages/46/8c/99040727b41f56616573a28771b1bfa08a3d3fe74d3d513f01251f79f172/pydantic_core-2.33.2-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:1082dd3e2d7109ad8b7da48e1d4710c8d06c253cbc4a27c1cff4fbcaa97a9e3f", size = 2015688, upload-time = "2025-04-23T18:31:53.175Z" },

     

       668
       668
       +
           { url = "https://files.pythonhosted.org/packages/3a/cc/5999d1eb705a6cefc31f0b4a90e9f7fc400539b1a1030529700cc1b51838/pydantic_core-2.33.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f517ca031dfc037a9c07e748cefd8d96235088b83b4f4ba8939105d20fa1dcd6", size = 1844808, upload-time = "2025-04-23T18:31:54.79Z" },

     

       669
       669
       +
           { url = "https://files.pythonhosted.org/packages/6f/5e/a0a7b8885c98889a18b6e376f344da1ef323d270b44edf8174d6bce4d622/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a9f2c9dd19656823cb8250b0724ee9c60a82f3cdf68a080979d13092a3b0fef", size = 1885580, upload-time = "2025-04-23T18:31:57.393Z" },

     

       670
       670
       +
           { url = "https://files.pythonhosted.org/packages/3b/2a/953581f343c7d11a304581156618c3f592435523dd9d79865903272c256a/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2b0a451c263b01acebe51895bfb0e1cc842a5c666efe06cdf13846c7418caa9a", size = 1973859, upload-time = "2025-04-23T18:31:59.065Z" },

     

       671
       671
       +
           { url = "https://files.pythonhosted.org/packages/e6/55/f1a813904771c03a3f97f676c62cca0c0a4138654107c1b61f19c644868b/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ea40a64d23faa25e62a70ad163571c0b342b8bf66d5fa612ac0dec4f069d916", size = 2120810, upload-time = "2025-04-23T18:32:00.78Z" },

     

       672
       672
       +
           { url = "https://files.pythonhosted.org/packages/aa/c3/053389835a996e18853ba107a63caae0b9deb4a276c6b472931ea9ae6e48/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0fb2d542b4d66f9470e8065c5469ec676978d625a8b7a363f07d9a501a9cb36a", size = 2676498, upload-time = "2025-04-23T18:32:02.418Z" },

     

       673
       673
       +
           { url = "https://files.pythonhosted.org/packages/eb/3c/f4abd740877a35abade05e437245b192f9d0ffb48bbbbd708df33d3cda37/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9fdac5d6ffa1b5a83bca06ffe7583f5576555e6c8b3a91fbd25ea7780f825f7d", size = 2000611, upload-time = "2025-04-23T18:32:04.152Z" },

     

       674
       674
       +
           { url = "https://files.pythonhosted.org/packages/59/a7/63ef2fed1837d1121a894d0ce88439fe3e3b3e48c7543b2a4479eb99c2bd/pydantic_core-2.33.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:04a1a413977ab517154eebb2d326da71638271477d6ad87a769102f7c2488c56", size = 2107924, upload-time = "2025-04-23T18:32:06.129Z" },

     

       675
       675
       +
           { url = "https://files.pythonhosted.org/packages/04/8f/2551964ef045669801675f1cfc3b0d74147f4901c3ffa42be2ddb1f0efc4/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c8e7af2f4e0194c22b5b37205bfb293d166a7344a5b0d0eaccebc376546d77d5", size = 2063196, upload-time = "2025-04-23T18:32:08.178Z" },

     

       676
       676
       +
           { url = "https://files.pythonhosted.org/packages/26/bd/d9602777e77fc6dbb0c7db9ad356e9a985825547dce5ad1d30ee04903918/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:5c92edd15cd58b3c2d34873597a1e20f13094f59cf88068adb18947df5455b4e", size = 2236389, upload-time = "2025-04-23T18:32:10.242Z" },

     

       677
       677
       +
           { url = "https://files.pythonhosted.org/packages/42/db/0e950daa7e2230423ab342ae918a794964b053bec24ba8af013fc7c94846/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:65132b7b4a1c0beded5e057324b7e16e10910c106d43675d9bd87d4f38dde162", size = 2239223, upload-time = "2025-04-23T18:32:12.382Z" },

     

       678
       678
       +
           { url = "https://files.pythonhosted.org/packages/58/4d/4f937099c545a8a17eb52cb67fe0447fd9a373b348ccfa9a87f141eeb00f/pydantic_core-2.33.2-cp313-cp313-win32.whl", hash = "sha256:52fb90784e0a242bb96ec53f42196a17278855b0f31ac7c3cc6f5c1ec4811849", size = 1900473, upload-time = "2025-04-23T18:32:14.034Z" },

     

       679
       679
       +
           { url = "https://files.pythonhosted.org/packages/a0/75/4a0a9bac998d78d889def5e4ef2b065acba8cae8c93696906c3a91f310ca/pydantic_core-2.33.2-cp313-cp313-win_amd64.whl", hash = "sha256:c083a3bdd5a93dfe480f1125926afcdbf2917ae714bdb80b36d34318b2bec5d9", size = 1955269, upload-time = "2025-04-23T18:32:15.783Z" },

     

       680
       680
       +
           { url = "https://files.pythonhosted.org/packages/f9/86/1beda0576969592f1497b4ce8e7bc8cbdf614c352426271b1b10d5f0aa64/pydantic_core-2.33.2-cp313-cp313-win_arm64.whl", hash = "sha256:e80b087132752f6b3d714f041ccf74403799d3b23a72722ea2e6ba2e892555b9", size = 1893921, upload-time = "2025-04-23T18:32:18.473Z" },

     

       681
       681
       +
           { url = "https://files.pythonhosted.org/packages/a4/7d/e09391c2eebeab681df2b74bfe6c43422fffede8dc74187b2b0bf6fd7571/pydantic_core-2.33.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:61c18fba8e5e9db3ab908620af374db0ac1baa69f0f32df4f61ae23f15e586ac", size = 1806162, upload-time = "2025-04-23T18:32:20.188Z" },

     

       682
       682
       +
           { url = "https://files.pythonhosted.org/packages/f1/3d/847b6b1fed9f8ed3bb95a9ad04fbd0b212e832d4f0f50ff4d9ee5a9f15cf/pydantic_core-2.33.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95237e53bb015f67b63c91af7518a62a8660376a6a0db19b89acc77a4d6199f5", size = 1981560, upload-time = "2025-04-23T18:32:22.354Z" },

     

       683
       683
       +
           { url = "https://files.pythonhosted.org/packages/6f/9a/e73262f6c6656262b5fdd723ad90f518f579b7bc8622e43a942eec53c938/pydantic_core-2.33.2-cp313-cp313t-win_amd64.whl", hash = "sha256:c2fc0a768ef76c15ab9238afa6da7f69895bb5d1ee83aeea2e3509af4472d0b9", size = 1935777, upload-time = "2025-04-23T18:32:25.088Z" },

     

       684
       684
       +
           { url = "https://files.pythonhosted.org/packages/53/ea/bbe9095cdd771987d13c82d104a9c8559ae9aec1e29f139e286fd2e9256e/pydantic_core-2.33.2-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:a2b911a5b90e0374d03813674bf0a5fbbb7741570dcd4b4e85a2e48d17def29d", size = 2028677, upload-time = "2025-04-23T18:32:27.227Z" },

     

       685
       685
       +
           { url = "https://files.pythonhosted.org/packages/49/1d/4ac5ed228078737d457a609013e8f7edc64adc37b91d619ea965758369e5/pydantic_core-2.33.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:6fa6dfc3e4d1f734a34710f391ae822e0a8eb8559a85c6979e14e65ee6ba2954", size = 1864735, upload-time = "2025-04-23T18:32:29.019Z" },

     

       686
       686
       +
           { url = "https://files.pythonhosted.org/packages/23/9a/2e70d6388d7cda488ae38f57bc2f7b03ee442fbcf0d75d848304ac7e405b/pydantic_core-2.33.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c54c939ee22dc8e2d545da79fc5381f1c020d6d3141d3bd747eab59164dc89fb", size = 1898467, upload-time = "2025-04-23T18:32:31.119Z" },

     

       687
       687
       +
           { url = "https://files.pythonhosted.org/packages/ff/2e/1568934feb43370c1ffb78a77f0baaa5a8b6897513e7a91051af707ffdc4/pydantic_core-2.33.2-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:53a57d2ed685940a504248187d5685e49eb5eef0f696853647bf37c418c538f7", size = 1983041, upload-time = "2025-04-23T18:32:33.655Z" },

     

       688
       688
       +
           { url = "https://files.pythonhosted.org/packages/01/1a/1a1118f38ab64eac2f6269eb8c120ab915be30e387bb561e3af904b12499/pydantic_core-2.33.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:09fb9dd6571aacd023fe6aaca316bd01cf60ab27240d7eb39ebd66a3a15293b4", size = 2136503, upload-time = "2025-04-23T18:32:35.519Z" },

     

       689
       689
       +
           { url = "https://files.pythonhosted.org/packages/5c/da/44754d1d7ae0f22d6d3ce6c6b1486fc07ac2c524ed8f6eca636e2e1ee49b/pydantic_core-2.33.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0e6116757f7959a712db11f3e9c0a99ade00a5bbedae83cb801985aa154f071b", size = 2736079, upload-time = "2025-04-23T18:32:37.659Z" },

     

       690
       690
       +
           { url = "https://files.pythonhosted.org/packages/4d/98/f43cd89172220ec5aa86654967b22d862146bc4d736b1350b4c41e7c9c03/pydantic_core-2.33.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8d55ab81c57b8ff8548c3e4947f119551253f4e3787a7bbc0b6b3ca47498a9d3", size = 2006508, upload-time = "2025-04-23T18:32:39.637Z" },

     

       691
       691
       +
           { url = "https://files.pythonhosted.org/packages/2b/cc/f77e8e242171d2158309f830f7d5d07e0531b756106f36bc18712dc439df/pydantic_core-2.33.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c20c462aa4434b33a2661701b861604913f912254e441ab8d78d30485736115a", size = 2113693, upload-time = "2025-04-23T18:32:41.818Z" },

     

       692
       692
       +
           { url = "https://files.pythonhosted.org/packages/54/7a/7be6a7bd43e0a47c147ba7fbf124fe8aaf1200bc587da925509641113b2d/pydantic_core-2.33.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:44857c3227d3fb5e753d5fe4a3420d6376fa594b07b621e220cd93703fe21782", size = 2074224, upload-time = "2025-04-23T18:32:44.033Z" },

     

       693
       693
       +
           { url = "https://files.pythonhosted.org/packages/2a/07/31cf8fadffbb03be1cb520850e00a8490c0927ec456e8293cafda0726184/pydantic_core-2.33.2-cp39-cp39-musllinux_1_1_armv7l.whl", hash = "sha256:eb9b459ca4df0e5c87deb59d37377461a538852765293f9e6ee834f0435a93b9", size = 2245403, upload-time = "2025-04-23T18:32:45.836Z" },

     

       694
       694
       +
           { url = "https://files.pythonhosted.org/packages/b6/8d/bbaf4c6721b668d44f01861f297eb01c9b35f612f6b8e14173cb204e6240/pydantic_core-2.33.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:9fcd347d2cc5c23b06de6d3b7b8275be558a0c90549495c699e379a80bf8379e", size = 2242331, upload-time = "2025-04-23T18:32:47.618Z" },

     

       695
       695
       +
           { url = "https://files.pythonhosted.org/packages/bb/93/3cc157026bca8f5006250e74515119fcaa6d6858aceee8f67ab6dc548c16/pydantic_core-2.33.2-cp39-cp39-win32.whl", hash = "sha256:83aa99b1285bc8f038941ddf598501a86f1536789740991d7d8756e34f1e74d9", size = 1910571, upload-time = "2025-04-23T18:32:49.401Z" },

     

       696
       696
       +
           { url = "https://files.pythonhosted.org/packages/5b/90/7edc3b2a0d9f0dda8806c04e511a67b0b7a41d2187e2003673a996fb4310/pydantic_core-2.33.2-cp39-cp39-win_amd64.whl", hash = "sha256:f481959862f57f29601ccced557cc2e817bce7533ab8e01a797a48b49c9692b3", size = 1956504, upload-time = "2025-04-23T18:32:51.287Z" },

     

       697
       697
       +
           { url = "https://files.pythonhosted.org/packages/30/68/373d55e58b7e83ce371691f6eaa7175e3a24b956c44628eb25d7da007917/pydantic_core-2.33.2-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:5c4aa4e82353f65e548c476b37e64189783aa5384903bfea4f41580f255fddfa", size = 2023982, upload-time = "2025-04-23T18:32:53.14Z" },

     

       698
       698
       +
           { url = "https://files.pythonhosted.org/packages/a4/16/145f54ac08c96a63d8ed6442f9dec17b2773d19920b627b18d4f10a061ea/pydantic_core-2.33.2-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:d946c8bf0d5c24bf4fe333af284c59a19358aa3ec18cb3dc4370080da1e8ad29", size = 1858412, upload-time = "2025-04-23T18:32:55.52Z" },

     

       699
       699
       +
           { url = "https://files.pythonhosted.org/packages/41/b1/c6dc6c3e2de4516c0bb2c46f6a373b91b5660312342a0cf5826e38ad82fa/pydantic_core-2.33.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:87b31b6846e361ef83fedb187bb5b4372d0da3f7e28d85415efa92d6125d6e6d", size = 1892749, upload-time = "2025-04-23T18:32:57.546Z" },

     

       700
       700
       +
           { url = "https://files.pythonhosted.org/packages/12/73/8cd57e20afba760b21b742106f9dbdfa6697f1570b189c7457a1af4cd8a0/pydantic_core-2.33.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aa9d91b338f2df0508606f7009fde642391425189bba6d8c653afd80fd6bb64e", size = 2067527, upload-time = "2025-04-23T18:32:59.771Z" },

     

       701
       701
       +
           { url = "https://files.pythonhosted.org/packages/e3/d5/0bb5d988cc019b3cba4a78f2d4b3854427fc47ee8ec8e9eaabf787da239c/pydantic_core-2.33.2-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2058a32994f1fde4ca0480ab9d1e75a0e8c87c22b53a3ae66554f9af78f2fe8c", size = 2108225, upload-time = "2025-04-23T18:33:04.51Z" },

     

       702
       702
       +
           { url = "https://files.pythonhosted.org/packages/f1/c5/00c02d1571913d496aabf146106ad8239dc132485ee22efe08085084ff7c/pydantic_core-2.33.2-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:0e03262ab796d986f978f79c943fc5f620381be7287148b8010b4097f79a39ec", size = 2069490, upload-time = "2025-04-23T18:33:06.391Z" },

     

       703
       703
       +
           { url = "https://files.pythonhosted.org/packages/22/a8/dccc38768274d3ed3a59b5d06f59ccb845778687652daa71df0cab4040d7/pydantic_core-2.33.2-pp310-pypy310_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:1a8695a8d00c73e50bff9dfda4d540b7dee29ff9b8053e38380426a85ef10052", size = 2237525, upload-time = "2025-04-23T18:33:08.44Z" },

     

       704
       704
       +
           { url = "https://files.pythonhosted.org/packages/d4/e7/4f98c0b125dda7cf7ccd14ba936218397b44f50a56dd8c16a3091df116c3/pydantic_core-2.33.2-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:fa754d1850735a0b0e03bcffd9d4b4343eb417e47196e4485d9cca326073a42c", size = 2238446, upload-time = "2025-04-23T18:33:10.313Z" },

     

       705
       705
       +
           { url = "https://files.pythonhosted.org/packages/ce/91/2ec36480fdb0b783cd9ef6795753c1dea13882f2e68e73bce76ae8c21e6a/pydantic_core-2.33.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:a11c8d26a50bfab49002947d3d237abe4d9e4b5bdc8846a63537b6488e197808", size = 2066678, upload-time = "2025-04-23T18:33:12.224Z" },

     

       706
       706
       +
           { url = "https://files.pythonhosted.org/packages/7b/27/d4ae6487d73948d6f20dddcd94be4ea43e74349b56eba82e9bdee2d7494c/pydantic_core-2.33.2-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:dd14041875d09cc0f9308e37a6f8b65f5585cf2598a53aa0123df8b129d481f8", size = 2025200, upload-time = "2025-04-23T18:33:14.199Z" },

     

       707
       707
       +
           { url = "https://files.pythonhosted.org/packages/f1/b8/b3cb95375f05d33801024079b9392a5ab45267a63400bf1866e7ce0f0de4/pydantic_core-2.33.2-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:d87c561733f66531dced0da6e864f44ebf89a8fba55f31407b00c2f7f9449593", size = 1859123, upload-time = "2025-04-23T18:33:16.555Z" },

     

       708
       708
       +
           { url = "https://files.pythonhosted.org/packages/05/bc/0d0b5adeda59a261cd30a1235a445bf55c7e46ae44aea28f7bd6ed46e091/pydantic_core-2.33.2-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2f82865531efd18d6e07a04a17331af02cb7a651583c418df8266f17a63c6612", size = 1892852, upload-time = "2025-04-23T18:33:18.513Z" },

     

       709
       709
       +
           { url = "https://files.pythonhosted.org/packages/3e/11/d37bdebbda2e449cb3f519f6ce950927b56d62f0b84fd9cb9e372a26a3d5/pydantic_core-2.33.2-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bfb5112df54209d820d7bf9317c7a6c9025ea52e49f46b6a2060104bba37de7", size = 2067484, upload-time = "2025-04-23T18:33:20.475Z" },

     

       710
       710
       +
           { url = "https://files.pythonhosted.org/packages/8c/55/1f95f0a05ce72ecb02a8a8a1c3be0579bbc29b1d5ab68f1378b7bebc5057/pydantic_core-2.33.2-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:64632ff9d614e5eecfb495796ad51b0ed98c453e447a76bcbeeb69615079fc7e", size = 2108896, upload-time = "2025-04-23T18:33:22.501Z" },

     

       711
       711
       +
           { url = "https://files.pythonhosted.org/packages/53/89/2b2de6c81fa131f423246a9109d7b2a375e83968ad0800d6e57d0574629b/pydantic_core-2.33.2-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:f889f7a40498cc077332c7ab6b4608d296d852182211787d4f3ee377aaae66e8", size = 2069475, upload-time = "2025-04-23T18:33:24.528Z" },

     

       712
       712
       +
           { url = "https://files.pythonhosted.org/packages/b8/e9/1f7efbe20d0b2b10f6718944b5d8ece9152390904f29a78e68d4e7961159/pydantic_core-2.33.2-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:de4b83bb311557e439b9e186f733f6c645b9417c84e2eb8203f3f820a4b988bf", size = 2239013, upload-time = "2025-04-23T18:33:26.621Z" },

     

       713
       713
       +
           { url = "https://files.pythonhosted.org/packages/3c/b2/5309c905a93811524a49b4e031e9851a6b00ff0fb668794472ea7746b448/pydantic_core-2.33.2-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:82f68293f055f51b51ea42fafc74b6aad03e70e191799430b90c13d643059ebb", size = 2238715, upload-time = "2025-04-23T18:33:28.656Z" },

     

       714
       714
       +
           { url = "https://files.pythonhosted.org/packages/32/56/8a7ca5d2cd2cda1d245d34b1c9a942920a718082ae8e54e5f3e5a58b7add/pydantic_core-2.33.2-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:329467cecfb529c925cf2bbd4d60d2c509bc2fb52a20c1045bf09bb70971a9c1", size = 2066757, upload-time = "2025-04-23T18:33:30.645Z" },

     

       715
       715
       +
           { url = "https://files.pythonhosted.org/packages/08/98/dbf3fdfabaf81cda5622154fda78ea9965ac467e3239078e0dcd6df159e7/pydantic_core-2.33.2-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:87acbfcf8e90ca885206e98359d7dca4bcbb35abdc0ff66672a293e1d7a19101", size = 2024034, upload-time = "2025-04-23T18:33:32.843Z" },

     

       716
       716
       +
           { url = "https://files.pythonhosted.org/packages/8d/99/7810aa9256e7f2ccd492590f86b79d370df1e9292f1f80b000b6a75bd2fb/pydantic_core-2.33.2-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:7f92c15cd1e97d4b12acd1cc9004fa092578acfa57b67ad5e43a197175d01a64", size = 1858578, upload-time = "2025-04-23T18:33:34.912Z" },

     

       717
       717
       +
           { url = "https://files.pythonhosted.org/packages/d8/60/bc06fa9027c7006cc6dd21e48dbf39076dc39d9abbaf718a1604973a9670/pydantic_core-2.33.2-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d3f26877a748dc4251cfcfda9dfb5f13fcb034f5308388066bcfe9031b63ae7d", size = 1892858, upload-time = "2025-04-23T18:33:36.933Z" },

     

       718
       718
       +
           { url = "https://files.pythonhosted.org/packages/f2/40/9d03997d9518816c68b4dfccb88969756b9146031b61cd37f781c74c9b6a/pydantic_core-2.33.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dac89aea9af8cd672fa7b510e7b8c33b0bba9a43186680550ccf23020f32d535", size = 2068498, upload-time = "2025-04-23T18:33:38.997Z" },

     

       719
       719
       +
           { url = "https://files.pythonhosted.org/packages/d8/62/d490198d05d2d86672dc269f52579cad7261ced64c2df213d5c16e0aecb1/pydantic_core-2.33.2-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:970919794d126ba8645f3837ab6046fb4e72bbc057b3709144066204c19a455d", size = 2108428, upload-time = "2025-04-23T18:33:41.18Z" },

     

       720
       720
       +
           { url = "https://files.pythonhosted.org/packages/9a/ec/4cd215534fd10b8549015f12ea650a1a973da20ce46430b68fc3185573e8/pydantic_core-2.33.2-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:3eb3fe62804e8f859c49ed20a8451342de53ed764150cb14ca71357c765dc2a6", size = 2069854, upload-time = "2025-04-23T18:33:43.446Z" },

     

       721
       721
       +
           { url = "https://files.pythonhosted.org/packages/1a/1a/abbd63d47e1d9b0d632fee6bb15785d0889c8a6e0a6c3b5a8e28ac1ec5d2/pydantic_core-2.33.2-pp39-pypy39_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:3abcd9392a36025e3bd55f9bd38d908bd17962cc49bc6da8e7e96285336e2bca", size = 2237859, upload-time = "2025-04-23T18:33:45.56Z" },

     

       722
       722
       +
           { url = "https://files.pythonhosted.org/packages/80/1c/fa883643429908b1c90598fd2642af8839efd1d835b65af1f75fba4d94fe/pydantic_core-2.33.2-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:3a1c81334778f9e3af2f8aeb7a960736e5cab1dfebfb26aabca09afd2906c039", size = 2239059, upload-time = "2025-04-23T18:33:47.735Z" },

     

       723
       723
       +
           { url = "https://files.pythonhosted.org/packages/d4/29/3cade8a924a61f60ccfa10842f75eb12787e1440e2b8660ceffeb26685e7/pydantic_core-2.33.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:2807668ba86cb38c6817ad9bc66215ab8584d1d304030ce4f0887336f28a5e27", size = 2066661, upload-time = "2025-04-23T18:33:49.995Z" },

     

       724
       724
       +
       ]

     

       725
       725
       +
       

     

       726
       726
       +
       [[package]]

     

       727
       727
       +
       name = "pydantic-settings"

     

       728
       728
       +
       version = "2.10.1"

     

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

     

       730
       730
       +
       dependencies = [

     

       731
       731
       +
           { name = "pydantic" },

     

       732
       732
       +
           { name = "python-dotenv" },

     

       733
       733
       +
           { name = "typing-inspection" },

     

       734
       734
       +
       ]

     

       735
       735
       +
       sdist = { url = "https://files.pythonhosted.org/packages/68/85/1ea668bbab3c50071ca613c6ab30047fb36ab0da1b92fa8f17bbc38fd36c/pydantic_settings-2.10.1.tar.gz", hash = "sha256:06f0062169818d0f5524420a360d632d5857b83cffd4d42fe29597807a1614ee", size = 172583, upload-time = "2025-06-24T13:26:46.841Z" }

     

       736
       736
       +
       wheels = [

     

       737
       737
       +
           { url = "https://files.pythonhosted.org/packages/58/f0/427018098906416f580e3cf1366d3b1abfb408a0652e9f31600c24a1903c/pydantic_settings-2.10.1-py3-none-any.whl", hash = "sha256:a60952460b99cf661dc25c29c0ef171721f98bfcb52ef8d9ea4c943d7c8cc796", size = 45235, upload-time = "2025-06-24T13:26:45.485Z" },

     

       738
       738
       +
       ]

     

       739
       739
       +
       

     

       740
       740
       +
       [[package]]

     

       741
       741
       +
       name = "pygments"

     

       742
       742
       +
       version = "2.19.2"

     

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

     

       744
       744
       +
       sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }

     

       745
       745
       +
       wheels = [

     

       746
       746
       +
           { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },

     

       747
       747
       +
       ]

     

       748
       748
       +
       

     

       749
       749
       +
       [[package]]

     

       750
       750
       +
       name = "pytest"

     

       751
       751
       +
       version = "8.4.1"

     

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

     

       753
       753
       +
       dependencies = [

     

       754
       754
       +
           { name = "colorama", marker = "sys_platform == 'win32'" },

     

       755
       755
       +
           { name = "exceptiongroup", marker = "python_full_version < '3.11'" },

     

       756
       756
       +
           { name = "iniconfig" },

     

       757
       757
       +
           { name = "packaging" },

     

       758
       758
       +
           { name = "pluggy" },

     

       759
       759
       +
           { name = "pygments" },

     

       760
       760
       +
           { name = "tomli", marker = "python_full_version < '3.11'" },

     

       761
       761
       +
       ]

     

       762
       762
       +
       sdist = { url = "https://files.pythonhosted.org/packages/08/ba/45911d754e8eba3d5a841a5ce61a65a685ff1798421ac054f85aa8747dfb/pytest-8.4.1.tar.gz", hash = "sha256:7c67fd69174877359ed9371ec3af8a3d2b04741818c51e5e99cc1742251fa93c", size = 1517714, upload-time = "2025-06-18T05:48:06.109Z" }

     

       763
       763
       +
       wheels = [

     

       764
       764
       +
           { url = "https://files.pythonhosted.org/packages/29/16/c8a903f4c4dffe7a12843191437d7cd8e32751d5de349d45d3fe69544e87/pytest-8.4.1-py3-none-any.whl", hash = "sha256:539c70ba6fcead8e78eebbf1115e8b589e7565830d7d006a8723f19ac8a0afb7", size = 365474, upload-time = "2025-06-18T05:48:03.955Z" },

     

       765
       765
       +
       ]

     

       766
       766
       +
       

     

       767
       767
       +
       [[package]]

     

       768
       768
       +
       name = "pytest-asyncio"

     

       769
       769
       +
       version = "1.0.0"

     

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

     

       771
       771
       +
       dependencies = [

     

       772
       772
       +
           { name = "pytest" },

     

       773
       773
       +
           { name = "typing-extensions", marker = "python_full_version < '3.10'" },

     

       774
       774
       +
       ]

     

       775
       775
       +
       sdist = { url = "https://files.pythonhosted.org/packages/d0/d4/14f53324cb1a6381bef29d698987625d80052bb33932d8e7cbf9b337b17c/pytest_asyncio-1.0.0.tar.gz", hash = "sha256:d15463d13f4456e1ead2594520216b225a16f781e144f8fdf6c5bb4667c48b3f", size = 46960, upload-time = "2025-05-26T04:54:40.484Z" }

     

       776
       776
       +
       wheels = [

     

       777
       777
       +
           { url = "https://files.pythonhosted.org/packages/30/05/ce271016e351fddc8399e546f6e23761967ee09c8c568bbfbecb0c150171/pytest_asyncio-1.0.0-py3-none-any.whl", hash = "sha256:4f024da9f1ef945e680dc68610b52550e36590a67fd31bb3b4943979a1f90ef3", size = 15976, upload-time = "2025-05-26T04:54:39.035Z" },

     

       778
       778
       +
       ]

     

       779
       779
       +
       

     

       780
       780
       +
       [[package]]

     

       781
       781
       +
       name = "pytest-cov"

     

       782
       782
       +
       version = "6.2.1"

     

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

     

       784
       784
       +
       dependencies = [

     

       785
       785
       +
           { name = "coverage", extra = ["toml"] },

     

       786
       786
       +
           { name = "pluggy" },

     

       787
       787
       +
           { name = "pytest" },

     

       788
       788
       +
       ]

     

       789
       789
       +
       sdist = { url = "https://files.pythonhosted.org/packages/18/99/668cade231f434aaa59bbfbf49469068d2ddd945000621d3d165d2e7dd7b/pytest_cov-6.2.1.tar.gz", hash = "sha256:25cc6cc0a5358204b8108ecedc51a9b57b34cc6b8c967cc2c01a4e00d8a67da2", size = 69432, upload-time = "2025-06-12T10:47:47.684Z" }

     

       790
       790
       +
       wheels = [

     

       791
       791
       +
           { url = "https://files.pythonhosted.org/packages/bc/16/4ea354101abb1287856baa4af2732be351c7bee728065aed451b678153fd/pytest_cov-6.2.1-py3-none-any.whl", hash = "sha256:f5bc4c23f42f1cdd23c70b1dab1bbaef4fc505ba950d53e0081d0730dd7e86d5", size = 24644, upload-time = "2025-06-12T10:47:45.932Z" },

     

       792
       792
       +
       ]

     

       793
       793
       +
       

     

       794
       794
       +
       [[package]]

     

       795
       795
       +
       name = "python-dateutil"

     

       796
       796
       +
       version = "2.9.0.post0"

     

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

     

       798
       798
       +
       dependencies = [

     

       799
       799
       +
           { name = "six" },

     

       800
       800
       +
       ]

     

       801
       801
       +
       sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" }

     

       802
       802
       +
       wheels = [

     

       803
       803
       +
           { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" },

     

       804
       804
       +
       ]

     

       805
       805
       +
       

     

       806
       806
       +
       [[package]]

     

       807
       807
       +
       name = "python-dotenv"

     

       808
       808
       +
       version = "1.1.1"

     

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

     

       810
       810
       +
       sdist = { url = "https://files.pythonhosted.org/packages/f6/b0/4bc07ccd3572a2f9df7e6782f52b0c6c90dcbb803ac4a167702d7d0dfe1e/python_dotenv-1.1.1.tar.gz", hash = "sha256:a8a6399716257f45be6a007360200409fce5cda2661e3dec71d23dc15f6189ab", size = 41978, upload-time = "2025-06-24T04:21:07.341Z" }

     

       811
       811
       +
       wheels = [

     

       812
       812
       +
           { url = "https://files.pythonhosted.org/packages/5f/ed/539768cf28c661b5b068d66d96a2f155c4971a5d55684a514c1a0e0dec2f/python_dotenv-1.1.1-py3-none-any.whl", hash = "sha256:31f23644fe2602f88ff55e1f5c79ba497e01224ee7737937930c448e4d0e24dc", size = 20556, upload-time = "2025-06-24T04:21:06.073Z" },

     

       813
       813
       +
       ]

     

       814
       814
       +
       

     

       815
       815
       +
       [[package]]

     

       816
       816
       +
       name = "pyyaml"

     

       817
       817
       +
       version = "6.0.2"

     

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

     

       819
       819
       +
       sdist = { url = "https://files.pythonhosted.org/packages/54/ed/79a089b6be93607fa5cdaedf301d7dfb23af5f25c398d5ead2525b063e17/pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e", size = 130631, upload-time = "2024-08-06T20:33:50.674Z" }

     

       820
       820
       +
       wheels = [

     

       821
       821
       +
           { url = "https://files.pythonhosted.org/packages/9b/95/a3fac87cb7158e231b5a6012e438c647e1a87f09f8e0d123acec8ab8bf71/PyYAML-6.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0a9a2848a5b7feac301353437eb7d5957887edbf81d56e903999a75a3d743086", size = 184199, upload-time = "2024-08-06T20:31:40.178Z" },

     

       822
       822
       +
           { url = "https://files.pythonhosted.org/packages/c7/7a/68bd47624dab8fd4afbfd3c48e3b79efe09098ae941de5b58abcbadff5cb/PyYAML-6.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:29717114e51c84ddfba879543fb232a6ed60086602313ca38cce623c1d62cfbf", size = 171758, upload-time = "2024-08-06T20:31:42.173Z" },

     

       823
       823
       +
           { url = "https://files.pythonhosted.org/packages/49/ee/14c54df452143b9ee9f0f29074d7ca5516a36edb0b4cc40c3f280131656f/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8824b5a04a04a047e72eea5cec3bc266db09e35de6bdfe34c9436ac5ee27d237", size = 718463, upload-time = "2024-08-06T20:31:44.263Z" },

     

       824
       824
       +
           { url = "https://files.pythonhosted.org/packages/4d/61/de363a97476e766574650d742205be468921a7b532aa2499fcd886b62530/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c36280e6fb8385e520936c3cb3b8042851904eba0e58d277dca80a5cfed590b", size = 719280, upload-time = "2024-08-06T20:31:50.199Z" },

     

       825
       825
       +
           { url = "https://files.pythonhosted.org/packages/6b/4e/1523cb902fd98355e2e9ea5e5eb237cbc5f3ad5f3075fa65087aa0ecb669/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec031d5d2feb36d1d1a24380e4db6d43695f3748343d99434e6f5f9156aaa2ed", size = 751239, upload-time = "2024-08-06T20:31:52.292Z" },

     

       826
       826
       +
           { url = "https://files.pythonhosted.org/packages/b7/33/5504b3a9a4464893c32f118a9cc045190a91637b119a9c881da1cf6b7a72/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:936d68689298c36b53b29f23c6dbb74de12b4ac12ca6cfe0e047bedceea56180", size = 695802, upload-time = "2024-08-06T20:31:53.836Z" },

     

       827
       827
       +
           { url = "https://files.pythonhosted.org/packages/5c/20/8347dcabd41ef3a3cdc4f7b7a2aff3d06598c8779faa189cdbf878b626a4/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:23502f431948090f597378482b4812b0caae32c22213aecf3b55325e049a6c68", size = 720527, upload-time = "2024-08-06T20:31:55.565Z" },

     

       828
       828
       +
           { url = "https://files.pythonhosted.org/packages/be/aa/5afe99233fb360d0ff37377145a949ae258aaab831bde4792b32650a4378/PyYAML-6.0.2-cp310-cp310-win32.whl", hash = "sha256:2e99c6826ffa974fe6e27cdb5ed0021786b03fc98e5ee3c5bfe1fd5015f42b99", size = 144052, upload-time = "2024-08-06T20:31:56.914Z" },

     

       829
       829
       +
           { url = "https://files.pythonhosted.org/packages/b5/84/0fa4b06f6d6c958d207620fc60005e241ecedceee58931bb20138e1e5776/PyYAML-6.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:a4d3091415f010369ae4ed1fc6b79def9416358877534caf6a0fdd2146c87a3e", size = 161774, upload-time = "2024-08-06T20:31:58.304Z" },

     

       830
       830
       +
           { url = "https://files.pythonhosted.org/packages/f8/aa/7af4e81f7acba21a4c6be026da38fd2b872ca46226673c89a758ebdc4fd2/PyYAML-6.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cc1c1159b3d456576af7a3e4d1ba7e6924cb39de8f67111c735f6fc832082774", size = 184612, upload-time = "2024-08-06T20:32:03.408Z" },

     

       831
       831
       +
           { url = "https://files.pythonhosted.org/packages/8b/62/b9faa998fd185f65c1371643678e4d58254add437edb764a08c5a98fb986/PyYAML-6.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1e2120ef853f59c7419231f3bf4e7021f1b936f6ebd222406c3b60212205d2ee", size = 172040, upload-time = "2024-08-06T20:32:04.926Z" },

     

       832
       832
       +
           { url = "https://files.pythonhosted.org/packages/ad/0c/c804f5f922a9a6563bab712d8dcc70251e8af811fce4524d57c2c0fd49a4/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d225db5a45f21e78dd9358e58a98702a0302f2659a3c6cd320564b75b86f47c", size = 736829, upload-time = "2024-08-06T20:32:06.459Z" },

     

       833
       833
       +
           { url = "https://files.pythonhosted.org/packages/51/16/6af8d6a6b210c8e54f1406a6b9481febf9c64a3109c541567e35a49aa2e7/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5ac9328ec4831237bec75defaf839f7d4564be1e6b25ac710bd1a96321cc8317", size = 764167, upload-time = "2024-08-06T20:32:08.338Z" },

     

       834
       834
       +
           { url = "https://files.pythonhosted.org/packages/75/e4/2c27590dfc9992f73aabbeb9241ae20220bd9452df27483b6e56d3975cc5/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ad2a3decf9aaba3d29c8f537ac4b243e36bef957511b4766cb0057d32b0be85", size = 762952, upload-time = "2024-08-06T20:32:14.124Z" },

     

       835
       835
       +
           { url = "https://files.pythonhosted.org/packages/9b/97/ecc1abf4a823f5ac61941a9c00fe501b02ac3ab0e373c3857f7d4b83e2b6/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:ff3824dc5261f50c9b0dfb3be22b4567a6f938ccce4587b38952d85fd9e9afe4", size = 735301, upload-time = "2024-08-06T20:32:16.17Z" },

     

       836
       836
       +
           { url = "https://files.pythonhosted.org/packages/45/73/0f49dacd6e82c9430e46f4a027baa4ca205e8b0a9dce1397f44edc23559d/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:797b4f722ffa07cc8d62053e4cff1486fa6dc094105d13fea7b1de7d8bf71c9e", size = 756638, upload-time = "2024-08-06T20:32:18.555Z" },

     

       837
       837
       +
           { url = "https://files.pythonhosted.org/packages/22/5f/956f0f9fc65223a58fbc14459bf34b4cc48dec52e00535c79b8db361aabd/PyYAML-6.0.2-cp311-cp311-win32.whl", hash = "sha256:11d8f3dd2b9c1207dcaf2ee0bbbfd5991f571186ec9cc78427ba5bd32afae4b5", size = 143850, upload-time = "2024-08-06T20:32:19.889Z" },

     

       838
       838
       +
           { url = "https://files.pythonhosted.org/packages/ed/23/8da0bbe2ab9dcdd11f4f4557ccaf95c10b9811b13ecced089d43ce59c3c8/PyYAML-6.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:e10ce637b18caea04431ce14fabcf5c64a1c61ec9c56b071a4b7ca131ca52d44", size = 161980, upload-time = "2024-08-06T20:32:21.273Z" },

     

       839
       839
       +
           { url = "https://files.pythonhosted.org/packages/86/0c/c581167fc46d6d6d7ddcfb8c843a4de25bdd27e4466938109ca68492292c/PyYAML-6.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:c70c95198c015b85feafc136515252a261a84561b7b1d51e3384e0655ddf25ab", size = 183873, upload-time = "2024-08-06T20:32:25.131Z" },

     

       840
       840
       +
           { url = "https://files.pythonhosted.org/packages/a8/0c/38374f5bb272c051e2a69281d71cba6fdb983413e6758b84482905e29a5d/PyYAML-6.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce826d6ef20b1bc864f0a68340c8b3287705cae2f8b4b1d932177dcc76721725", size = 173302, upload-time = "2024-08-06T20:32:26.511Z" },

     

       841
       841
       +
           { url = "https://files.pythonhosted.org/packages/c3/93/9916574aa8c00aa06bbac729972eb1071d002b8e158bd0e83a3b9a20a1f7/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f71ea527786de97d1a0cc0eacd1defc0985dcf6b3f17bb77dcfc8c34bec4dc5", size = 739154, upload-time = "2024-08-06T20:32:28.363Z" },

     

       842
       842
       +
           { url = "https://files.pythonhosted.org/packages/95/0f/b8938f1cbd09739c6da569d172531567dbcc9789e0029aa070856f123984/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b22676e8097e9e22e36d6b7bda33190d0d400f345f23d4065d48f4ca7ae0425", size = 766223, upload-time = "2024-08-06T20:32:30.058Z" },

     

       843
       843
       +
           { url = "https://files.pythonhosted.org/packages/b9/2b/614b4752f2e127db5cc206abc23a8c19678e92b23c3db30fc86ab731d3bd/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80bab7bfc629882493af4aa31a4cfa43a4c57c83813253626916b8c7ada83476", size = 767542, upload-time = "2024-08-06T20:32:31.881Z" },

     

       844
       844
       +
           { url = "https://files.pythonhosted.org/packages/d4/00/dd137d5bcc7efea1836d6264f049359861cf548469d18da90cd8216cf05f/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0833f8694549e586547b576dcfaba4a6b55b9e96098b36cdc7ebefe667dfed48", size = 731164, upload-time = "2024-08-06T20:32:37.083Z" },

     

       845
       845
       +
           { url = "https://files.pythonhosted.org/packages/c9/1f/4f998c900485e5c0ef43838363ba4a9723ac0ad73a9dc42068b12aaba4e4/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8b9c7197f7cb2738065c481a0461e50ad02f18c78cd75775628afb4d7137fb3b", size = 756611, upload-time = "2024-08-06T20:32:38.898Z" },

     

       846
       846
       +
           { url = "https://files.pythonhosted.org/packages/df/d1/f5a275fdb252768b7a11ec63585bc38d0e87c9e05668a139fea92b80634c/PyYAML-6.0.2-cp312-cp312-win32.whl", hash = "sha256:ef6107725bd54b262d6dedcc2af448a266975032bc85ef0172c5f059da6325b4", size = 140591, upload-time = "2024-08-06T20:32:40.241Z" },

     

       847
       847
       +
           { url = "https://files.pythonhosted.org/packages/0c/e8/4f648c598b17c3d06e8753d7d13d57542b30d56e6c2dedf9c331ae56312e/PyYAML-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:7e7401d0de89a9a855c839bc697c079a4af81cf878373abd7dc625847d25cbd8", size = 156338, upload-time = "2024-08-06T20:32:41.93Z" },

     

       848
       848
       +
           { url = "https://files.pythonhosted.org/packages/ef/e3/3af305b830494fa85d95f6d95ef7fa73f2ee1cc8ef5b495c7c3269fb835f/PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efdca5630322a10774e8e98e1af481aad470dd62c3170801852d752aa7a783ba", size = 181309, upload-time = "2024-08-06T20:32:43.4Z" },

     

       849
       849
       +
           { url = "https://files.pythonhosted.org/packages/45/9f/3b1c20a0b7a3200524eb0076cc027a970d320bd3a6592873c85c92a08731/PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:50187695423ffe49e2deacb8cd10510bc361faac997de9efef88badc3bb9e2d1", size = 171679, upload-time = "2024-08-06T20:32:44.801Z" },

     

       850
       850
       +
           { url = "https://files.pythonhosted.org/packages/7c/9a/337322f27005c33bcb656c655fa78325b730324c78620e8328ae28b64d0c/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ffe8360bab4910ef1b9e87fb812d8bc0a308b0d0eef8c8f44e0254ab3b07133", size = 733428, upload-time = "2024-08-06T20:32:46.432Z" },

     

       851
       851
       +
           { url = "https://files.pythonhosted.org/packages/a3/69/864fbe19e6c18ea3cc196cbe5d392175b4cf3d5d0ac1403ec3f2d237ebb5/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:17e311b6c678207928d649faa7cb0d7b4c26a0ba73d41e99c4fff6b6c3276484", size = 763361, upload-time = "2024-08-06T20:32:51.188Z" },

     

       852
       852
       +
           { url = "https://files.pythonhosted.org/packages/04/24/b7721e4845c2f162d26f50521b825fb061bc0a5afcf9a386840f23ea19fa/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70b189594dbe54f75ab3a1acec5f1e3faa7e8cf2f1e08d9b561cb41b845f69d5", size = 759523, upload-time = "2024-08-06T20:32:53.019Z" },

     

       853
       853
       +
           { url = "https://files.pythonhosted.org/packages/2b/b2/e3234f59ba06559c6ff63c4e10baea10e5e7df868092bf9ab40e5b9c56b6/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:41e4e3953a79407c794916fa277a82531dd93aad34e29c2a514c2c0c5fe971cc", size = 726660, upload-time = "2024-08-06T20:32:54.708Z" },

     

       854
       854
       +
           { url = "https://files.pythonhosted.org/packages/fe/0f/25911a9f080464c59fab9027482f822b86bf0608957a5fcc6eaac85aa515/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:68ccc6023a3400877818152ad9a1033e3db8625d899c72eacb5a668902e4d652", size = 751597, upload-time = "2024-08-06T20:32:56.985Z" },

     

       855
       855
       +
           { url = "https://files.pythonhosted.org/packages/14/0d/e2c3b43bbce3cf6bd97c840b46088a3031085179e596d4929729d8d68270/PyYAML-6.0.2-cp313-cp313-win32.whl", hash = "sha256:bc2fa7c6b47d6bc618dd7fb02ef6fdedb1090ec036abab80d4681424b84c1183", size = 140527, upload-time = "2024-08-06T20:33:03.001Z" },

     

       856
       856
       +
           { url = "https://files.pythonhosted.org/packages/fa/de/02b54f42487e3d3c6efb3f89428677074ca7bf43aae402517bc7cca949f3/PyYAML-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563", size = 156446, upload-time = "2024-08-06T20:33:04.33Z" },

     

       857
       857
       +
           { url = "https://files.pythonhosted.org/packages/65/d8/b7a1db13636d7fb7d4ff431593c510c8b8fca920ade06ca8ef20015493c5/PyYAML-6.0.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:688ba32a1cffef67fd2e9398a2efebaea461578b0923624778664cc1c914db5d", size = 184777, upload-time = "2024-08-06T20:33:25.896Z" },

     

       858
       858
       +
           { url = "https://files.pythonhosted.org/packages/0a/02/6ec546cd45143fdf9840b2c6be8d875116a64076218b61d68e12548e5839/PyYAML-6.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a8786accb172bd8afb8be14490a16625cbc387036876ab6ba70912730faf8e1f", size = 172318, upload-time = "2024-08-06T20:33:27.212Z" },

     

       859
       859
       +
           { url = "https://files.pythonhosted.org/packages/0e/9a/8cc68be846c972bda34f6c2a93abb644fb2476f4dcc924d52175786932c9/PyYAML-6.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8e03406cac8513435335dbab54c0d385e4a49e4945d2909a581c83647ca0290", size = 720891, upload-time = "2024-08-06T20:33:28.974Z" },

     

       860
       860
       +
           { url = "https://files.pythonhosted.org/packages/e9/6c/6e1b7f40181bc4805e2e07f4abc10a88ce4648e7e95ff1abe4ae4014a9b2/PyYAML-6.0.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f753120cb8181e736c57ef7636e83f31b9c0d1722c516f7e86cf15b7aa57ff12", size = 722614, upload-time = "2024-08-06T20:33:34.157Z" },

     

       861
       861
       +
           { url = "https://files.pythonhosted.org/packages/3d/32/e7bd8535d22ea2874cef6a81021ba019474ace0d13a4819c2a4bce79bd6a/PyYAML-6.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3b1fdb9dc17f5a7677423d508ab4f243a726dea51fa5e70992e59a7411c89d19", size = 737360, upload-time = "2024-08-06T20:33:35.84Z" },

     

       862
       862
       +
           { url = "https://files.pythonhosted.org/packages/d7/12/7322c1e30b9be969670b672573d45479edef72c9a0deac3bb2868f5d7469/PyYAML-6.0.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:0b69e4ce7a131fe56b7e4d770c67429700908fc0752af059838b1cfb41960e4e", size = 699006, upload-time = "2024-08-06T20:33:37.501Z" },

     

       863
       863
       +
           { url = "https://files.pythonhosted.org/packages/82/72/04fcad41ca56491995076630c3ec1e834be241664c0c09a64c9a2589b507/PyYAML-6.0.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:a9f8c2e67970f13b16084e04f134610fd1d374bf477b17ec1599185cf611d725", size = 723577, upload-time = "2024-08-06T20:33:39.389Z" },

     

       864
       864
       +
           { url = "https://files.pythonhosted.org/packages/ed/5e/46168b1f2757f1fcd442bc3029cd8767d88a98c9c05770d8b420948743bb/PyYAML-6.0.2-cp39-cp39-win32.whl", hash = "sha256:6395c297d42274772abc367baaa79683958044e5d3835486c16da75d2a694631", size = 144593, upload-time = "2024-08-06T20:33:46.63Z" },

     

       865
       865
       +
           { url = "https://files.pythonhosted.org/packages/19/87/5124b1c1f2412bb95c59ec481eaf936cd32f0fe2a7b16b97b81c4c017a6a/PyYAML-6.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:39693e1f8320ae4f43943590b49779ffb98acb81f788220ea932a6b6c51004d8", size = 162312, upload-time = "2024-08-06T20:33:49.073Z" },

     

       866
       866
       +
       ]

     

       867
       867
       +
       

     

       868
       868
       +
       [[package]]

     

       869
       869
       +
       name = "rich"

     

       870
       870
       +
       version = "14.0.0"

     

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

     

       872
       872
       +
       dependencies = [

     

       873
       873
       +
           { name = "markdown-it-py" },

     

       874
       874
       +
           { name = "pygments" },

     

       875
       875
       +
           { name = "typing-extensions", marker = "python_full_version < '3.11'" },

     

       876
       876
       +
       ]

     

       877
       877
       +
       sdist = { url = "https://files.pythonhosted.org/packages/a1/53/830aa4c3066a8ab0ae9a9955976fb770fe9c6102117c8ec4ab3ea62d89e8/rich-14.0.0.tar.gz", hash = "sha256:82f1bc23a6a21ebca4ae0c45af9bdbc492ed20231dcb63f297d6d1021a9d5725", size = 224078, upload-time = "2025-03-30T14:15:14.23Z" }

     

       878
       878
       +
       wheels = [

     

       879
       879
       +
           { url = "https://files.pythonhosted.org/packages/0d/9b/63f4c7ebc259242c89b3acafdb37b41d1185c07ff0011164674e9076b491/rich-14.0.0-py3-none-any.whl", hash = "sha256:1c9491e1951aac09caffd42f448ee3d04e58923ffe14993f6e83068dc395d7e0", size = 243229, upload-time = "2025-03-30T14:15:12.283Z" },

     

       880
       880
       +
       ]

     

       881
       881
       +
       

     

       882
       882
       +
       [[package]]

     

       883
       883
       +
       name = "ruff"

     

       884
       884
       +
       version = "0.12.3"

     

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

     

       886
       886
       +
       sdist = { url = "https://files.pythonhosted.org/packages/c3/2a/43955b530c49684d3c38fcda18c43caf91e99204c2a065552528e0552d4f/ruff-0.12.3.tar.gz", hash = "sha256:f1b5a4b6668fd7b7ea3697d8d98857390b40c1320a63a178eee6be0899ea2d77", size = 4459341, upload-time = "2025-07-11T13:21:16.086Z" }

     

       887
       887
       +
       wheels = [

     

       888
       888
       +
           { url = "https://files.pythonhosted.org/packages/e2/fd/b44c5115539de0d598d75232a1cc7201430b6891808df111b8b0506aae43/ruff-0.12.3-py3-none-linux_armv6l.whl", hash = "sha256:47552138f7206454eaf0c4fe827e546e9ddac62c2a3d2585ca54d29a890137a2", size = 10430499, upload-time = "2025-07-11T13:20:26.321Z" },

     

       889
       889
       +
           { url = "https://files.pythonhosted.org/packages/43/c5/9eba4f337970d7f639a37077be067e4ec80a2ad359e4cc6c5b56805cbc66/ruff-0.12.3-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:0a9153b000c6fe169bb307f5bd1b691221c4286c133407b8827c406a55282041", size = 11213413, upload-time = "2025-07-11T13:20:30.017Z" },

     

       890
       890
       +
           { url = "https://files.pythonhosted.org/packages/e2/2c/fac3016236cf1fe0bdc8e5de4f24c76ce53c6dd9b5f350d902549b7719b2/ruff-0.12.3-py3-none-macosx_11_0_arm64.whl", hash = "sha256:fa6b24600cf3b750e48ddb6057e901dd5b9aa426e316addb2a1af185a7509882", size = 10586941, upload-time = "2025-07-11T13:20:33.046Z" },

     

       891
       891
       +
           { url = "https://files.pythonhosted.org/packages/c5/0f/41fec224e9dfa49a139f0b402ad6f5d53696ba1800e0f77b279d55210ca9/ruff-0.12.3-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e2506961bf6ead54887ba3562604d69cb430f59b42133d36976421bc8bd45901", size = 10783001, upload-time = "2025-07-11T13:20:35.534Z" },

     

       892
       892
       +
           { url = "https://files.pythonhosted.org/packages/0d/ca/dd64a9ce56d9ed6cad109606ac014860b1c217c883e93bf61536400ba107/ruff-0.12.3-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c4faaff1f90cea9d3033cbbcdf1acf5d7fb11d8180758feb31337391691f3df0", size = 10269641, upload-time = "2025-07-11T13:20:38.459Z" },

     

       893
       893
       +
           { url = "https://files.pythonhosted.org/packages/63/5c/2be545034c6bd5ce5bb740ced3e7014d7916f4c445974be11d2a406d5088/ruff-0.12.3-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40dced4a79d7c264389de1c59467d5d5cefd79e7e06d1dfa2c75497b5269a5a6", size = 11875059, upload-time = "2025-07-11T13:20:41.517Z" },

     

       894
       894
       +
           { url = "https://files.pythonhosted.org/packages/8e/d4/a74ef1e801ceb5855e9527dae105eaff136afcb9cc4d2056d44feb0e4792/ruff-0.12.3-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:0262d50ba2767ed0fe212aa7e62112a1dcbfd46b858c5bf7bbd11f326998bafc", size = 12658890, upload-time = "2025-07-11T13:20:44.442Z" },

     

       895
       895
       +
           { url = "https://files.pythonhosted.org/packages/13/c8/1057916416de02e6d7c9bcd550868a49b72df94e3cca0aeb77457dcd9644/ruff-0.12.3-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:12371aec33e1a3758597c5c631bae9a5286f3c963bdfb4d17acdd2d395406687", size = 12232008, upload-time = "2025-07-11T13:20:47.374Z" },

     

       896
       896
       +
           { url = "https://files.pythonhosted.org/packages/f5/59/4f7c130cc25220392051fadfe15f63ed70001487eca21d1796db46cbcc04/ruff-0.12.3-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:560f13b6baa49785665276c963edc363f8ad4b4fc910a883e2625bdb14a83a9e", size = 11499096, upload-time = "2025-07-11T13:20:50.348Z" },

     

       897
       897
       +
           { url = "https://files.pythonhosted.org/packages/d4/01/a0ad24a5d2ed6be03a312e30d32d4e3904bfdbc1cdbe63c47be9d0e82c79/ruff-0.12.3-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:023040a3499f6f974ae9091bcdd0385dd9e9eb4942f231c23c57708147b06311", size = 11688307, upload-time = "2025-07-11T13:20:52.945Z" },

     

       898
       898
       +
           { url = "https://files.pythonhosted.org/packages/93/72/08f9e826085b1f57c9a0226e48acb27643ff19b61516a34c6cab9d6ff3fa/ruff-0.12.3-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:883d844967bffff5ab28bba1a4d246c1a1b2933f48cb9840f3fdc5111c603b07", size = 10661020, upload-time = "2025-07-11T13:20:55.799Z" },

     

       899
       899
       +
           { url = "https://files.pythonhosted.org/packages/80/a0/68da1250d12893466c78e54b4a0ff381370a33d848804bb51279367fc688/ruff-0.12.3-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:2120d3aa855ff385e0e562fdee14d564c9675edbe41625c87eeab744a7830d12", size = 10246300, upload-time = "2025-07-11T13:20:58.222Z" },

     

       900
       900
       +
           { url = "https://files.pythonhosted.org/packages/6a/22/5f0093d556403e04b6fd0984fc0fb32fbb6f6ce116828fd54306a946f444/ruff-0.12.3-py3-none-musllinux_1_2_i686.whl", hash = "sha256:6b16647cbb470eaf4750d27dddc6ebf7758b918887b56d39e9c22cce2049082b", size = 11263119, upload-time = "2025-07-11T13:21:01.503Z" },

     

       901
       901
       +
           { url = "https://files.pythonhosted.org/packages/92/c9/f4c0b69bdaffb9968ba40dd5fa7df354ae0c73d01f988601d8fac0c639b1/ruff-0.12.3-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:e1417051edb436230023575b149e8ff843a324557fe0a265863b7602df86722f", size = 11746990, upload-time = "2025-07-11T13:21:04.524Z" },

     

       902
       902
       +
           { url = "https://files.pythonhosted.org/packages/fe/84/7cc7bd73924ee6be4724be0db5414a4a2ed82d06b30827342315a1be9e9c/ruff-0.12.3-py3-none-win32.whl", hash = "sha256:dfd45e6e926deb6409d0616078a666ebce93e55e07f0fb0228d4b2608b2c248d", size = 10589263, upload-time = "2025-07-11T13:21:07.148Z" },

     

       903
       903
       +
           { url = "https://files.pythonhosted.org/packages/07/87/c070f5f027bd81f3efee7d14cb4d84067ecf67a3a8efb43aadfc72aa79a6/ruff-0.12.3-py3-none-win_amd64.whl", hash = "sha256:a946cf1e7ba3209bdef039eb97647f1c77f6f540e5845ec9c114d3af8df873e7", size = 11695072, upload-time = "2025-07-11T13:21:11.004Z" },

     

       904
       904
       +
           { url = "https://files.pythonhosted.org/packages/e0/30/f3eaf6563c637b6e66238ed6535f6775480db973c836336e4122161986fc/ruff-0.12.3-py3-none-win_arm64.whl", hash = "sha256:5f9c7c9c8f84c2d7f27e93674d27136fbf489720251544c4da7fb3d742e011b1", size = 10805855, upload-time = "2025-07-11T13:21:13.547Z" },

     

       905
       905
       +
       ]

     

       906
       906
       +
       

     

       907
       907
       +
       [[package]]

     

       908
       908
       +
       name = "sgmllib3k"

     

       909
       909
       +
       version = "1.0.0"

     

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

     

       911
       911
       +
       sdist = { url = "https://files.pythonhosted.org/packages/9e/bd/3704a8c3e0942d711c1299ebf7b9091930adae6675d7c8f476a7ce48653c/sgmllib3k-1.0.0.tar.gz", hash = "sha256:7868fb1c8bfa764c1ac563d3cf369c381d1325d36124933a726f29fcdaa812e9", size = 5750, upload-time = "2010-08-24T14:33:52.445Z" }

     

       912
       912
       +
       

     

       913
       913
       +
       [[package]]

     

       914
       914
       +
       name = "shellingham"

     

       915
       915
       +
       version = "1.5.4"

     

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

     

       917
       917
       +
       sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de", size = 10310, upload-time = "2023-10-24T04:13:40.426Z" }

     

       918
       918
       +
       wheels = [

     

       919
       919
       +
           { url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755, upload-time = "2023-10-24T04:13:38.866Z" },

     

       920
       920
       +
       ]

     

       921
       921
       +
       

     

       922
       922
       +
       [[package]]

     

       923
       923
       +
       name = "six"

     

       924
       924
       +
       version = "1.17.0"

     

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

     

       926
       926
       +
       sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" }

     

       927
       927
       +
       wheels = [

     

       928
       928
       +
           { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },

     

       929
       929
       +
       ]

     

       930
       930
       +
       

     

       931
       931
       +
       [[package]]

     

       932
       932
       +
       name = "smmap"

     

       933
       933
       +
       version = "5.0.2"

     

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

     

       935
       935
       +
       sdist = { url = "https://files.pythonhosted.org/packages/44/cd/a040c4b3119bbe532e5b0732286f805445375489fceaec1f48306068ee3b/smmap-5.0.2.tar.gz", hash = "sha256:26ea65a03958fa0c8a1c7e8c7a58fdc77221b8910f6be2131affade476898ad5", size = 22329, upload-time = "2025-01-02T07:14:40.909Z" }

     

       936
       936
       +
       wheels = [

     

       937
       937
       +
           { url = "https://files.pythonhosted.org/packages/04/be/d09147ad1ec7934636ad912901c5fd7667e1c858e19d355237db0d0cd5e4/smmap-5.0.2-py3-none-any.whl", hash = "sha256:b30115f0def7d7531d22a0fb6502488d879e75b260a9db4d0819cfb25403af5e", size = 24303, upload-time = "2025-01-02T07:14:38.724Z" },

     

       938
       938
       +
       ]

     

       939
       939
       +
       

     

       940
       940
       +
       [[package]]

     

       941
       941
       +
       name = "sniffio"

     

       942
       942
       +
       version = "1.3.1"

     

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

     

       944
       944
       +
       sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" }

     

       945
       945
       +
       wheels = [

     

       946
       946
       +
           { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" },

     

       947
       947
       +
       ]

     

       948
       948
       +
       

     

       949
       949
       +
       [[package]]

     

       950
       950
       +
       name = "thicket"

     

       951
       951
       +
       source = { editable = "." }

     

       952
       952
       +
       dependencies = [

     

       953
       953
       +
           { name = "bleach" },

     

       954
       954
       +
           { name = "email-validator" },

     

       955
       955
       +
           { name = "feedparser" },

     

       956
       956
       +
           { name = "gitpython" },

     

       957
       957
       +
           { name = "httpx" },

     

       958
       958
       +
           { name = "jinja2" },

     

       959
       959
       +
           { name = "pendulum" },

     

       960
       960
       +
           { name = "platformdirs" },

     

       961
       961
       +
           { name = "pydantic" },

     

       962
       962
       +
           { name = "pydantic-settings" },

     

       963
       963
       +
           { name = "pyyaml" },

     

       964
       964
       +
           { name = "rich" },

     

       965
       965
       +
           { name = "typer" },

     

       966
       966
       +
       ]

     

       967
       967
       +
       

     

       968
       968
       +
       [package.optional-dependencies]

     

       969
       969
       +
       dev = [

     

       970
       970
       +
           { name = "black" },

     

       971
       971
       +
           { name = "mypy" },

     

       972
       972
       +
           { name = "pytest" },

     

       973
       973
       +
           { name = "pytest-asyncio" },

     

       974
       974
       +
           { name = "pytest-cov" },

     

       975
       975
       +
           { name = "ruff" },

     

       976
       976
       +
           { name = "types-pyyaml" },

     

       977
       977
       +
       ]

     

       978
       978
       +
       

     

       979
       979
       +
       [package.metadata]

     

       980
       980
       +
       requires-dist = [

     

       981
       981
       +
           { name = "black", marker = "extra == 'dev'", specifier = ">=24.0.0" },

     

       982
       982
       +
           { name = "bleach", specifier = ">=6.0.0" },

     

       983
       983
       +
           { name = "email-validator" },

     

       984
       984
       +
           { name = "feedparser", specifier = ">=6.0.11" },

     

       985
       985
       +
           { name = "gitpython", specifier = ">=3.1.40" },

     

       986
       986
       +
           { name = "httpx", specifier = ">=0.28.0" },

     

       987
       987
       +
           { name = "jinja2", specifier = ">=3.1.6" },

     

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

     

       989
       989
       +
           { name = "pendulum", specifier = ">=3.0.0" },

     

       990
       990
       +
           { name = "platformdirs", specifier = ">=4.0.0" },

     

       991
       991
       +
           { name = "pydantic", specifier = ">=2.11.0" },

     

       992
       992
       +
           { name = "pydantic-settings", specifier = ">=2.10.0" },

     

       993
       993
       +
           { name = "pytest", marker = "extra == 'dev'", specifier = ">=8.0.0" },

     

       994
       994
       +
           { name = "pytest-asyncio", marker = "extra == 'dev'", specifier = ">=0.24.0" },

     

       995
       995
       +
           { name = "pytest-cov", marker = "extra == 'dev'", specifier = ">=6.0.0" },

     

       996
       996
       +
           { name = "pyyaml", specifier = ">=6.0.0" },

     

       997
       997
       +
           { name = "rich", specifier = ">=13.0.0" },

     

       998
       998
       +
           { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.8.0" },

     

       999
       999
       +
           { name = "typer", specifier = ">=0.15.0" },

     

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

     

       1001
       1001
       +
       ]

     

       1002
       1002
       +
       provides-extras = ["dev"]

     

       1003
       1003
       +
       

     

       1004
       1004
       +
       [[package]]

     

       1005
       1005
       +
       name = "tomli"

     

       1006
       1006
       +
       version = "2.2.1"

     

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

     

       1008
       1008
       +
       sdist = { url = "https://files.pythonhosted.org/packages/18/87/302344fed471e44a87289cf4967697d07e532f2421fdaf868a303cbae4ff/tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff", size = 17175, upload-time = "2024-11-27T22:38:36.873Z" }

     

       1009
       1009
       +
       wheels = [

     

       1010
       1010
       +
           { url = "https://files.pythonhosted.org/packages/43/ca/75707e6efa2b37c77dadb324ae7d9571cb424e61ea73fad7c56c2d14527f/tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249", size = 131077, upload-time = "2024-11-27T22:37:54.956Z" },

     

       1011
       1011
       +
           { url = "https://files.pythonhosted.org/packages/c7/16/51ae563a8615d472fdbffc43a3f3d46588c264ac4f024f63f01283becfbb/tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6", size = 123429, upload-time = "2024-11-27T22:37:56.698Z" },

     

       1012
       1012
       +
           { url = "https://files.pythonhosted.org/packages/f1/dd/4f6cd1e7b160041db83c694abc78e100473c15d54620083dbd5aae7b990e/tomli-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece47d672db52ac607a3d9599a9d48dcb2f2f735c6c2d1f34130085bb12b112a", size = 226067, upload-time = "2024-11-27T22:37:57.63Z" },

     

       1013
       1013
       +
           { url = "https://files.pythonhosted.org/packages/a9/6b/c54ede5dc70d648cc6361eaf429304b02f2871a345bbdd51e993d6cdf550/tomli-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee", size = 236030, upload-time = "2024-11-27T22:37:59.344Z" },

     

       1014
       1014
       +
           { url = "https://files.pythonhosted.org/packages/1f/47/999514fa49cfaf7a92c805a86c3c43f4215621855d151b61c602abb38091/tomli-2.2.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c954d2250168d28797dd4e3ac5cf812a406cd5a92674ee4c8f123c889786aa8e", size = 240898, upload-time = "2024-11-27T22:38:00.429Z" },

     

       1015
       1015
       +
           { url = "https://files.pythonhosted.org/packages/73/41/0a01279a7ae09ee1573b423318e7934674ce06eb33f50936655071d81a24/tomli-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8dd28b3e155b80f4d54beb40a441d366adcfe740969820caf156c019fb5c7ec4", size = 229894, upload-time = "2024-11-27T22:38:02.094Z" },

     

       1016
       1016
       +
           { url = "https://files.pythonhosted.org/packages/55/18/5d8bc5b0a0362311ce4d18830a5d28943667599a60d20118074ea1b01bb7/tomli-2.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e59e304978767a54663af13c07b3d1af22ddee3bb2fb0618ca1593e4f593a106", size = 245319, upload-time = "2024-11-27T22:38:03.206Z" },

     

       1017
       1017
       +
           { url = "https://files.pythonhosted.org/packages/92/a3/7ade0576d17f3cdf5ff44d61390d4b3febb8a9fc2b480c75c47ea048c646/tomli-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:33580bccab0338d00994d7f16f4c4ec25b776af3ffaac1ed74e0b3fc95e885a8", size = 238273, upload-time = "2024-11-27T22:38:04.217Z" },

     

       1018
       1018
       +
           { url = "https://files.pythonhosted.org/packages/72/6f/fa64ef058ac1446a1e51110c375339b3ec6be245af9d14c87c4a6412dd32/tomli-2.2.1-cp311-cp311-win32.whl", hash = "sha256:465af0e0875402f1d226519c9904f37254b3045fc5084697cefb9bdde1ff99ff", size = 98310, upload-time = "2024-11-27T22:38:05.908Z" },

     

       1019
       1019
       +
           { url = "https://files.pythonhosted.org/packages/6a/1c/4a2dcde4a51b81be3530565e92eda625d94dafb46dbeb15069df4caffc34/tomli-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2d0f2fdd22b02c6d81637a3c95f8cd77f995846af7414c5c4b8d0545afa1bc4b", size = 108309, upload-time = "2024-11-27T22:38:06.812Z" },

     

       1020
       1020
       +
           { url = "https://files.pythonhosted.org/packages/52/e1/f8af4c2fcde17500422858155aeb0d7e93477a0d59a98e56cbfe75070fd0/tomli-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a8f6e44de52d5e6c657c9fe83b562f5f4256d8ebbfe4ff922c495620a7f6cea", size = 132762, upload-time = "2024-11-27T22:38:07.731Z" },

     

       1021
       1021
       +
           { url = "https://files.pythonhosted.org/packages/03/b8/152c68bb84fc00396b83e7bbddd5ec0bd3dd409db4195e2a9b3e398ad2e3/tomli-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8", size = 123453, upload-time = "2024-11-27T22:38:09.384Z" },

     

       1022
       1022
       +
           { url = "https://files.pythonhosted.org/packages/c8/d6/fc9267af9166f79ac528ff7e8c55c8181ded34eb4b0e93daa767b8841573/tomli-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e340144ad7ae1533cb897d406382b4b6fede8890a03738ff1683af800d54192", size = 233486, upload-time = "2024-11-27T22:38:10.329Z" },

     

       1023
       1023
       +
           { url = "https://files.pythonhosted.org/packages/5c/51/51c3f2884d7bab89af25f678447ea7d297b53b5a3b5730a7cb2ef6069f07/tomli-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222", size = 242349, upload-time = "2024-11-27T22:38:11.443Z" },

     

       1024
       1024
       +
           { url = "https://files.pythonhosted.org/packages/ab/df/bfa89627d13a5cc22402e441e8a931ef2108403db390ff3345c05253935e/tomli-2.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40741994320b232529c802f8bc86da4e1aa9f413db394617b9a256ae0f9a7f77", size = 252159, upload-time = "2024-11-27T22:38:13.099Z" },

     

       1025
       1025
       +
           { url = "https://files.pythonhosted.org/packages/9e/6e/fa2b916dced65763a5168c6ccb91066f7639bdc88b48adda990db10c8c0b/tomli-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:400e720fe168c0f8521520190686ef8ef033fb19fc493da09779e592861b78c6", size = 237243, upload-time = "2024-11-27T22:38:14.766Z" },

     

       1026
       1026
       +
           { url = "https://files.pythonhosted.org/packages/b4/04/885d3b1f650e1153cbb93a6a9782c58a972b94ea4483ae4ac5cedd5e4a09/tomli-2.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:02abe224de6ae62c19f090f68da4e27b10af2b93213d36cf44e6e1c5abd19fdd", size = 259645, upload-time = "2024-11-27T22:38:15.843Z" },

     

       1027
       1027
       +
           { url = "https://files.pythonhosted.org/packages/9c/de/6b432d66e986e501586da298e28ebeefd3edc2c780f3ad73d22566034239/tomli-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b82ebccc8c8a36f2094e969560a1b836758481f3dc360ce9a3277c65f374285e", size = 244584, upload-time = "2024-11-27T22:38:17.645Z" },

     

       1028
       1028
       +
           { url = "https://files.pythonhosted.org/packages/1c/9a/47c0449b98e6e7d1be6cbac02f93dd79003234ddc4aaab6ba07a9a7482e2/tomli-2.2.1-cp312-cp312-win32.whl", hash = "sha256:889f80ef92701b9dbb224e49ec87c645ce5df3fa2cc548664eb8a25e03127a98", size = 98875, upload-time = "2024-11-27T22:38:19.159Z" },

     

       1029
       1029
       +
           { url = "https://files.pythonhosted.org/packages/ef/60/9b9638f081c6f1261e2688bd487625cd1e660d0a85bd469e91d8db969734/tomli-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:7fc04e92e1d624a4a63c76474610238576942d6b8950a2d7f908a340494e67e4", size = 109418, upload-time = "2024-11-27T22:38:20.064Z" },

     

       1030
       1030
       +
           { url = "https://files.pythonhosted.org/packages/04/90/2ee5f2e0362cb8a0b6499dc44f4d7d48f8fff06d28ba46e6f1eaa61a1388/tomli-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f4039b9cbc3048b2416cc57ab3bda989a6fcf9b36cf8937f01a6e731b64f80d7", size = 132708, upload-time = "2024-11-27T22:38:21.659Z" },

     

       1031
       1031
       +
           { url = "https://files.pythonhosted.org/packages/c0/ec/46b4108816de6b385141f082ba99e315501ccd0a2ea23db4a100dd3990ea/tomli-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:286f0ca2ffeeb5b9bd4fcc8d6c330534323ec51b2f52da063b11c502da16f30c", size = 123582, upload-time = "2024-11-27T22:38:22.693Z" },

     

       1032
       1032
       +
           { url = "https://files.pythonhosted.org/packages/a0/bd/b470466d0137b37b68d24556c38a0cc819e8febe392d5b199dcd7f578365/tomli-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a92ef1a44547e894e2a17d24e7557a5e85a9e1d0048b0b5e7541f76c5032cb13", size = 232543, upload-time = "2024-11-27T22:38:24.367Z" },

     

       1033
       1033
       +
           { url = "https://files.pythonhosted.org/packages/d9/e5/82e80ff3b751373f7cead2815bcbe2d51c895b3c990686741a8e56ec42ab/tomli-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9316dc65bed1684c9a98ee68759ceaed29d229e985297003e494aa825ebb0281", size = 241691, upload-time = "2024-11-27T22:38:26.081Z" },

     

       1034
       1034
       +
           { url = "https://files.pythonhosted.org/packages/05/7e/2a110bc2713557d6a1bfb06af23dd01e7dde52b6ee7dadc589868f9abfac/tomli-2.2.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e85e99945e688e32d5a35c1ff38ed0b3f41f43fad8df0bdf79f72b2ba7bc5272", size = 251170, upload-time = "2024-11-27T22:38:27.921Z" },

     

       1035
       1035
       +
           { url = "https://files.pythonhosted.org/packages/64/7b/22d713946efe00e0adbcdfd6d1aa119ae03fd0b60ebed51ebb3fa9f5a2e5/tomli-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ac065718db92ca818f8d6141b5f66369833d4a80a9d74435a268c52bdfa73140", size = 236530, upload-time = "2024-11-27T22:38:29.591Z" },

     

       1036
       1036
       +
           { url = "https://files.pythonhosted.org/packages/38/31/3a76f67da4b0cf37b742ca76beaf819dca0ebef26d78fc794a576e08accf/tomli-2.2.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d920f33822747519673ee656a4b6ac33e382eca9d331c87770faa3eef562aeb2", size = 258666, upload-time = "2024-11-27T22:38:30.639Z" },

     

       1037
       1037
       +
           { url = "https://files.pythonhosted.org/packages/07/10/5af1293da642aded87e8a988753945d0cf7e00a9452d3911dd3bb354c9e2/tomli-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a198f10c4d1b1375d7687bc25294306e551bf1abfa4eace6650070a5c1ae2744", size = 243954, upload-time = "2024-11-27T22:38:31.702Z" },

     

       1038
       1038
       +
           { url = "https://files.pythonhosted.org/packages/5b/b9/1ed31d167be802da0fc95020d04cd27b7d7065cc6fbefdd2f9186f60d7bd/tomli-2.2.1-cp313-cp313-win32.whl", hash = "sha256:d3f5614314d758649ab2ab3a62d4f2004c825922f9e370b29416484086b264ec", size = 98724, upload-time = "2024-11-27T22:38:32.837Z" },

     

       1039
       1039
       +
           { url = "https://files.pythonhosted.org/packages/c7/32/b0963458706accd9afcfeb867c0f9175a741bf7b19cd424230714d722198/tomli-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:a38aa0308e754b0e3c67e344754dff64999ff9b513e691d0e786265c93583c69", size = 109383, upload-time = "2024-11-27T22:38:34.455Z" },

     

       1040
       1040
       +
           { url = "https://files.pythonhosted.org/packages/6e/c2/61d3e0f47e2b74ef40a68b9e6ad5984f6241a942f7cd3bbfbdbd03861ea9/tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc", size = 14257, upload-time = "2024-11-27T22:38:35.385Z" },

     

       1041
       1041
       +
       ]

     

       1042
       1042
       +
       

     

       1043
       1043
       +
       [[package]]

     

       1044
       1044
       +
       name = "typer"

     

       1045
       1045
       +
       version = "0.16.0"

     

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

     

       1047
       1047
       +
       dependencies = [

     

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

     

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

     

       1050
       1050
       +
           { name = "rich" },

     

       1051
       1051
       +
           { name = "shellingham" },

     

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

     

       1053
       1053
       +
       ]

     

       1054
       1054
       +
       sdist = { url = "https://files.pythonhosted.org/packages/c5/8c/7d682431efca5fd290017663ea4588bf6f2c6aad085c7f108c5dbc316e70/typer-0.16.0.tar.gz", hash = "sha256:af377ffaee1dbe37ae9440cb4e8f11686ea5ce4e9bae01b84ae7c63b87f1dd3b", size = 102625, upload-time = "2025-05-26T14:30:31.824Z" }

     

       1055
       1055
       +
       wheels = [

     

       1056
       1056
       +
           { url = "https://files.pythonhosted.org/packages/76/42/3efaf858001d2c2913de7f354563e3a3a2f0decae3efe98427125a8f441e/typer-0.16.0-py3-none-any.whl", hash = "sha256:1f79bed11d4d02d4310e3c1b7ba594183bcedb0ac73b27a9e5f28f6fb5b98855", size = 46317, upload-time = "2025-05-26T14:30:30.523Z" },

     

       1057
       1057
       +
       ]

     

       1058
       1058
       +
       

     

       1059
       1059
       +
       [[package]]

     

       1060
       1060
       +
       name = "types-pyyaml"

     

       1061
       1061
       +
       version = "6.0.12.20250516"

     

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

     

       1063
       1063
       +
       sdist = { url = "https://files.pythonhosted.org/packages/4e/22/59e2aeb48ceeee1f7cd4537db9568df80d62bdb44a7f9e743502ea8aab9c/types_pyyaml-6.0.12.20250516.tar.gz", hash = "sha256:9f21a70216fc0fa1b216a8176db5f9e0af6eb35d2f2932acb87689d03a5bf6ba", size = 17378, upload-time = "2025-05-16T03:08:04.897Z" }

     

       1064
       1064
       +
       wheels = [

     

       1065
       1065
       +
           { url = "https://files.pythonhosted.org/packages/99/5f/e0af6f7f6a260d9af67e1db4f54d732abad514252a7a378a6c4d17dd1036/types_pyyaml-6.0.12.20250516-py3-none-any.whl", hash = "sha256:8478208feaeb53a34cb5d970c56a7cd76b72659442e733e268a94dc72b2d0530", size = 20312, upload-time = "2025-05-16T03:08:04.019Z" },

     

       1066
       1066
       +
       ]

     

       1067
       1067
       +
       

     

       1068
       1068
       +
       [[package]]

     

       1069
       1069
       +
       name = "typing-extensions"

     

       1070
       1070
       +
       version = "4.14.1"

     

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

     

       1072
       1072
       +
       sdist = { url = "https://files.pythonhosted.org/packages/98/5a/da40306b885cc8c09109dc2e1abd358d5684b1425678151cdaed4731c822/typing_extensions-4.14.1.tar.gz", hash = "sha256:38b39f4aeeab64884ce9f74c94263ef78f3c22467c8724005483154c26648d36", size = 107673, upload-time = "2025-07-04T13:28:34.16Z" }

     

       1073
       1073
       +
       wheels = [

     

       1074
       1074
       +
           { url = "https://files.pythonhosted.org/packages/b5/00/d631e67a838026495268c2f6884f3711a15a9a2a96cd244fdaea53b823fb/typing_extensions-4.14.1-py3-none-any.whl", hash = "sha256:d1e1e3b58374dc93031d6eda2420a48ea44a36c2b4766a4fdeb3710755731d76", size = 43906, upload-time = "2025-07-04T13:28:32.743Z" },

     

       1075
       1075
       +
       ]

     

       1076
       1076
       +
       

     

       1077
       1077
       +
       [[package]]

     

       1078
       1078
       +
       name = "typing-inspection"

     

       1079
       1079
       +
       version = "0.4.1"

     

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

     

       1081
       1081
       +
       dependencies = [

     

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

     

       1083
       1083
       +
       ]

     

       1084
       1084
       +
       sdist = { url = "https://files.pythonhosted.org/packages/f8/b1/0c11f5058406b3af7609f121aaa6b609744687f1d158b3c3a5bf4cc94238/typing_inspection-0.4.1.tar.gz", hash = "sha256:6ae134cc0203c33377d43188d4064e9b357dba58cff3185f22924610e70a9d28", size = 75726, upload-time = "2025-05-21T18:55:23.885Z" }

     

       1085
       1085
       +
       wheels = [

     

       1086
       1086
       +
           { url = "https://files.pythonhosted.org/packages/17/69/cd203477f944c353c31bade965f880aa1061fd6bf05ded0726ca845b6ff7/typing_inspection-0.4.1-py3-none-any.whl", hash = "sha256:389055682238f53b04f7badcb49b989835495a96700ced5dab2d8feae4b26f51", size = 14552, upload-time = "2025-05-21T18:55:22.152Z" },

     

       1087
       1087
       +
       ]

     

       1088
       1088
       +
       

     

       1089
       1089
       +
       [[package]]

     

       1090
       1090
       +
       name = "tzdata"

     

       1091
       1091
       +
       version = "2025.2"

     

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

     

       1093
       1093
       +
       sdist = { url = "https://files.pythonhosted.org/packages/95/32/1a225d6164441be760d75c2c42e2780dc0873fe382da3e98a2e1e48361e5/tzdata-2025.2.tar.gz", hash = "sha256:b60a638fcc0daffadf82fe0f57e53d06bdec2f36c4df66280ae79bce6bd6f2b9", size = 196380, upload-time = "2025-03-23T13:54:43.652Z" }

     

       1094
       1094
       +
       wheels = [

     

       1095
       1095
       +
           { url = "https://files.pythonhosted.org/packages/5c/23/c7abc0ca0a1526a0774eca151daeb8de62ec457e77262b66b359c3c7679e/tzdata-2025.2-py2.py3-none-any.whl", hash = "sha256:1a403fada01ff9221ca8044d701868fa132215d84beb92242d9acd2147f667a8", size = 347839, upload-time = "2025-03-23T13:54:41.845Z" },

     

       1096
       1096
       +
       ]

     

       1097
       1097
       +
       

     

       1098
       1098
       +
       [[package]]

     

       1099
       1099
       +
       name = "webencodings"

     

       1100
       1100
       +
       version = "0.5.1"

     

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

     

       1102
       1102
       +
       sdist = { url = "https://files.pythonhosted.org/packages/0b/02/ae6ceac1baeda530866a85075641cec12989bd8d31af6d5ab4a3e8c92f47/webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923", size = 9721, upload-time = "2017-04-05T20:21:34.189Z" }

     

       1103
       1103
       +
       wheels = [

     

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

     

       1105
       1105
       +
       ]

Compare changes