commit 81932e032324f02bdd8daa888f6dee415061d6a6 · anil.recoil.org/thicket

+5 -6

pyproject.toml

···

       40
       40
        
           "platformdirs>=4.0.0",

     

       41
       41
        
           "pyyaml>=6.0.0",

     

       42
       42
        
           "email_validator",

     

       43
       43
       -
           "textual>=4.0.0",

     

       44
       44
       -
           "flask>=3.1.1",

     

       45
       43
        
       ]

     

       46
       44
        
       

     

       47
       45
        
       [project.optional-dependencies]

     
···

       140
       138
        
           "-ra",

     

       141
       139
        
           "--strict-markers",

     

       142
       140
        
           "--strict-config",

     

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

     

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

     

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

     

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

     

       147
       141
        
       ]

     

       148
       142
        
       filterwarnings = [

     

       149
       143
        
           "error",

     
···

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

     

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

     

       174
       168
        
       ]

     

       169
       169
       +
       

     

       170
       170
       +
       [dependency-groups]

     

       171
       171
       +
       dev = [

     

       172
       172
       +
           "pytest>=8.4.1",

     

       173
       173
       +
       ]

+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, info_cmd, init, links_cmd, list_cmd, sync, threads_cmd

     

       4
       4
       +
       from . import add, duplicates, info_cmd, init, list_cmd, sync

     

       5
       5
        
       

     

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

     

       6
       6
       +
       __all__ = ["add", "duplicates", "info_cmd", "init", "list_cmd", "sync"]

+44 -9

src/thicket/cli/commands/add.py

···

       23
       23
        
       def add_command(

     

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

     

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

     

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

     

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

     

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

     

       28
       28
       +
           ),

     

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

     

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

     

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

     

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

     

       32
       32
       +
           ),

     

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

     

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

     

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

     

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

     

       36
       36
       +
           ),

     

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

     

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

     

       33
       39
        
           ),

     

       34
       40
        
           auto_discover: bool = typer.Option(

     

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

     

       41
       41
       +
               True,

     

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

     

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

     

       36
       44
        
           ),

     

       37
       45
        
       ) -> None:

     

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

     

       39
       47
        
       

     

       40
       48
        
           if subcommand == "user":

     

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

     

       49
       49
       +
               add_user(

     

       50
       50
       +
                   username,

     

       51
       51
       +
                   feed_url,

     

       52
       52
       +
                   email,

     

       53
       53
       +
                   homepage,

     

       54
       54
       +
                   icon,

     

       55
       55
       +
                   display_name,

     

       56
       56
       +
                   config_file,

     

       57
       57
       +
                   auto_discover,

     

       58
       58
       +
               )

     

       42
       59
        
           elif subcommand == "feed":

     

       43
       60
        
               add_feed(username, feed_url, config_file)

     

       44
       61
        
           else:

     
···

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

     

       90
       107
        
       

     

       91
       108
        
           # Prepare user data with manual overrides taking precedence

     

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

     

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

     

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

     

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

     

       109
       109
       +
           user_display_name = display_name or (

     

       110
       110
       +
               discovered_metadata.author_name or discovered_metadata.title

     

       111
       111
       +
               if discovered_metadata

     

       112
       112
       +
               else None

     

       113
       113
       +
           )

     

       114
       114
       +
           user_email = email or (

     

       115
       115
       +
               discovered_metadata.author_email if discovered_metadata else None

     

       116
       116
       +
           )

     

       117
       117
       +
           user_homepage = homepage or (

     

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

     

       119
       119
       +
               if discovered_metadata

     

       120
       120
       +
               else None

     

       121
       121
       +
           )

     

       122
       122
       +
           user_icon = icon or (

     

       123
       123
       +
               str(

     

       124
       124
       +
                   discovered_metadata.logo

     

       125
       125
       +
                   or discovered_metadata.icon

     

       126
       126
       +
                   or discovered_metadata.image_url

     

       127
       127
       +
               )

     

       128
       128
       +
               if discovered_metadata

     

       129
       129
       +
               else None

     

       130
       130
       +
           )

     

       96
       131
        
       

     

       97
       132
        
           # Add user to Git store

     

       98
       133
        
           git_store.add_user(

+7 -3

src/thicket/cli/commands/duplicates.py

···

       10
       10
        
       from ..main import app

     

       11
       11
        
       from ..utils import (

     

       12
       12
        
           console,

     

       13
       13
       +
           get_tsv_mode,

     

       13
       14
        
           load_config,

     

       14
       15
        
           print_error,

     

       15
       16
        
           print_info,

     

       16
       17
        
           print_success,

     

       17
       17
       -
           get_tsv_mode,

     

       18
       18
        
       )

     

       19
       19
        
       

     

       20
       20
        
       

     
···

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

     

       76
       76
        
       

     

       77
       77
        
       

     

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

     

       78
       78
       +
       def add_duplicate(

     

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

     

       80
       80
       +
       ) -> None:

     

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

     

       80
       82
        
           if not duplicate_id:

     

       81
       83
        
               print_error("Duplicate ID is required")

     
···

       124
       126
        
           # Remove the mapping

     

       125
       127
        
           if git_store.remove_duplicate(duplicate_id):

     

       126
       128
        
               # Commit changes

     

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

     

       129
       129
       +
               git_store.commit_changes(

     

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

     

       131
       131
       +
               )

     

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

     

       129
       133
        
           else:

     

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

+78 -72

src/thicket/cli/commands/info_cmd.py

···

       7
       7
        
       from rich.console import Console

     

       8
       8
        
       from rich.panel import Panel

     

       9
       9
        
       from rich.table import Table

     

       10
       10
       -
       from rich.text import Text

     

       11
       10
        
       

     

       12
       11
        
       from ...core.git_store import GitStore

     

       13
       12
        
       from ..main import app

     

       14
       14
       -
       from ..utils import load_config, get_tsv_mode

     

       13
       13
       +
       from ..utils import get_tsv_mode, load_config

     

       15
       14
        
       

     

       16
       15
        
       console = Console()

     

       17
       16
        
       

     
···

       19
       18
        
       @app.command()

     

       20
       19
        
       def info(

     

       21
       20
        
           identifier: str = typer.Argument(

     

       22
       22
       -
               ...,

     

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

     

       21
       21
       +
               ..., help="The atom ID or URL of the entry to display information about"

     

       24
       22
        
           ),

     

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

     

       26
       24
        
               None,

     

       27
       25
        
               "--username",

     

       28
       26
        
               "-u",

     

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

     

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

     

       30
       28
        
           ),

     

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

     

       32
       30
        
               Path("thicket.yaml"),

     
···

       35
       33
        
               help="Path to configuration file",

     

       36
       34
        
           ),

     

       37
       35
        
           show_content: bool = typer.Option(

     

       38
       38
       -
               False,

     

       39
       39
       -
               "--content",

     

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

     

       36
       36
       +
               False, "--content", help="Include the full content of the entry in the output"

     

       41
       37
        
           ),

     

       42
       38
        
       ) -> None:

     

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

     

       44
       44
       -
           

     

       40
       40
       +
       

     

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

     

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

     

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

     
···

       49
       45
        
           try:

     

       50
       46
        
               # Load configuration

     

       51
       47
        
               config = load_config(config_file)

     

       52
       52
       -
               

     

       48
       48
       +
       

     

       53
       49
        
               # Initialize Git store

     

       54
       50
        
               git_store = GitStore(config.git_store)

     

       55
       55
       -
               

     

       51
       51
       +
       

     

       56
       52
        
               # Find the entry

     

       57
       53
        
               entry = None

     

       58
       54
        
               found_username = None

     

       59
       59
       -
               

     

       55
       55
       +
       

     

       60
       56
        
               # Check if identifier looks like a URL

     

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

     

       62
       62
       -
               

     

       57
       57
       +
               is_url = identifier.startswith(("http://", "https://"))

     

       58
       58
       +
       

     

       63
       59
        
               if username:

     

       64
       60
        
                   # Search specific username

     

       65
       61
        
                   if is_url:

     
···

       95
       91
        
                           if entry:

     

       96
       92
        
                               found_username = user

     

       97
       93
        
                               break

     

       98
       98
       -
               

     

       94
       94
       +
       

     

       99
       95
        
               if not entry or not found_username:

     

       100
       96
        
                   if username:

     

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

     

       97
       97
       +
                       console.print(

     

       98
       98
       +
                           f"[red]Entry with {'URL' if is_url else 'atom ID'} '{identifier}' not found for user '{username}'[/red]"

     

       99
       99
       +
                       )

     

       102
       100
        
                   else:

     

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

     

       101
       101
       +
                       console.print(

     

       102
       102
       +
                           f"[red]Entry with {'URL' if is_url else 'atom ID'} '{identifier}' not found in any user's entries[/red]"

     

       103
       103
       +
                       )

     

       104
       104
        
                   raise typer.Exit(1)

     

       105
       105
       -
               

     

       105
       105
       +
       

     

       106
       106
        
               # Display information

     

       107
       107
        
               if get_tsv_mode():

     

       108
       108
        
                   _display_entry_info_tsv(entry, found_username, show_content)

     

       109
       109
        
               else:

     

       110
       110
        
                   _display_entry_info(entry, found_username)

     

       111
       111
       -
                   

     

       111
       111
       +
       

     

       112
       112
        
                   # Display links and backlinks from entry fields

     

       113
       113
        
                   _display_link_info(entry, found_username, git_store)

     

       114
       114
       -
                   

     

       114
       114
       +
       

     

       115
       115
        
                   # Optionally display content

     

       116
       116
        
                   if show_content and entry.content:

     

       117
       117
        
                       _display_content(entry.content)

     

       118
       118
       -
                   

     

       118
       118
       +
       

     

       119
       119
        
           except Exception as e:

     

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

     

       121
       121
        
               raise typer.Exit(1)

     
···

       123
       123
        
       

     

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

     

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

     

       126
       126
       -
           

     

       126
       126
       +
       

     

       127
       127
        
           # Create main info panel

     

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

     

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

     

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

     

       131
       131
       -
           

     

       131
       131
       +
       

     

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

     

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

     

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

     

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

     

       136
       136
       -
           

     

       136
       136
       +
       

     

       137
       137
        
           if entry.published:

     

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

     

       139
       139
       -
           

     

       138
       138
       +
               info_table.add_row(

     

       139
       139
       +
                   "Published", entry.published.strftime("%Y-%m-%d %H:%M:%S UTC")

     

       140
       140
       +
               )

     

       141
       141
       +
       

     

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

     

       141
       141
       -
           

     

       143
       143
       +
       

     

       142
       144
        
           if entry.summary:

     

       143
       145
        
               # Truncate long summaries

     

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

     

       146
       146
       +
               summary = (

     

       147
       147
       +
                   entry.summary[:200] + "..." if len(entry.summary) > 200 else entry.summary

     

       148
       148
       +
               )

     

       145
       149
        
               info_table.add_row("Summary", summary)

     

       146
       146
       -
           

     

       150
       150
       +
       

     

       147
       151
        
           if entry.categories:

     

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

     

       149
       153
        
               info_table.add_row("Categories", categories_text)

     

       150
       150
       -
           

     

       154
       154
       +
       

     

       151
       155
        
           if entry.author:

     

       152
       156
        
               author_info = []

     

       153
       157
        
               if "name" in entry.author:

     
···

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

     

       157
       161
        
               if author_info:

     

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

     

       159
       159
       -
           

     

       163
       163
       +
       

     

       160
       164
        
           if entry.content_type:

     

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

     

       162
       162
       -
           

     

       166
       166
       +
       

     

       163
       167
        
           if entry.rights:

     

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

     

       165
       165
       -
           

     

       169
       169
       +
       

     

       166
       170
        
           if entry.source:

     

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

     

       168
       168
       -
           

     

       172
       172
       +
       

     

       169
       173
        
           panel = Panel(

     

       170
       170
       -
               info_table,

     

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

     

       172
       172
       -
               border_style="blue"

     

       174
       174
       +
               info_table, title="[bold]Entry Information[/bold]", border_style="blue"

     

       173
       175
        
           )

     

       174
       174
       -
           

     

       176
       176
       +
       

     

       175
       177
        
           console.print(panel)

     

       176
       178
        
       

     

       177
       179
        
       

     

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

     

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

     

       180
       180
       -
           

     

       182
       182
       +
       

     

       181
       183
        
           # Get links from entry fields

     

       182
       182
       -
           outbound_links = getattr(entry, 'links', [])

     

       183
       183
       -
           backlinks = getattr(entry, 'backlinks', [])

     

       184
       184
       -
           

     

       184
       184
       +
           outbound_links = getattr(entry, "links", [])

     

       185
       185
       +
           backlinks = getattr(entry, "backlinks", [])

     

       186
       186
       +
       

     

       185
       187
        
           if not outbound_links and not backlinks:

     

       186
       188
        
               console.print("\n[dim]No cross-references found for this entry.[/dim]")

     

       187
       189
        
               return

     

       188
       188
       -
           

     

       190
       190
       +
       

     

       189
       191
        
           # Create links table

     

       190
       192
        
           links_table = Table(title="Cross-References")

     

       191
       193
        
           links_table.add_column("Direction", style="cyan", width=10)

     

       192
       194
        
           links_table.add_column("Target/Source", style="green", width=30)

     

       193
       195
        
           links_table.add_column("URL/ID", style="blue", width=60)

     

       194
       194
       -
           

     

       196
       196
       +
       

     

       195
       197
        
           # Add outbound links

     

       196
       198
        
           for link in outbound_links:

     

       197
       199
        
               links_table.add_row("→ Out", "External/Other", link)

     

       198
       198
       -
           

     

       200
       200
       +
       

     

       199
       201
        
           # Add backlinks (inbound references)

     

       200
       202
        
           for backlink_id in backlinks:

     

       201
       203
        
               # Try to find which user this entry belongs to

     

       202
       204
        
               source_info = backlink_id

     

       203
       205
        
               # Could enhance this by looking up the actual entry to get username

     

       204
       206
        
               links_table.add_row("← In", "Entry", source_info)

     

       205
       205
       -
           

     

       207
       207
       +
       

     

       206
       208
        
           console.print()

     

       207
       209
        
           console.print(links_table)

     

       208
       208
       -
           

     

       210
       210
       +
       

     

       209
       211
        
           # Summary

     

       210
       210
       -
           console.print(f"\n[bold]Summary:[/bold] {len(outbound_links)} outbound links, {len(backlinks)} inbound backlinks")

     

       212
       212
       +
           console.print(

     

       213
       213
       +
               f"\n[bold]Summary:[/bold] {len(outbound_links)} outbound links, {len(backlinks)} inbound backlinks"

     

       214
       214
       +
           )

     

       211
       215
        
       

     

       212
       216
        
       

     

       213
       217
        
       def _display_content(content: str) -> None:

     

       214
       218
        
           """Display the full content of the entry."""

     

       215
       215
       -
           

     

       219
       219
       +
       

     

       216
       220
        
           # Truncate very long content

     

       217
       221
        
           display_content = content

     

       218
       222
        
           if len(content) > 5000:

     

       219
       223
        
               display_content = content[:5000] + "\n\n[... content truncated ...]"

     

       220
       220
       -
           

     

       224
       224
       +
       

     

       221
       225
        
           panel = Panel(

     

       222
       226
        
               display_content,

     

       223
       227
        
               title="[bold]Entry Content[/bold]",

     

       224
       228
        
               border_style="green",

     

       225
       225
       -
               expand=False

     

       229
       229
       +
               expand=False,

     

       226
       230
        
           )

     

       227
       227
       -
           

     

       231
       231
       +
       

     

       228
       232
        
           console.print()

     

       229
       233
        
           console.print(panel)

     

       230
       234
        
       

     

       231
       235
        
       

     

       232
       236
        
       def _display_entry_info_tsv(entry, username: str, show_content: bool) -> None:

     

       233
       237
        
           """Display entry information in TSV format."""

     

       234
       234
       -
           

     

       238
       238
       +
       

     

       235
       239
        
           # Basic info

     

       236
       240
        
           print("Field\tValue")

     

       237
       241
        
           print(f"User\t{username}")

     

       238
       242
        
           print(f"Atom ID\t{entry.id}")

     

       239
       239
       -
           print(f"Title\t{entry.title.replace(chr(9), ' ').replace(chr(10), ' ').replace(chr(13), ' ')}")

     

       243
       243
       +
           print(

     

       244
       244
       +
               f"Title\t{entry.title.replace(chr(9), ' ').replace(chr(10), ' ').replace(chr(13), ' ')}"

     

       245
       245
       +
           )

     

       240
       246
        
           print(f"Link\t{entry.link}")

     

       241
       241
       -
           

     

       247
       247
       +
       

     

       242
       248
        
           if entry.published:

     

       243
       249
        
               print(f"Published\t{entry.published.strftime('%Y-%m-%d %H:%M:%S UTC')}")

     

       244
       244
       -
           

     

       250
       250
       +
       

     

       245
       251
        
           print(f"Updated\t{entry.updated.strftime('%Y-%m-%d %H:%M:%S UTC')}")

     

       246
       246
       -
           

     

       252
       252
       +
       

     

       247
       253
        
           if entry.summary:

     

       248
       254
        
               # Escape tabs and newlines in summary

     

       249
       249
       -
               summary = entry.summary.replace('\t', ' ').replace('\n', ' ').replace('\r', ' ')

     

       255
       255
       +
               summary = entry.summary.replace("\t", " ").replace("\n", " ").replace("\r", " ")

     

       250
       256
        
               print(f"Summary\t{summary}")

     

       251
       251
       -
           

     

       257
       257
       +
       

     

       252
       258
        
           if entry.categories:

     

       253
       259
        
               print(f"Categories\t{', '.join(entry.categories)}")

     

       254
       254
       -
           

     

       260
       260
       +
       

     

       255
       261
        
           if entry.author:

     

       256
       262
        
               author_info = []

     

       257
       263
        
               if "name" in entry.author:

     
···

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

     

       261
       267
        
               if author_info:

     

       262
       268
        
                   print(f"Author\t{' '.join(author_info)}")

     

       263
       263
       -
           

     

       269
       269
       +
       

     

       264
       270
        
           if entry.content_type:

     

       265
       271
        
               print(f"Content Type\t{entry.content_type}")

     

       266
       266
       -
           

     

       272
       272
       +
       

     

       267
       273
        
           if entry.rights:

     

       268
       274
        
               print(f"Rights\t{entry.rights}")

     

       269
       269
       -
           

     

       275
       275
       +
       

     

       270
       276
        
           if entry.source:

     

       271
       277
        
               print(f"Source Feed\t{entry.source}")

     

       272
       272
       -
           

     

       278
       278
       +
       

     

       273
       279
        
           # Add links info from entry fields

     

       274
       274
       -
           outbound_links = getattr(entry, 'links', [])

     

       275
       275
       -
           backlinks = getattr(entry, 'backlinks', [])

     

       276
       276
       -
           

     

       280
       280
       +
           outbound_links = getattr(entry, "links", [])

     

       281
       281
       +
           backlinks = getattr(entry, "backlinks", [])

     

       282
       282
       +
       

     

       277
       283
        
           if outbound_links or backlinks:

     

       278
       284
        
               print(f"Outbound Links\t{len(outbound_links)}")

     

       279
       285
        
               print(f"Backlinks\t{len(backlinks)}")

     

       280
       280
       -
               

     

       286
       286
       +
       

     

       281
       287
        
               # Show each link

     

       282
       288
        
               for link in outbound_links:

     

       283
       289
        
                   print(f"→ Link\t{link}")

     

       284
       284
       -
               

     

       290
       290
       +
       

     

       285
       291
        
               for backlink_id in backlinks:

     

       286
       292
        
                   print(f"← Backlink\t{backlink_id}")

     

       287
       287
       -
           

     

       293
       293
       +
       

     

       288
       294
        
           # Show content if requested

     

       289
       295
        
           if show_content and entry.content:

     

       290
       296
        
               # Escape tabs and newlines in content

     

       291
       291
       -
               content = entry.content.replace('\t', ' ').replace('\n', ' ').replace('\r', ' ')

     

       292
       292
       -
               print(f"Content\t{content}")
     

       297
       297
       +
               content = entry.content.replace("\t", " ").replace("\n", " ").replace("\r", " ")

     

       298
       298
       +
               print(f"Content\t{content}")

+5 -6

src/thicket/cli/commands/init.py

···

       14
       14
        
       

     

       15
       15
        
       @app.command()

     

       16
       16
        
       def init(

     

       17
       17
       -
           git_store: Path = typer.Argument(..., help="Path to Git repository for storing feeds"),

     

       17
       17
       +
           git_store: Path = typer.Argument(

     

       18
       18
       +
               ..., help="Path to Git repository for storing feeds"

     

       19
       19
       +
           ),

     

       18
       20
        
           cache_dir: Optional[Path] = typer.Option(

     

       19
       21
        
               None, "--cache-dir", "-c", help="Cache directory (default: ~/.cache/thicket)"

     

       20
       22
        
           ),

     
···

       30
       32
        
           # Set default paths

     

       31
       33
        
           if cache_dir is None:

     

       32
       34
        
               from platformdirs import user_cache_dir

     

       35
       35
       +
       

     

       33
       36
        
               cache_dir = Path(user_cache_dir("thicket"))

     

       34
       37
        
       

     

       35
       38
        
           if config_file is None:

     
···

       54
       57
        
       

     

       55
       58
        
           # Create configuration

     

       56
       59
        
           try:

     

       57
       57
       -
               config = ThicketConfig(

     

       58
       58
       -
                   git_store=git_store,

     

       59
       59
       -
                   cache_dir=cache_dir,

     

       60
       60
       -
                   users=[]

     

       61
       61
       -
               )

     

       60
       60
       +
               config = ThicketConfig(git_store=git_store, cache_dir=cache_dir, users=[])

     

       62
       61
        
       

     

       63
       62
        
               save_config(config, config_file)

     

       64
       63
        
               print_success(f"Created configuration file: {config_file}")

-331

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 re

     

       4
       4
       -
       from pathlib import Path

     

       5
       5
       -
       from typing import Any, Optional

     

       6
       6
       -
       from urllib.parse import urljoin, urlparse

     

       7
       7
       -
       

     

       8
       8
       -
       import typer

     

       9
       9
       -
       from rich.console import Console

     

       10
       10
       -
       from rich.progress import (

     

       11
       11
       -
           BarColumn,

     

       12
       12
       -
           Progress,

     

       13
       13
       -
           SpinnerColumn,

     

       14
       14
       -
           TaskProgressColumn,

     

       15
       15
       -
           TextColumn,

     

       16
       16
       -
       )

     

       17
       17
       -
       from rich.table import Table

     

       18
       18
       -
       

     

       19
       19
       -
       from ...core.git_store import GitStore

     

       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
       -
       class LinkExtractor:

     

       27
       27
       -
           """Extracts and resolves links from blog entries."""

     

       28
       28
       -
       

     

       29
       29
       -
           def __init__(self) -> None:

     

       30
       30
       -
               # Pattern for extracting links from HTML

     

       31
       31
       -
               self.link_pattern = re.compile(

     

       32
       32
       -
                   r'<a[^>]+href="([^"]+)"[^>]*>(.*?)</a>', re.IGNORECASE | re.DOTALL

     

       33
       33
       -
               )

     

       34
       34
       -
               self.url_pattern = re.compile(r'https?://[^\s<>"]+')

     

       35
       35
       -
       

     

       36
       36
       -
           def extract_links_from_html(

     

       37
       37
       -
               self, html_content: str, base_url: str

     

       38
       38
       -
           ) -> list[tuple[str, str]]:

     

       39
       39
       -
               """Extract all links from HTML content and resolve them against base URL."""

     

       40
       40
       -
               links = []

     

       41
       41
       -
       

     

       42
       42
       -
               # Extract links from <a> tags

     

       43
       43
       -
               for match in self.link_pattern.finditer(html_content):

     

       44
       44
       -
                   url = match.group(1)

     

       45
       45
       -
                   text = re.sub(

     

       46
       46
       -
                       r"<[^>]+>", "", match.group(2)

     

       47
       47
       -
                   ).strip()  # Remove HTML tags from link text

     

       48
       48
       -
       

     

       49
       49
       -
                   # Resolve relative URLs against base URL

     

       50
       50
       -
                   resolved_url = urljoin(base_url, url)

     

       51
       51
       -
                   links.append((resolved_url, text))

     

       52
       52
       -
       

     

       53
       53
       -
               return links

     

       54
       54
       -
       

     

       55
       55
       -
           def extract_links_from_entry(

     

       56
       56
       -
               self, entry: Any, username: str, base_url: str

     

       57
       57
       -
           ) -> list[str]:

     

       58
       58
       -
               """Extract all links from a blog entry."""

     

       59
       59
       -
               links = []

     

       60
       60
       -
       

     

       61
       61
       -
               # Combine all text content for analysis

     

       62
       62
       -
               content_to_search = []

     

       63
       63
       -
               if entry.content:

     

       64
       64
       -
                   content_to_search.append(entry.content)

     

       65
       65
       -
               if entry.summary:

     

       66
       66
       -
                   content_to_search.append(entry.summary)

     

       67
       67
       -
       

     

       68
       68
       -
               for content in content_to_search:

     

       69
       69
       -
                   extracted_links = self.extract_links_from_html(content, base_url)

     

       70
       70
       -
       

     

       71
       71
       -
                   for url, _link_text in extracted_links:

     

       72
       72
       -
                       # Skip empty URLs

     

       73
       73
       -
                       if not url or url.startswith("#"):

     

       74
       74
       -
                           continue

     

       75
       75
       -
       

     

       76
       76
       -
                       links.append(url)

     

       77
       77
       -
       

     

       78
       78
       -
               return links

     

       79
       79
       -
       

     

       80
       80
       -
       

     

       81
       81
       -
       @app.command()

     

       82
       82
       -
       def links(

     

       83
       83
       -
           config_file: Optional[Path] = typer.Option(

     

       84
       84
       -
               Path("thicket.yaml"),

     

       85
       85
       -
               "--config",

     

       86
       86
       -
               "-c",

     

       87
       87
       -
               help="Path to configuration file",

     

       88
       88
       -
           ),

     

       89
       89
       -
           verbose: bool = typer.Option(

     

       90
       90
       -
               False,

     

       91
       91
       -
               "--verbose",

     

       92
       92
       -
               "-v",

     

       93
       93
       -
               help="Show detailed progress information",

     

       94
       94
       -
           ),

     

       95
       95
       -
       ) -> None:

     

       96
       96
       -
           """Extract and store outbound links and backlinks in blog entry JSON files.

     

       97
       97
       -
       

     

       98
       98
       -
           This command analyzes all blog entries to extract outbound links,

     

       99
       99
       -
           resolve them properly with respect to the feed's base URL, and

     

       100
       100
       -
           store them in each entry's JSON file in a 'links' field.

     

       101
       101
       -
       

     

       102
       102
       -
           It also builds backlinks by finding all entries that link to each entry

     

       103
       103
       -
           and storing the referring entry IDs in a 'backlinks' field.

     

       104
       104
       -
           """

     

       105
       105
       -
           try:

     

       106
       106
       -
               # Load configuration

     

       107
       107
       -
               config = load_config(config_file)

     

       108
       108
       -
       

     

       109
       109
       -
               # Initialize Git store

     

       110
       110
       -
               git_store = GitStore(config.git_store)

     

       111
       111
       -
       

     

       112
       112
       -
               # Build user domain mapping

     

       113
       113
       -
               if verbose:

     

       114
       114
       -
                   console.print("Building user domain mapping...")

     

       115
       115
       -
       

     

       116
       116
       -
               index = git_store._load_index()

     

       117
       117
       -
               user_domains = {}

     

       118
       118
       -
       

     

       119
       119
       -
               for username, user_metadata in index.users.items():

     

       120
       120
       -
                   domains = set()

     

       121
       121
       -
       

     

       122
       122
       -
                   # Add domains from feeds

     

       123
       123
       -
                   for feed_url in user_metadata.feeds:

     

       124
       124
       -
                       domain = urlparse(feed_url).netloc.lower()

     

       125
       125
       -
                       if domain:

     

       126
       126
       -
                           domains.add(domain)

     

       127
       127
       -
       

     

       128
       128
       -
                   # Add domain from homepage

     

       129
       129
       -
                   if user_metadata.homepage:

     

       130
       130
       -
                       domain = urlparse(str(user_metadata.homepage)).netloc.lower()

     

       131
       131
       -
                       if domain:

     

       132
       132
       -
                           domains.add(domain)

     

       133
       133
       -
       

     

       134
       134
       -
                   user_domains[username] = domains

     

       135
       135
       -
       

     

       136
       136
       -
               if verbose:

     

       137
       137
       -
                   console.print(

     

       138
       138
       -
                       f"Found {len(user_domains)} users with {sum(len(d) for d in user_domains.values())} total domains"

     

       139
       139
       -
                   )

     

       140
       140
       -
       

     

       141
       141
       -
               # Initialize components

     

       142
       142
       -
               link_extractor = LinkExtractor()

     

       143
       143
       -
       

     

       144
       144
       -
               # Get all users

     

       145
       145
       -
               users = list(index.users.keys())

     

       146
       146
       -
       

     

       147
       147
       -
               if not users:

     

       148
       148
       -
                   console.print("[yellow]No users found in Git store[/yellow]")

     

       149
       149
       -
                   raise typer.Exit(0)

     

       150
       150
       -
       

     

       151
       151
       -
               # First pass: collect all entries and build URL mapping

     

       152
       152
       -
               all_entries = []  # List of (username, entry) tuples

     

       153
       153
       -
               url_to_entry = {}  # Map URL to (username, entry_id)

     

       154
       154
       -
       

     

       155
       155
       -
               with Progress(

     

       156
       156
       -
                   SpinnerColumn(),

     

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

     

       158
       158
       -
                   BarColumn(),

     

       159
       159
       -
                   TaskProgressColumn(),

     

       160
       160
       -
                   console=console,

     

       161
       161
       -
               ) as progress:

     

       162
       162
       -
                   # Count total entries first

     

       163
       163
       -
                   counting_task = progress.add_task("Counting entries...", total=len(users))

     

       164
       164
       -
                   total_entries = 0

     

       165
       165
       -
       

     

       166
       166
       -
                   for username in users:

     

       167
       167
       -
                       entries = git_store.list_entries(username)

     

       168
       168
       -
                       total_entries += len(entries)

     

       169
       169
       -
                       for entry in entries:

     

       170
       170
       -
                           all_entries.append((username, entry))

     

       171
       171
       -
                           # Map entry's permalink URL to the entry

     

       172
       172
       -
                           if hasattr(entry, "link") and entry.link:

     

       173
       173
       -
                               url_to_entry[str(entry.link)] = (username, entry.id)

     

       174
       174
       -
                       progress.advance(counting_task)

     

       175
       175
       -
       

     

       176
       176
       -
                   progress.remove_task(counting_task)

     

       177
       177
       -
       

     

       178
       178
       -
                   if verbose:

     

       179
       179
       -
                       console.print(f"Built URL mapping for {len(url_to_entry)} entry URLs")

     

       180
       180
       -
       

     

       181
       181
       -
                   # Second pass: process links for each entry

     

       182
       182
       -
                   processing_task = progress.add_task(

     

       183
       183
       -
                       f"Processing {total_entries} entries for links...", total=total_entries

     

       184
       184
       -
                   )

     

       185
       185
       -
       

     

       186
       186
       -
                   updated_entries = 0

     

       187
       187
       -
                   total_links_found = 0

     

       188
       188
       -
                   link_mapping = {}  # entry_id -> list of linked URLs

     

       189
       189
       -
       

     

       190
       190
       -
                   for username, entry in all_entries:

     

       191
       191
       -
                       user_metadata = index.users[username]

     

       192
       192
       -
       

     

       193
       193
       -
                       # Get base URL for this user (use first feed URL)

     

       194
       194
       -
                       base_url = (

     

       195
       195
       -
                           str(user_metadata.feeds[0])

     

       196
       196
       -
                           if user_metadata.feeds

     

       197
       197
       -
                           else "https://example.com"

     

       198
       198
       -
                       )

     

       199
       199
       -
       

     

       200
       200
       -
                       # Extract links from this entry

     

       201
       201
       -
                       extracted_urls = link_extractor.extract_links_from_entry(

     

       202
       202
       -
                           entry, username, base_url

     

       203
       203
       -
                       )

     

       204
       204
       -
       

     

       205
       205
       -
                       # Remove duplicates while preserving order

     

       206
       206
       -
                       unique_urls = []

     

       207
       207
       -
                       seen_urls = set()

     

       208
       208
       -
       

     

       209
       209
       -
                       for url in extracted_urls:

     

       210
       210
       -
                           if url not in seen_urls:

     

       211
       211
       -
                               unique_urls.append(url)

     

       212
       212
       -
                               seen_urls.add(url)

     

       213
       213
       -
       

     

       214
       214
       -
                       # Store the links in our mapping for backlink processing

     

       215
       215
       -
                       link_mapping[entry.id] = unique_urls

     

       216
       216
       -
       

     

       217
       217
       -
                       # Update entry with links

     

       218
       218
       -
                       entry.links = unique_urls

     

       219
       219
       -
                       if unique_urls:

     

       220
       220
       -
                           updated_entries += 1

     

       221
       221
       -
                           total_links_found += len(unique_urls)

     

       222
       222
       -
       

     

       223
       223
       -
                           if verbose:

     

       224
       224
       -
                               console.print(

     

       225
       225
       -
                                   f"  Updated {username}:{entry.title[:50]}... with {len(unique_urls)} links"

     

       226
       226
       -
                               )

     

       227
       227
       -
       

     

       228
       228
       -
                       progress.advance(processing_task)

     

       229
       229
       -
       

     

       230
       230
       -
                   progress.remove_task(processing_task)

     

       231
       231
       -
       

     

       232
       232
       -
                   # Third pass: process backlinks

     

       233
       233
       -
                   backlink_task = progress.add_task(

     

       234
       234
       -
                       f"Processing backlinks for {total_entries} entries...",

     

       235
       235
       -
                       total=total_entries,

     

       236
       236
       -
                   )

     

       237
       237
       -
       

     

       238
       238
       -
                   # Initialize backlinks for all entries

     

       239
       239
       -
                   for _username, entry in all_entries:

     

       240
       240
       -
                       entry.backlinks = []

     

       241
       241
       -
       

     

       242
       242
       -
                   # Build backlinks by examining all the links

     

       243
       243
       -
                   for _username, entry in all_entries:

     

       244
       244
       -
                       source_entry_id = entry.id

     

       245
       245
       -
                       for linked_url in link_mapping.get(source_entry_id, []):

     

       246
       246
       -
                           # Check if this URL corresponds to an entry we know about

     

       247
       247
       -
                           if linked_url in url_to_entry:

     

       248
       248
       -
                               target_username, target_entry_id = url_to_entry[linked_url]

     

       249
       249
       -
                               # Find the target entry and add this source as a backlink

     

       250
       250
       -
                               for target_user, target_entry in all_entries:

     

       251
       251
       -
                                   if (

     

       252
       252
       -
                                       target_user == target_username

     

       253
       253
       -
                                       and target_entry.id == target_entry_id

     

       254
       254
       -
                                   ):

     

       255
       255
       -
                                       if source_entry_id not in target_entry.backlinks:

     

       256
       256
       -
                                           target_entry.backlinks.append(source_entry_id)

     

       257
       257
       -
                                       break

     

       258
       258
       -
       

     

       259
       259
       -
                       progress.advance(backlink_task)

     

       260
       260
       -
       

     

       261
       261
       -
                   progress.remove_task(backlink_task)

     

       262
       262
       -
       

     

       263
       263
       -
                   # Final pass: save all updated entries

     

       264
       264
       -
                   saving_task = progress.add_task(

     

       265
       265
       -
                       f"Saving {total_entries} updated entries...", total=total_entries

     

       266
       266
       -
                   )

     

       267
       267
       -
       

     

       268
       268
       -
                   backlinks_updated = 0

     

       269
       269
       -
                   for username, entry in all_entries:

     

       270
       270
       -
                       # Count entries that have backlinks

     

       271
       271
       -
                       if entry.backlinks:

     

       272
       272
       -
                           backlinks_updated += 1

     

       273
       273
       -
       

     

       274
       274
       -
                       # Store the updated entry back to the git store

     

       275
       275
       -
                       git_store.store_entry(username, entry)

     

       276
       276
       -
                       progress.advance(saving_task)

     

       277
       277
       -
       

     

       278
       278
       -
               # Show summary

     

       279
       279
       -
               if not get_tsv_mode():

     

       280
       280
       -
                   console.print("\n[green]✓ Links extraction completed successfully[/green]")

     

       281
       281
       -
       

     

       282
       282
       -
               # Create summary table or TSV output

     

       283
       283
       -
               if get_tsv_mode():

     

       284
       284
       -
                   print("Metric\tValue\tDescription")

     

       285
       285
       -
                   print(

     

       286
       286
       -
                       f"Entries Updated\t{updated_entries}\tBlog entries updated with links"

     

       287
       287
       -
                   )

     

       288
       288
       -
                   print(

     

       289
       289
       -
                       f"Total Links\t{total_links_found}\tTotal unique links found across all entries"

     

       290
       290
       -
                   )

     

       291
       291
       -
                   print(

     

       292
       292
       -
                       f"Entries with Backlinks\t{backlinks_updated}\tEntries that have backlinks from other entries"

     

       293
       293
       -
                   )

     

       294
       294
       -
                   print(f"Total Entries\t{total_entries}\tTotal entries processed")

     

       295
       295
       -
               else:

     

       296
       296
       -
                   table = Table(title="Links & Backlinks Processing Summary")

     

       297
       297
       -
                   table.add_column("Metric", style="cyan")

     

       298
       298
       -
                   table.add_column("Value", style="green")

     

       299
       299
       -
                   table.add_column("Description", style="white")

     

       300
       300
       -
       

     

       301
       301
       -
                   table.add_row(

     

       302
       302
       -
                       "Entries Updated",

     

       303
       303
       -
                       str(updated_entries),

     

       304
       304
       -
                       "Blog entries updated with links",

     

       305
       305
       -
                   )

     

       306
       306
       -
                   table.add_row(

     

       307
       307
       -
                       "Total Links",

     

       308
       308
       -
                       str(total_links_found),

     

       309
       309
       -
                       "Total unique links found across all entries",

     

       310
       310
       -
                   )

     

       311
       311
       -
                   table.add_row(

     

       312
       312
       -
                       "Entries with Backlinks",

     

       313
       313
       -
                       str(backlinks_updated),

     

       314
       314
       -
                       "Entries that have backlinks from other entries",

     

       315
       315
       -
                   )

     

       316
       316
       -
                   table.add_row(

     

       317
       317
       -
                       "Total Entries", str(total_entries), "Total entries processed"

     

       318
       318
       -
                   )

     

       319
       319
       -
       

     

       320
       320
       -
                   console.print(table)

     

       321
       321
       -
       

     

       322
       322
       -
               if not get_tsv_mode():

     

       323
       323
       -
                   console.print(

     

       324
       324
       -
                       "\nLinks and backlinks have been stored in individual entry JSON files in the git repository."

     

       325
       325
       -
                   )

     

       326
       326
       -
       

     

       327
       327
       -
           except Exception as e:

     

       328
       328
       -
               console.print(f"[red]Error extracting links: {e}[/red]")

     

       329
       329
       -
               if verbose:

     

       330
       330
       -
                   console.print_exception()

     

       331
       331
       -
               raise typer.Exit(1) from e

+11 -11

src/thicket/cli/commands/list_cmd.py

···

       11
       11
        
       from ..main import app

     

       12
       12
        
       from ..utils import (

     

       13
       13
        
           console,

     

       14
       14
       +
           get_tsv_mode,

     

       14
       15
        
           load_config,

     

       16
       16
       +
           print_entries_tsv,

     

       15
       17
        
           print_error,

     

       16
       16
       -
           print_feeds_table,

     

       17
       18
        
           print_feeds_table_from_git,

     

       18
       19
        
           print_info,

     

       19
       19
       -
           print_users_table,

     

       20
       20
        
           print_users_table_from_git,

     

       21
       21
       -
           print_entries_tsv,

     

       22
       22
       -
           get_tsv_mode,

     

       23
       21
        
       )

     

       24
       22
        
       

     

       25
       23
        
       

     
···

       60
       58
        
           """List all users."""

     

       61
       59
        
           index = git_store._load_index()

     

       62
       60
        
           users = list(index.users.values())

     

       63
       63
       -
           

     

       61
       61
       +
       

     

       64
       62
        
           if not users:

     

       65
       63
        
               print_info("No users configured")

     

       66
       64
        
               return

     
···

       83
       81
        
           print_feeds_table_from_git(git_store, username)

     

       84
       82
        
       

     

       85
       83
        
       

     

       86
       86
       -
       def list_entries(git_store: GitStore, username: Optional[str] = None, limit: Optional[int] = None) -> None:

     

       84
       84
       +
       def list_entries(

     

       85
       85
       +
           git_store: GitStore, username: Optional[str] = None, limit: Optional[int] = None

     

       86
       86
       +
       ) -> None:

     

       87
       87
        
           """List entries, optionally filtered by user."""

     

       88
       88
        
       

     

       89
       89
        
           if username:

     
···

       123
       123
        
           """Clean HTML content for display in table."""

     

       124
       124
        
           if not content:

     

       125
       125
        
               return ""

     

       126
       126
       -
           

     

       126
       126
       +
       

     

       127
       127
        
           # Remove HTML tags

     

       128
       128
       -
           clean_text = re.sub(r'<[^>]+>', ' ', content)

     

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

     

       129
       129
        
           # Replace multiple whitespace with single space

     

       130
       130
       -
           clean_text = re.sub(r'\s+', ' ', clean_text)

     

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

     

       131
       131
        
           # Strip and limit length

     

       132
       132
        
           clean_text = clean_text.strip()

     

       133
       133
        
           if len(clean_text) > 100:

     

       134
       134
        
               clean_text = clean_text[:97] + "..."

     

       135
       135
       -
           

     

       135
       135
       +
       

     

       136
       136
        
           return clean_text

     

       137
       137
        
       

     

       138
       138
        
       

     
···

       141
       141
        
           if get_tsv_mode():

     

       142
       142
        
               print_entries_tsv(entries_by_user, usernames)

     

       143
       143
        
               return

     

       144
       144
       -
               

     

       144
       144
       +
       

     

       145
       145
        
           table = Table(title="Feed Entries")

     

       146
       146
        
           table.add_column("User", style="cyan", no_wrap=True)

     

       147
       147
        
           table.add_column("Title", style="bold")

+15 -5

src/thicket/cli/commands/sync.py

···

       71
       71
        
               user_updated_entries = 0

     

       72
       72
        
       

     

       73
       73
        
               # Sync each feed for the user

     

       74
       74
       -
               for feed_url in track(user_metadata.feeds, description=f"Syncing {user_metadata.username}'s feeds"):

     

       74
       74
       +
               for feed_url in track(

     

       75
       75
       +
                   user_metadata.feeds, description=f"Syncing {user_metadata.username}'s feeds"

     

       76
       76
       +
               ):

     

       75
       77
        
                   try:

     

       76
       78
        
                       new_entries, updated_entries = asyncio.run(

     

       77
       79
        
                           sync_feed(git_store, user_metadata.username, feed_url, dry_run)

     
···

       83
       85
        
                       print_error(f"Failed to sync feed {feed_url}: {e}")

     

       84
       86
        
                       continue

     

       85
       87
        
       

     

       86
       86
       -
               print_info(f"User {user_metadata.username}: {user_new_entries} new, {user_updated_entries} updated")

     

       88
       88
       +
               print_info(

     

       89
       89
       +
                   f"User {user_metadata.username}: {user_new_entries} new, {user_updated_entries} updated"

     

       90
       90
       +
               )

     

       87
       91
        
               total_new_entries += user_new_entries

     

       88
       92
        
               total_updated_entries += user_updated_entries

     

       89
       93
        
       

     
···

       95
       99
        
       

     

       96
       100
        
           # Summary

     

       97
       101
        
           if dry_run:

     

       98
       98
       -
               print_info(f"Dry run complete: would sync {total_new_entries} new entries, {total_updated_entries} updated")

     

       102
       102
       +
               print_info(

     

       103
       103
       +
                   f"Dry run complete: would sync {total_new_entries} new entries, {total_updated_entries} updated"

     

       104
       104
       +
               )

     

       99
       105
        
           else:

     

       100
       100
       -
               print_success(f"Sync complete: {total_new_entries} new entries, {total_updated_entries} updated")

     

       106
       106
       +
               print_success(

     

       107
       107
       +
                   f"Sync complete: {total_new_entries} new entries, {total_updated_entries} updated"

     

       108
       108
       +
               )

     

       101
       109
        
       

     

       102
       110
        
       

     

       103
       103
       -
       async def sync_feed(git_store: GitStore, username: str, feed_url, dry_run: bool) -> tuple[int, int]:

     

       111
       111
       +
       async def sync_feed(

     

       112
       112
       +
           git_store: GitStore, username: str, feed_url, dry_run: bool

     

       113
       113
       +
       ) -> tuple[int, int]:

     

       104
       114
        
           """Sync a single feed for a user."""

     

       105
       115
        
       

     

       106
       116
        
           parser = FeedParser()

-1111

src/thicket/cli/commands/threads_cmd.py

···

       1
       1
       -
       """CLI command for displaying and browsing thread-graphs of blog posts."""

     

       2
       2
       -
       

     

       3
       3
       -
       from dataclasses import dataclass, field

     

       4
       4
       -
       from datetime import datetime

     

       5
       5
       -
       from enum import Enum

     

       6
       6
       -
       from pathlib import Path

     

       7
       7
       -
       from typing import Dict, List, Optional, Set, Tuple

     

       8
       8
       -
       

     

       9
       9
       -
       import typer

     

       10
       10
       -
       from rich.console import Console

     

       11
       11
       -
       import json

     

       12
       12
       -
       import webbrowser

     

       13
       13
       -
       import threading

     

       14
       14
       -
       import time

     

       15
       15
       -
       from flask import Flask, render_template_string, jsonify

     

       16
       16
       -
       from textual import events

     

       17
       17
       -
       from textual.app import App, ComposeResult

     

       18
       18
       -
       from textual.containers import Container, Horizontal, Vertical

     

       19
       19
       -
       from textual.reactive import reactive

     

       20
       20
       -
       from textual.widget import Widget

     

       21
       21
       -
       from textual.widgets import Footer, Header, Label, Static

     

       22
       22
       -
       

     

       23
       23
       -
       from ...core.git_store import GitStore

     

       24
       24
       -
       from ...models import AtomEntry

     

       25
       25
       -
       from ..main import app

     

       26
       26
       -
       from ..utils import get_tsv_mode, load_config

     

       27
       27
       -
       

     

       28
       28
       -
       console = Console()

     

       29
       29
       -
       

     

       30
       30
       -
       

     

       31
       31
       -
       class LinkType(Enum):

     

       32
       32
       -
           """Types of links between entries."""

     

       33
       33
       -
       

     

       34
       34
       -
           SELF_REFERENCE = "self"  # Link to same user's content

     

       35
       35
       -
           USER_REFERENCE = "user"  # Link to another tracked user

     

       36
       36
       -
           EXTERNAL = "external"  # Link to external content

     

       37
       37
       -
       

     

       38
       38
       -
       

     

       39
       39
       -
       @dataclass

     

       40
       40
       -
       class ThreadNode:

     

       41
       41
       -
           """Represents a node in the thread graph."""

     

       42
       42
       -
       

     

       43
       43
       -
           entry_id: str

     

       44
       44
       -
           username: str

     

       45
       45
       -
           entry: AtomEntry

     

       46
       46
       -
           outbound_links: List[Tuple[str, LinkType]] = field(

     

       47
       47
       -
               default_factory=list

     

       48
       48
       -
           )  # (url, type)

     

       49
       49
       -
           inbound_backlinks: List[str] = field(default_factory=list)  # entry_ids

     

       50
       50
       -
       

     

       51
       51
       -
           @property

     

       52
       52
       -
           def published_date(self) -> datetime:

     

       53
       53
       -
               """Get the published or updated date for sorting."""

     

       54
       54
       -
               return self.entry.published or self.entry.updated

     

       55
       55
       -
       

     

       56
       56
       -
           @property

     

       57
       57
       -
           def title(self) -> str:

     

       58
       58
       -
               """Get the entry title."""

     

       59
       59
       -
               return self.entry.title

     

       60
       60
       -
       

     

       61
       61
       -
           @property

     

       62
       62
       -
           def summary(self) -> str:

     

       63
       63
       -
               """Get a short summary of the entry."""

     

       64
       64
       -
               if self.entry.summary:

     

       65
       65
       -
                   return (

     

       66
       66
       -
                       self.entry.summary[:100] + "..."

     

       67
       67
       -
                       if len(self.entry.summary) > 100

     

       68
       68
       -
                       else self.entry.summary

     

       69
       69
       -
                   )

     

       70
       70
       -
               return ""

     

       71
       71
       -
       

     

       72
       72
       -
       

     

       73
       73
       -
       @dataclass

     

       74
       74
       -
       class ThreadGraph:

     

       75
       75
       -
           """Represents the full thread graph of interconnected posts."""

     

       76
       76
       -
       

     

       77
       77
       -
           nodes: Dict[str, ThreadNode] = field(default_factory=dict)  # entry_id -> ThreadNode

     

       78
       78
       -
           user_entries: Dict[str, List[str]] = field(

     

       79
       79
       -
               default_factory=dict

     

       80
       80
       -
           )  # username -> [entry_ids]

     

       81
       81
       -
           url_to_entry: Dict[str, str] = field(default_factory=dict)  # url -> entry_id

     

       82
       82
       -
       

     

       83
       83
       -
           def add_node(self, node: ThreadNode) -> None:

     

       84
       84
       -
               """Add a node to the graph."""

     

       85
       85
       -
               self.nodes[node.entry_id] = node

     

       86
       86
       -
       

     

       87
       87
       -
               # Update user entries index

     

       88
       88
       -
               if node.username not in self.user_entries:

     

       89
       89
       -
                   self.user_entries[node.username] = []

     

       90
       90
       -
               self.user_entries[node.username].append(node.entry_id)

     

       91
       91
       -
       

     

       92
       92
       -
               # Update URL mapping

     

       93
       93
       -
               if node.entry.link:

     

       94
       94
       -
                   self.url_to_entry[str(node.entry.link)] = node.entry_id

     

       95
       95
       -
       

     

       96
       96
       -
           def get_connected_components(self) -> List[Set[str]]:

     

       97
       97
       -
               """Find all connected components in the graph (threads)."""

     

       98
       98
       -
               visited: Set[str] = set()

     

       99
       99
       -
               components: List[Set[str]] = []

     

       100
       100
       -
       

     

       101
       101
       -
               for entry_id in self.nodes:

     

       102
       102
       -
                   if entry_id not in visited:

     

       103
       103
       -
                       component: Set[str] = set()

     

       104
       104
       -
                       self._dfs(entry_id, visited, component)

     

       105
       105
       -
                       components.append(component)

     

       106
       106
       -
       

     

       107
       107
       -
               return components

     

       108
       108
       -
       

     

       109
       109
       -
           def _dfs(self, entry_id: str, visited: Set[str], component: Set[str]) -> None:

     

       110
       110
       -
               """Depth-first search to find connected components."""

     

       111
       111
       -
               if entry_id in visited:

     

       112
       112
       -
                   return

     

       113
       113
       -
       

     

       114
       114
       -
               visited.add(entry_id)

     

       115
       115
       -
               component.add(entry_id)

     

       116
       116
       -
       

     

       117
       117
       -
               node = self.nodes.get(entry_id)

     

       118
       118
       -
               if not node:

     

       119
       119
       -
                   return

     

       120
       120
       -
       

     

       121
       121
       -
               # Follow outbound links

     

       122
       122
       -
               for url, link_type in node.outbound_links:

     

       123
       123
       -
                   if url in self.url_to_entry:

     

       124
       124
       -
                       target_id = self.url_to_entry[url]

     

       125
       125
       -
                       self._dfs(target_id, visited, component)

     

       126
       126
       -
       

     

       127
       127
       -
               # Follow backlinks

     

       128
       128
       -
               for backlink_id in node.inbound_backlinks:

     

       129
       129
       -
                   self._dfs(backlink_id, visited, component)

     

       130
       130
       -
       

     

       131
       131
       -
           def get_standalone_entries(self) -> List[str]:

     

       132
       132
       -
               """Get entries with no connections."""

     

       133
       133
       -
               standalone = []

     

       134
       134
       -
               for entry_id, node in self.nodes.items():

     

       135
       135
       -
                   if not node.outbound_links and not node.inbound_backlinks:

     

       136
       136
       -
                       standalone.append(entry_id)

     

       137
       137
       -
               return standalone

     

       138
       138
       -
       

     

       139
       139
       -
           def sort_component_chronologically(self, component: Set[str]) -> List[str]:

     

       140
       140
       -
               """Sort a component by published date."""

     

       141
       141
       -
               nodes = [

     

       142
       142
       -
                   self.nodes[entry_id] for entry_id in component if entry_id in self.nodes

     

       143
       143
       -
               ]

     

       144
       144
       -
               nodes.sort(key=lambda n: n.published_date)

     

       145
       145
       -
               return [n.entry_id for n in nodes]

     

       146
       146
       -
       

     

       147
       147
       -
       

     

       148
       148
       -
       def build_thread_graph(git_store: GitStore) -> ThreadGraph:

     

       149
       149
       -
           """Build the thread graph from all entries in the git store."""

     

       150
       150
       -
           graph = ThreadGraph()

     

       151
       151
       -
       

     

       152
       152
       -
           # Get all users from index

     

       153
       153
       -
           index = git_store._load_index()

     

       154
       154
       -
           user_domains = {}

     

       155
       155
       -
       

     

       156
       156
       -
           # Build user domain mapping

     

       157
       157
       -
           for username, user_metadata in index.users.items():

     

       158
       158
       -
               domains = set()

     

       159
       159
       -
       

     

       160
       160
       -
               # Add domains from feeds

     

       161
       161
       -
               for feed_url in user_metadata.feeds:

     

       162
       162
       -
                   from urllib.parse import urlparse

     

       163
       163
       -
       

     

       164
       164
       -
                   domain = urlparse(str(feed_url)).netloc.lower()

     

       165
       165
       -
                   if domain:

     

       166
       166
       -
                       domains.add(domain)

     

       167
       167
       -
       

     

       168
       168
       -
               # Add domain from homepage

     

       169
       169
       -
               if user_metadata.homepage:

     

       170
       170
       -
                   domain = urlparse(str(user_metadata.homepage)).netloc.lower()

     

       171
       171
       -
                   if domain:

     

       172
       172
       -
                       domains.add(domain)

     

       173
       173
       -
       

     

       174
       174
       -
               user_domains[username] = domains

     

       175
       175
       -
       

     

       176
       176
       -
           # Process all entries

     

       177
       177
       -
           for username in index.users:

     

       178
       178
       -
               entries = git_store.list_entries(username)

     

       179
       179
       -
       

     

       180
       180
       -
               for entry in entries:

     

       181
       181
       -
                   # Create node

     

       182
       182
       -
                   node = ThreadNode(entry_id=entry.id, username=username, entry=entry)

     

       183
       183
       -
       

     

       184
       184
       -
                   # Process outbound links

     

       185
       185
       -
                   for link in getattr(entry, "links", []):

     

       186
       186
       -
                       link_type = categorize_link(link, username, user_domains)

     

       187
       187
       -
                       node.outbound_links.append((link, link_type))

     

       188
       188
       -
       

     

       189
       189
       -
                   # Copy backlinks

     

       190
       190
       -
                   node.inbound_backlinks = getattr(entry, "backlinks", [])

     

       191
       191
       -
       

     

       192
       192
       -
                   # Add to graph

     

       193
       193
       -
                   graph.add_node(node)

     

       194
       194
       -
       

     

       195
       195
       -
           return graph

     

       196
       196
       -
       

     

       197
       197
       -
       

     

       198
       198
       -
       def categorize_link(

     

       199
       199
       -
           url: str, source_username: str, user_domains: Dict[str, Set[str]]

     

       200
       200
       -
       ) -> LinkType:

     

       201
       201
       -
           """Categorize a link as self-reference, user reference, or external."""

     

       202
       202
       -
           from urllib.parse import urlparse

     

       203
       203
       -
       

     

       204
       204
       -
           try:

     

       205
       205
       -
               parsed = urlparse(url)

     

       206
       206
       -
               domain = parsed.netloc.lower()

     

       207
       207
       -
       

     

       208
       208
       -
               # Check if it's a self-reference

     

       209
       209
       -
               if domain in user_domains.get(source_username, set()):

     

       210
       210
       -
                   return LinkType.SELF_REFERENCE

     

       211
       211
       -
       

     

       212
       212
       -
               # Check if it's a reference to another tracked user

     

       213
       213
       -
               for username, domains in user_domains.items():

     

       214
       214
       -
                   if username != source_username and domain in domains:

     

       215
       215
       -
                       return LinkType.USER_REFERENCE

     

       216
       216
       -
       

     

       217
       217
       -
               # Otherwise it's external

     

       218
       218
       -
               return LinkType.EXTERNAL

     

       219
       219
       -
       

     

       220
       220
       -
           except Exception:

     

       221
       221
       -
               return LinkType.EXTERNAL

     

       222
       222
       -
       

     

       223
       223
       -
       

     

       224
       224
       -
       class ThreadTreeWidget(Static):

     

       225
       225
       -
           """Widget for displaying a thread as a tree."""

     

       226
       226
       -
       

     

       227
       227
       -
           def __init__(self, component: Set[str], graph: ThreadGraph, **kwargs):

     

       228
       228
       -
               super().__init__(**kwargs)

     

       229
       229
       -
               self.component = component

     

       230
       230
       -
               self.graph = graph

     

       231
       231
       -
       

     

       232
       232
       -
           def compose(self) -> ComposeResult:

     

       233
       233
       -
               """Create the tree display."""

     

       234
       234
       -
               # Sort entries chronologically

     

       235
       235
       -
               sorted_ids = self.graph.sort_component_chronologically(self.component)

     

       236
       236
       -
       

     

       237
       237
       -
               # Build tree structure as text

     

       238
       238
       -
               content_lines = ["Thread:"]

     

       239
       239
       -
               added_nodes: Set[str] = set()

     

       240
       240
       -
       

     

       241
       241
       -
               # Add nodes in chronological order, showing connections

     

       242
       242
       -
               for entry_id in sorted_ids:

     

       243
       243
       -
                   if entry_id not in added_nodes:

     

       244
       244
       -
                       self._add_node_to_text(content_lines, entry_id, added_nodes, 0)

     

       245
       245
       -
       

     

       246
       246
       -
               # Join all lines into content

     

       247
       247
       -
               content = "\n".join(content_lines)

     

       248
       248
       -
               

     

       249
       249
       -
               # Create a Static widget with the content

     

       250
       250
       -
               yield Static(content, id="thread-content")

     

       251
       251
       -
       

     

       252
       252
       -
           def _add_node_to_text(

     

       253
       253
       -
               self, content_lines: List[str], entry_id: str, added_nodes: Set[str], indent: int = 0

     

       254
       254
       -
           ):

     

       255
       255
       -
               """Recursively add nodes to the text display."""

     

       256
       256
       -
               if entry_id in added_nodes:

     

       257
       257
       -
                   # Show cycle reference

     

       258
       258
       -
                   node = self.graph.nodes.get(entry_id)

     

       259
       259
       -
                   if node:

     

       260
       260
       -
                       prefix = "  " * indent

     

       261
       261
       -
                       content_lines.append(f"{prefix}↻ {node.username}: {node.title}")

     

       262
       262
       -
                   return

     

       263
       263
       -
       

     

       264
       264
       -
               added_nodes.add(entry_id)

     

       265
       265
       -
               node = self.graph.nodes.get(entry_id)

     

       266
       266
       -
               if not node:

     

       267
       267
       -
                   return

     

       268
       268
       -
       

     

       269
       269
       -
               # Format node display

     

       270
       270
       -
               prefix = "  " * indent

     

       271
       271
       -
               date_str = node.published_date.strftime("%Y-%m-%d")

     

       272
       272
       -
               node_label = f"{prefix}• {node.username}: {node.title} ({date_str})"

     

       273
       273
       -
               content_lines.append(node_label)

     

       274
       274
       -
       

     

       275
       275
       -
               # Add connections info

     

       276
       276
       -
               if node.outbound_links:

     

       277
       277
       -
                   links_by_type: Dict[LinkType, List[str]] = {}

     

       278
       278
       -
                   for url, link_type in node.outbound_links:

     

       279
       279
       -
                       if link_type not in links_by_type:

     

       280
       280
       -
                           links_by_type[link_type] = []

     

       281
       281
       -
                       links_by_type[link_type].append(url)

     

       282
       282
       -
       

     

       283
       283
       -
                   for link_type, urls in links_by_type.items():

     

       284
       284
       -
                       type_label = f"{prefix}  → {link_type.value}: {len(urls)} link(s)"

     

       285
       285
       -
                       content_lines.append(type_label)

     

       286
       286
       -
       

     

       287
       287
       -
               if node.inbound_backlinks:

     

       288
       288
       -
                   backlink_label = f"{prefix}  ← backlinks: {len(node.inbound_backlinks)}"

     

       289
       289
       -
                   content_lines.append(backlink_label)

     

       290
       290
       -
       

     

       291
       291
       -
       

     

       292
       292
       -
       class ThreadBrowserApp(App):

     

       293
       293
       -
           """Terminal UI for browsing threads."""

     

       294
       294
       -
       

     

       295
       295
       -
           CSS = """

     

       296
       296
       -
           ThreadBrowserApp {

     

       297
       297
       -
               background: $surface;

     

       298
       298
       -
           }

     

       299
       299
       -
           

     

       300
       300
       -
           #thread-list {

     

       301
       301
       -
               width: 1fr;

     

       302
       302
       -
               height: 1fr;

     

       303
       303
       -
               border: solid $primary;

     

       304
       304
       -
               overflow-y: scroll;

     

       305
       305
       -
           }

     

       306
       306
       -
           

     

       307
       307
       -
           #entry-detail {

     

       308
       308
       -
               width: 1fr;

     

       309
       309
       -
               height: 1fr;

     

       310
       310
       -
               border: solid $secondary;

     

       311
       311
       -
               overflow-y: scroll;

     

       312
       312
       -
               padding: 1;

     

       313
       313
       -
           }

     

       314
       314
       -
           """

     

       315
       315
       -
       

     

       316
       316
       -
           BINDINGS = [

     

       317
       317
       -
               ("q", "quit", "Quit"),

     

       318
       318
       -
               ("j", "next_thread", "Next Thread"),

     

       319
       319
       -
               ("k", "prev_thread", "Previous Thread"),

     

       320
       320
       -
               ("enter", "select_thread", "View Thread"),

     

       321
       321
       -
           ]

     

       322
       322
       -
       

     

       323
       323
       -
           def __init__(self, graph: ThreadGraph):

     

       324
       324
       -
               super().__init__()

     

       325
       325
       -
               self.graph = graph

     

       326
       326
       -
               self.threads = []

     

       327
       327
       -
               self.current_thread_index = 0

     

       328
       328
       -
               self._build_thread_list()

     

       329
       329
       -
       

     

       330
       330
       -
           def _build_thread_list(self):

     

       331
       331
       -
               """Build the list of threads to display."""

     

       332
       332
       -
               # Get connected components (actual threads)

     

       333
       333
       -
               components = self.graph.get_connected_components()

     

       334
       334
       -
       

     

       335
       335
       -
               # Sort components by the earliest date in each

     

       336
       336
       -
               sorted_components = []

     

       337
       337
       -
               for component in components:

     

       338
       338
       -
                   if len(component) > 1:  # Only show actual threads

     

       339
       339
       -
                       sorted_ids = self.graph.sort_component_chronologically(component)

     

       340
       340
       -
                       if sorted_ids:

     

       341
       341
       -
                           first_node = self.graph.nodes.get(sorted_ids[0])

     

       342
       342
       -
                           if first_node:

     

       343
       343
       -
                               sorted_components.append((first_node.published_date, component))

     

       344
       344
       -
       

     

       345
       345
       -
               sorted_components.sort(key=lambda x: x[0], reverse=True)

     

       346
       346
       -
               self.threads = [comp for _, comp in sorted_components]

     

       347
       347
       -
       

     

       348
       348
       -
           def compose(self) -> ComposeResult:

     

       349
       349
       -
               """Create the UI layout."""

     

       350
       350
       -
               yield Header()

     

       351
       351
       -
       

     

       352
       352
       -
               with Horizontal():

     

       353
       353
       -
                   with Vertical(id="thread-list"):

     

       354
       354
       -
                       yield Label("Threads", classes="title")

     

       355
       355
       -
                       for i, thread in enumerate(self.threads):

     

       356
       356
       -
                           # Get thread summary

     

       357
       357
       -
                           sorted_ids = self.graph.sort_component_chronologically(thread)

     

       358
       358
       -
                           if sorted_ids:

     

       359
       359
       -
                               first_node = self.graph.nodes.get(sorted_ids[0])

     

       360
       360
       -
                               if first_node:

     

       361
       361
       -
                                   label = f"{i + 1}. {first_node.title} ({len(thread)} posts)"

     

       362
       362
       -
                                   yield Label(label, classes="thread-item")

     

       363
       363
       -
       

     

       364
       364
       -
                   with Vertical(id="entry-detail"):

     

       365
       365
       -
                       if self.threads:

     

       366
       366
       -
                           yield ThreadTreeWidget(self.threads[0], self.graph)

     

       367
       367
       -
       

     

       368
       368
       -
               yield Footer()

     

       369
       369
       -
       

     

       370
       370
       -
           def action_next_thread(self) -> None:

     

       371
       371
       -
               """Move to next thread."""

     

       372
       372
       -
               if self.current_thread_index < len(self.threads) - 1:

     

       373
       373
       -
                   self.current_thread_index += 1

     

       374
       374
       -
                   self.update_display()

     

       375
       375
       -
       

     

       376
       376
       -
           def action_prev_thread(self) -> None:

     

       377
       377
       -
               """Move to previous thread."""

     

       378
       378
       -
               if self.current_thread_index > 0:

     

       379
       379
       -
                   self.current_thread_index -= 1

     

       380
       380
       -
                   self.update_display()

     

       381
       381
       -
       

     

       382
       382
       -
           def action_select_thread(self) -> None:

     

       383
       383
       -
               """View detailed thread."""

     

       384
       384
       -
               # In a real implementation, this could show more detail

     

       385
       385
       -
               pass

     

       386
       386
       -
       

     

       387
       387
       -
           def update_display(self) -> None:

     

       388
       388
       -
               """Update the thread display."""

     

       389
       389
       -
               detail_view = self.query_one("#entry-detail")

     

       390
       390
       -
               detail_view.remove_children()

     

       391
       391
       -
       

     

       392
       392
       -
               if self.threads and self.current_thread_index < len(self.threads):

     

       393
       393
       -
                   widget = ThreadTreeWidget(

     

       394
       394
       -
                       self.threads[self.current_thread_index], self.graph

     

       395
       395
       -
                   )

     

       396
       396
       -
                   detail_view.mount(widget)

     

       397
       397
       -
       

     

       398
       398
       -
       

     

       399
       399
       -
       @app.command()

     

       400
       400
       -
       def threads(

     

       401
       401
       -
           config_file: Optional[Path] = typer.Option(

     

       402
       402
       -
               Path("thicket.yaml"),

     

       403
       403
       -
               "--config",

     

       404
       404
       -
               "-c",

     

       405
       405
       -
               help="Path to configuration file",

     

       406
       406
       -
           ),

     

       407
       407
       -
           interactive: bool = typer.Option(

     

       408
       408
       -
               True,

     

       409
       409
       -
               "--interactive/--no-interactive",

     

       410
       410
       -
               "-i/-n",

     

       411
       411
       -
               help="Launch interactive terminal UI",

     

       412
       412
       -
           ),

     

       413
       413
       -
           web: bool = typer.Option(

     

       414
       414
       -
               False,

     

       415
       415
       -
               "--web",

     

       416
       416
       -
               "-w",

     

       417
       417
       -
               help="Launch web server with D3 force graph visualization",

     

       418
       418
       -
           ),

     

       419
       419
       -
           port: int = typer.Option(

     

       420
       420
       -
               8080,

     

       421
       421
       -
               "--port",

     

       422
       422
       -
               "-p",

     

       423
       423
       -
               help="Port for web server",

     

       424
       424
       -
           ),

     

       425
       425
       -
       ) -> None:

     

       426
       426
       -
           """Browse and visualize thread-graphs of interconnected blog posts.

     

       427
       427
       -
       

     

       428
       428
       -
           This command analyzes all blog entries and their links/backlinks to build

     

       429
       429
       -
           a graph of conversations and references between posts. Threads are displayed

     

       430
       430
       -
           as connected components in the link graph.

     

       431
       431
       -
           """

     

       432
       432
       -
           try:

     

       433
       433
       -
               # Load configuration

     

       434
       434
       -
               config = load_config(config_file)

     

       435
       435
       -
       

     

       436
       436
       -
               # Initialize Git store

     

       437
       437
       -
               git_store = GitStore(config.git_store)

     

       438
       438
       -
       

     

       439
       439
       -
               # Build thread graph

     

       440
       440
       -
               console.print("Building thread graph...")

     

       441
       441
       -
               graph = build_thread_graph(git_store)

     

       442
       442
       -
       

     

       443
       443
       -
               # Get statistics

     

       444
       444
       -
               components = graph.get_connected_components()

     

       445
       445
       -
               threads = [c for c in components if len(c) > 1]

     

       446
       446
       -
               standalone = graph.get_standalone_entries()

     

       447
       447
       -
       

     

       448
       448
       -
               console.print(

     

       449
       449
       -
                   f"\n[green]Found {len(threads)} threads and {len(standalone)} standalone posts[/green]"

     

       450
       450
       -
               )

     

       451
       451
       -
       

     

       452
       452
       -
               if web:

     

       453
       453
       -
                   # Launch web server with D3 visualization

     

       454
       454
       -
                   _launch_web_server(graph, port)

     

       455
       455
       -
               elif interactive and threads:

     

       456
       456
       -
                   # Launch terminal UI

     

       457
       457
       -
                   app = ThreadBrowserApp(graph)

     

       458
       458
       -
                   app.run()

     

       459
       459
       -
               else:

     

       460
       460
       -
                   # Display in console

     

       461
       461
       -
                   if get_tsv_mode():

     

       462
       462
       -
                       _display_threads_tsv(graph, threads)

     

       463
       463
       -
                   else:

     

       464
       464
       -
                       _display_threads_rich(graph, threads)

     

       465
       465
       -
       

     

       466
       466
       -
           except Exception as e:

     

       467
       467
       -
               console.print(f"[red]Error building threads: {e}[/red]")

     

       468
       468
       -
               raise typer.Exit(1)

     

       469
       469
       -
       

     

       470
       470
       -
       

     

       471
       471
       -
       def _display_threads_rich(graph: ThreadGraph, threads: List[Set[str]]) -> None:

     

       472
       472
       -
           """Display threads using rich formatting."""

     

       473
       473
       -
           for i, thread in enumerate(threads[:10]):  # Show first 10 threads

     

       474
       474
       -
               sorted_ids = graph.sort_component_chronologically(thread)

     

       475
       475
       -
       

     

       476
       476
       -
               console.print(f"\n[bold]Thread {i + 1}[/bold] ({len(thread)} posts)")

     

       477
       477
       -
       

     

       478
       478
       -
               for j, entry_id in enumerate(sorted_ids):

     

       479
       479
       -
                   node = graph.nodes.get(entry_id)

     

       480
       480
       -
                   if node:

     

       481
       481
       -
                       date_str = node.published_date.strftime("%Y-%m-%d")

     

       482
       482
       -
                       indent = "  " * min(j, 3)  # Max 3 levels of indent

     

       483
       483
       -
                       console.print(f"{indent}• [{node.username}] {node.title} ({date_str})")

     

       484
       484
       -
       

     

       485
       485
       -
                       # Show link types

     

       486
       486
       -
                       if node.outbound_links:

     

       487
       487
       -
                           link_summary = {}

     

       488
       488
       -
                           for _, link_type in node.outbound_links:

     

       489
       489
       -
                               link_summary[link_type] = link_summary.get(link_type, 0) + 1

     

       490
       490
       -
       

     

       491
       491
       -
                           link_str = ", ".join(

     

       492
       492
       -
                               [f"{t.value}:{c}" for t, c in link_summary.items()]

     

       493
       493
       -
                           )

     

       494
       494
       -
                           console.print(f"{indent}  → Links: {link_str}")

     

       495
       495
       -
       

     

       496
       496
       -
       

     

       497
       497
       -
       def _display_threads_tsv(graph: ThreadGraph, threads: List[Set[str]]) -> None:

     

       498
       498
       -
           """Display threads in TSV format."""

     

       499
       499
       -
           print("Thread\tSize\tFirst Post\tLast Post\tUsers")

     

       500
       500
       -
       

     

       501
       501
       -
           for i, thread in enumerate(threads):

     

       502
       502
       -
               sorted_ids = graph.sort_component_chronologically(thread)

     

       503
       503
       -
       

     

       504
       504
       -
               if sorted_ids:

     

       505
       505
       -
                   first_node = graph.nodes.get(sorted_ids[0])

     

       506
       506
       -
                   last_node = graph.nodes.get(sorted_ids[-1])

     

       507
       507
       -
       

     

       508
       508
       -
                   users = set()

     

       509
       509
       -
                   for entry_id in thread:

     

       510
       510
       -
                       node = graph.nodes.get(entry_id)

     

       511
       511
       -
                       if node:

     

       512
       512
       -
                           users.add(node.username)

     

       513
       513
       -
       

     

       514
       514
       -
                   if first_node and last_node:

     

       515
       515
       -
                       print(

     

       516
       516
       -
                           f"{i + 1}\t{len(thread)}\t{first_node.published_date.strftime('%Y-%m-%d')}\t{last_node.published_date.strftime('%Y-%m-%d')}\t{','.join(users)}"

     

       517
       517
       -
                       )

     

       518
       518
       -
       

     

       519
       519
       -
       

     

       520
       520
       -
       def _build_graph_json(graph: ThreadGraph) -> dict:

     

       521
       521
       -
           """Convert ThreadGraph to JSON format for D3 visualization."""

     

       522
       522
       -
           nodes = []

     

       523
       523
       -
           links = []

     

       524
       524
       -
           

     

       525
       525
       -
           # Color mapping for different users

     

       526
       526
       -
           user_colors = {}

     

       527
       527
       -
           colors = [

     

       528
       528
       -
               "#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd", 

     

       529
       529
       -
               "#8c564b", "#e377c2", "#7f7f7f", "#bcbd22", "#17becf",

     

       530
       530
       -
               "#aec7e8", "#ffbb78", "#98df8a", "#ff9896", "#c5b0d5"

     

       531
       531
       -
           ]

     

       532
       532
       -
           

     

       533
       533
       -
           # Assign colors to users

     

       534
       534
       -
           for i, username in enumerate(set(node.username for node in graph.nodes.values())):

     

       535
       535
       -
               user_colors[username] = colors[i % len(colors)]

     

       536
       536
       -
           

     

       537
       537
       -
           # Create nodes

     

       538
       538
       -
           for entry_id, node in graph.nodes.items():

     

       539
       539
       -
               nodes.append({

     

       540
       540
       -
                   "id": entry_id,

     

       541
       541
       -
                   "title": node.title,

     

       542
       542
       -
                   "username": node.username,

     

       543
       543
       -
                   "date": node.published_date.strftime("%Y-%m-%d"),

     

       544
       544
       -
                   "summary": node.summary,

     

       545
       545
       -
                   "color": user_colors[node.username],

     

       546
       546
       -
                   "outbound_count": len(node.outbound_links),

     

       547
       547
       -
                   "backlink_count": len(node.inbound_backlinks),

     

       548
       548
       -
                   "link_types": {

     

       549
       549
       -
                       "self": len([l for l in node.outbound_links if l[1] == LinkType.SELF_REFERENCE]),

     

       550
       550
       -
                       "user": len([l for l in node.outbound_links if l[1] == LinkType.USER_REFERENCE]),

     

       551
       551
       -
                       "external": len([l for l in node.outbound_links if l[1] == LinkType.EXTERNAL])

     

       552
       552
       -
                   }

     

       553
       553
       -
               })

     

       554
       554
       -
           

     

       555
       555
       -
           # Create links (only for links between tracked entries)

     

       556
       556
       -
           for entry_id, node in graph.nodes.items():

     

       557
       557
       -
               for url, link_type in node.outbound_links:

     

       558
       558
       -
                   if url in graph.url_to_entry:

     

       559
       559
       -
                       target_id = graph.url_to_entry[url]

     

       560
       560
       -
                       if target_id in graph.nodes:

     

       561
       561
       -
                           links.append({

     

       562
       562
       -
                               "source": entry_id,

     

       563
       563
       -
                               "target": target_id,

     

       564
       564
       -
                               "type": link_type.value,

     

       565
       565
       -
                               "url": url

     

       566
       566
       -
                           })

     

       567
       567
       -
           

     

       568
       568
       -
           return {

     

       569
       569
       -
               "nodes": nodes,

     

       570
       570
       -
               "links": links,

     

       571
       571
       -
               "stats": {

     

       572
       572
       -
                   "total_nodes": len(nodes),

     

       573
       573
       -
                   "total_links": len(links),

     

       574
       574
       -
                   "users": list(user_colors.keys()),

     

       575
       575
       -
                   "user_colors": user_colors

     

       576
       576
       -
               }

     

       577
       577
       -
           }

     

       578
       578
       -
       

     

       579
       579
       -
       

     

       580
       580
       -
       def _launch_web_server(graph: ThreadGraph, port: int) -> None:

     

       581
       581
       -
           """Launch Flask web server with D3 force graph visualization."""

     

       582
       582
       -
           flask_app = Flask(__name__)

     

       583
       583
       -
           

     

       584
       584
       -
           # Store graph data globally for the Flask app

     

       585
       585
       -
           graph_data = _build_graph_json(graph)

     

       586
       586
       -
           

     

       587
       587
       -
           @flask_app.route('/')

     

       588
       588
       -
           def index():

     

       589
       589
       -
               """Serve the main visualization page."""

     

       590
       590
       -
               return render_template_string(HTML_TEMPLATE, port=port)

     

       591
       591
       -
           

     

       592
       592
       -
           @flask_app.route('/api/graph')

     

       593
       593
       -
           def api_graph():

     

       594
       594
       -
               """API endpoint to serve graph data as JSON."""

     

       595
       595
       -
               return jsonify(graph_data)

     

       596
       596
       -
           

     

       597
       597
       -
           # Disable Flask logging in development mode

     

       598
       598
       -
           import logging

     

       599
       599
       -
           log = logging.getLogger('werkzeug')

     

       600
       600
       -
           log.setLevel(logging.ERROR)

     

       601
       601
       -
           

     

       602
       602
       -
           def open_browser():

     

       603
       603
       -
               """Open browser after a short delay."""

     

       604
       604
       -
               time.sleep(1.5)

     

       605
       605
       -
               webbrowser.open(f'http://localhost:{port}')

     

       606
       606
       -
           

     

       607
       607
       -
           # Start browser in a separate thread

     

       608
       608
       -
           browser_thread = threading.Thread(target=open_browser)

     

       609
       609
       -
           browser_thread.daemon = True

     

       610
       610
       -
           browser_thread.start()

     

       611
       611
       -
           

     

       612
       612
       -
           console.print(f"\n[green]Starting web server at http://localhost:{port}[/green]")

     

       613
       613
       -
           console.print("[yellow]Press Ctrl+C to stop the server[/yellow]")

     

       614
       614
       -
           

     

       615
       615
       -
           try:

     

       616
       616
       -
               flask_app.run(host='0.0.0.0', port=port, debug=False)

     

       617
       617
       -
           except KeyboardInterrupt:

     

       618
       618
       -
               console.print("\n[green]Server stopped[/green]")

     

       619
       619
       -
       

     

       620
       620
       -
       

     

       621
       621
       -
       # HTML template for D3 force graph visualization

     

       622
       622
       -
       HTML_TEMPLATE = """

     

       623
       623
       -
       <!DOCTYPE html>

     

       624
       624
       -
       <html lang="en">

     

       625
       625
       -
       <head>

     

       626
       626
       -
           <meta charset="UTF-8">

     

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

     

       628
       628
       -
           <title>Thicket Thread Graph Visualization</title>

     

       629
       629
       -
           <script src="https://d3js.org/d3.v7.min.js"></script>

     

       630
       630
       -
           <style>

     

       631
       631
       -
               body {

     

       632
       632
       -
                   font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;

     

       633
       633
       -
                   margin: 0;

     

       634
       634
       -
                   padding: 20px;

     

       635
       635
       -
                   background-color: #f5f5f5;

     

       636
       636
       -
               }

     

       637
       637
       -
               

     

       638
       638
       -
               .header {

     

       639
       639
       -
                   text-align: center;

     

       640
       640
       -
                   margin-bottom: 20px;

     

       641
       641
       -
               }

     

       642
       642
       -
               

     

       643
       643
       -
               h1 {

     

       644
       644
       -
                   color: #333;

     

       645
       645
       -
                   margin-bottom: 10px;

     

       646
       646
       -
               }

     

       647
       647
       -
               

     

       648
       648
       -
               .controls {

     

       649
       649
       -
                   display: flex;

     

       650
       650
       -
                   justify-content: center;

     

       651
       651
       -
                   gap: 15px;

     

       652
       652
       -
                   margin-bottom: 20px;

     

       653
       653
       -
                   flex-wrap: wrap;

     

       654
       654
       -
               }

     

       655
       655
       -
               

     

       656
       656
       -
               .control-group {

     

       657
       657
       -
                   display: flex;

     

       658
       658
       -
                   align-items: center;

     

       659
       659
       -
                   gap: 5px;

     

       660
       660
       -
               }

     

       661
       661
       -
               

     

       662
       662
       -
               select, input[type="range"] {

     

       663
       663
       -
                   padding: 5px;

     

       664
       664
       -
                   border: 1px solid #ddd;

     

       665
       665
       -
                   border-radius: 4px;

     

       666
       666
       -
               }

     

       667
       667
       -
               

     

       668
       668
       -
               .stats {

     

       669
       669
       -
                   display: flex;

     

       670
       670
       -
                   justify-content: center;

     

       671
       671
       -
                   gap: 20px;

     

       672
       672
       -
                   margin-bottom: 20px;

     

       673
       673
       -
                   font-size: 14px;

     

       674
       674
       -
                   color: #666;

     

       675
       675
       -
               }

     

       676
       676
       -
               

     

       677
       677
       -
               .stat-item {

     

       678
       678
       -
                   background: white;

     

       679
       679
       -
                   padding: 10px 15px;

     

       680
       680
       -
                   border-radius: 6px;

     

       681
       681
       -
                   box-shadow: 0 2px 4px rgba(0,0,0,0.1);

     

       682
       682
       -
               }

     

       683
       683
       -
               

     

       684
       684
       -
               #graph-container {

     

       685
       685
       -
                   background: white;

     

       686
       686
       -
                   border-radius: 8px;

     

       687
       687
       -
                   box-shadow: 0 4px 6px rgba(0,0,0,0.1);

     

       688
       688
       -
                   overflow: hidden;

     

       689
       689
       -
               }

     

       690
       690
       -
               

     

       691
       691
       -
               #graph {

     

       692
       692
       -
                   cursor: grab;

     

       693
       693
       -
               }

     

       694
       694
       -
               

     

       695
       695
       -
               #graph:active {

     

       696
       696
       -
                   cursor: grabbing;

     

       697
       697
       -
               }

     

       698
       698
       -
               

     

       699
       699
       -
               .node {

     

       700
       700
       -
                   stroke: #fff;

     

       701
       701
       -
                   stroke-width: 1.5px;

     

       702
       702
       -
                   cursor: pointer;

     

       703
       703
       -
               }

     

       704
       704
       -
               

     

       705
       705
       -
               .node:hover {

     

       706
       706
       -
                   stroke: #333;

     

       707
       707
       -
                   stroke-width: 2px;

     

       708
       708
       -
               }

     

       709
       709
       -
               

     

       710
       710
       -
               .link {

     

       711
       711
       -
                   stroke: #999;

     

       712
       712
       -
                   stroke-opacity: 0.6;

     

       713
       713
       -
                   stroke-width: 1px;

     

       714
       714
       -
               }

     

       715
       715
       -
               

     

       716
       716
       -
               .link.self-link {

     

       717
       717
       -
                   stroke: #2ca02c;

     

       718
       718
       -
               }

     

       719
       719
       -
               

     

       720
       720
       -
               .link.user-link {

     

       721
       721
       -
                   stroke: #ff7f0e;

     

       722
       722
       -
               }

     

       723
       723
       -
               

     

       724
       724
       -
               .link.external-link {

     

       725
       725
       -
                   stroke: #d62728;

     

       726
       726
       -
               }

     

       727
       727
       -
               

     

       728
       728
       -
               .tooltip {

     

       729
       729
       -
                   position: absolute;

     

       730
       730
       -
                   background: rgba(0, 0, 0, 0.9);

     

       731
       731
       -
                   color: white;

     

       732
       732
       -
                   padding: 10px;

     

       733
       733
       -
                   border-radius: 4px;

     

       734
       734
       -
                   font-size: 12px;

     

       735
       735
       -
                   line-height: 1.4;

     

       736
       736
       -
                   pointer-events: none;

     

       737
       737
       -
                   z-index: 1000;

     

       738
       738
       -
                   max-width: 300px;

     

       739
       739
       -
               }

     

       740
       740
       -
               

     

       741
       741
       -
               .legend {

     

       742
       742
       -
                   position: fixed;

     

       743
       743
       -
                   top: 20px;

     

       744
       744
       -
                   right: 20px;

     

       745
       745
       -
                   background: white;

     

       746
       746
       -
                   padding: 15px;

     

       747
       747
       -
                   border-radius: 6px;

     

       748
       748
       -
                   box-shadow: 0 2px 8px rgba(0,0,0,0.15);

     

       749
       749
       -
                   font-size: 12px;

     

       750
       750
       -
                   z-index: 100;

     

       751
       751
       -
               }

     

       752
       752
       -
               

     

       753
       753
       -
               .legend h3 {

     

       754
       754
       -
                   margin: 0 0 10px 0;

     

       755
       755
       -
                   font-size: 14px;

     

       756
       756
       -
                   color: #333;

     

       757
       757
       -
               }

     

       758
       758
       -
               

     

       759
       759
       -
               .legend-item {

     

       760
       760
       -
                   display: flex;

     

       761
       761
       -
                   align-items: center;

     

       762
       762
       -
                   margin-bottom: 5px;

     

       763
       763
       -
               }

     

       764
       764
       -
               

     

       765
       765
       -
               .legend-color {

     

       766
       766
       -
                   width: 12px;

     

       767
       767
       -
                   height: 12px;

     

       768
       768
       -
                   margin-right: 8px;

     

       769
       769
       -
                   border-radius: 2px;

     

       770
       770
       -
               }

     

       771
       771
       -
               

     

       772
       772
       -
               .legend-line {

     

       773
       773
       -
                   width: 20px;

     

       774
       774
       -
                   height: 2px;

     

       775
       775
       -
                   margin-right: 8px;

     

       776
       776
       -
               }

     

       777
       777
       -
           </style>

     

       778
       778
       -
       </head>

     

       779
       779
       -
       <body>

     

       780
       780
       -
           <div class="header">

     

       781
       781
       -
               <h1>Thicket Thread Graph Visualization</h1>

     

       782
       782
       -
               <p>Interactive visualization of blog post connections and conversations</p>

     

       783
       783
       -
           </div>

     

       784
       784
       -
           

     

       785
       785
       -
           <div class="controls">

     

       786
       786
       -
               <div class="control-group">

     

       787
       787
       -
                   <label for="userFilter">Filter by user:</label>

     

       788
       788
       -
                   <select id="userFilter">

     

       789
       789
       -
                       <option value="all">All Users</option>

     

       790
       790
       -
                   </select>

     

       791
       791
       -
               </div>

     

       792
       792
       -
               

     

       793
       793
       -
               <div class="control-group">

     

       794
       794
       -
                   <label for="linkFilter">Show links:</label>

     

       795
       795
       -
                   <select id="linkFilter">

     

       796
       796
       -
                       <option value="all">All Links</option>

     

       797
       797
       -
                       <option value="user">User Links Only</option>

     

       798
       798
       -
                       <option value="self">Self Links Only</option>

     

       799
       799
       -
                       <option value="external">External Links Only</option>

     

       800
       800
       -
                   </select>

     

       801
       801
       -
               </div>

     

       802
       802
       -
               

     

       803
       803
       -
               <div class="control-group">

     

       804
       804
       -
                   <label for="forceStrength">Force Strength:</label>

     

       805
       805
       -
                   <input type="range" id="forceStrength" min="0.1" max="2" step="0.1" value="0.3">

     

       806
       806
       -
               </div>

     

       807
       807
       -
               

     

       808
       808
       -
               <div class="control-group">

     

       809
       809
       -
                   <label for="nodeSize">Node Size:</label>

     

       810
       810
       -
                   <input type="range" id="nodeSize" min="3" max="15" step="1" value="6">

     

       811
       811
       -
               </div>

     

       812
       812
       -
           </div>

     

       813
       813
       -
           

     

       814
       814
       -
           <div class="stats" id="stats"></div>

     

       815
       815
       -
           

     

       816
       816
       -
           <div id="graph-container">

     

       817
       817
       -
               <svg id="graph"></svg>

     

       818
       818
       -
           </div>

     

       819
       819
       -
           

     

       820
       820
       -
           <div class="legend">

     

       821
       821
       -
               <h3>Link Types</h3>

     

       822
       822
       -
               <div class="legend-item">

     

       823
       823
       -
                   <div class="legend-line" style="background: #2ca02c;"></div>

     

       824
       824
       -
                   <span>Self References</span>

     

       825
       825
       -
               </div>

     

       826
       826
       -
               <div class="legend-item">

     

       827
       827
       -
                   <div class="legend-line" style="background: #ff7f0e;"></div>

     

       828
       828
       -
                   <span>User References</span>

     

       829
       829
       -
               </div>

     

       830
       830
       -
               <div class="legend-item">

     

       831
       831
       -
                   <div class="legend-line" style="background: #d62728;"></div>

     

       832
       832
       -
                   <span>External References</span>

     

       833
       833
       -
               </div>

     

       834
       834
       -
               

     

       835
       835
       -
               <h3 style="margin-top: 15px;">Interactions</h3>

     

       836
       836
       -
               <div style="font-size: 11px; color: #666;">

     

       837
       837
       -
                   • Hover: Show details<br>

     

       838
       838
       -
                   • Click: Pin/unpin node<br>

     

       839
       839
       -
                   • Drag: Move nodes<br>

     

       840
       840
       -
                   • Zoom: Mouse wheel

     

       841
       841
       -
               </div>

     

       842
       842
       -
           </div>

     

       843
       843
       -
           

     

       844
       844
       -
           <div class="tooltip" id="tooltip" style="display: none;"></div>

     

       845
       845
       -
       

     

       846
       846
       -
           <script>

     

       847
       847
       -
               let graphData;

     

       848
       848
       -
               let simulation;

     

       849
       849
       -
               let svg, g, link, node;

     

       850
       850
       -
               let width = window.innerWidth - 40;

     

       851
       851
       -
               let height = window.innerHeight - 200;

     

       852
       852
       -
               

     

       853
       853
       -
               // Initialize the visualization

     

       854
       854
       -
               async function init() {

     

       855
       855
       -
                   // Fetch graph data

     

       856
       856
       -
                   const response = await fetch('/api/graph');

     

       857
       857
       -
                   graphData = await response.json();

     

       858
       858
       -
                   

     

       859
       859
       -
                   // Set up SVG

     

       860
       860
       -
                   svg = d3.select("#graph")

     

       861
       861
       -
                       .attr("width", width)

     

       862
       862
       -
                       .attr("height", height);

     

       863
       863
       -
                       

     

       864
       864
       -
                   // Add zoom behavior

     

       865
       865
       -
                   const zoom = d3.zoom()

     

       866
       866
       -
                       .scaleExtent([0.1, 4])

     

       867
       867
       -
                       .on("zoom", (event) => {

     

       868
       868
       -
                           g.attr("transform", event.transform);

     

       869
       869
       -
                       });

     

       870
       870
       -
                   

     

       871
       871
       -
                   svg.call(zoom);

     

       872
       872
       -
                   

     

       873
       873
       -
                   // Create main group for all elements

     

       874
       874
       -
                   g = svg.append("g");

     

       875
       875
       -
                   

     

       876
       876
       -
                   // Set up controls

     

       877
       877
       -
                   setupControls();

     

       878
       878
       -
                   

     

       879
       879
       -
                   // Initial render

     

       880
       880
       -
                   updateVisualization();

     

       881
       881
       -
                   

     

       882
       882
       -
                   // Update stats

     

       883
       883
       -
                   updateStats();

     

       884
       884
       -
                   

     

       885
       885
       -
                   // Handle window resize

     

       886
       886
       -
                   window.addEventListener('resize', () => {

     

       887
       887
       -
                       width = window.innerWidth - 40;

     

       888
       888
       -
                       height = window.innerHeight - 200;

     

       889
       889
       -
                       svg.attr("width", width).attr("height", height);

     

       890
       890
       -
                       simulation.force("center", d3.forceCenter(width / 2, height / 2));

     

       891
       891
       -
                       simulation.restart();

     

       892
       892
       -
                   });

     

       893
       893
       -
               }

     

       894
       894
       -
               

     

       895
       895
       -
               function setupControls() {

     

       896
       896
       -
                   // Populate user filter

     

       897
       897
       -
                   const userFilter = d3.select("#userFilter");

     

       898
       898
       -
                   graphData.stats.users.forEach(user => {

     

       899
       899
       -
                       userFilter.append("option").attr("value", user).text(user);

     

       900
       900
       -
                   });

     

       901
       901
       -
                   

     

       902
       902
       -
                   // Add event listeners

     

       903
       903
       -
                   d3.select("#userFilter").on("change", updateVisualization);

     

       904
       904
       -
                   d3.select("#linkFilter").on("change", updateVisualization);

     

       905
       905
       -
                   d3.select("#forceStrength").on("input", updateForces);

     

       906
       906
       -
                   d3.select("#nodeSize").on("input", updateNodeSizes);

     

       907
       907
       -
               }

     

       908
       908
       -
               

     

       909
       909
       -
               function updateVisualization() {

     

       910
       910
       -
                   // Filter data based on controls

     

       911
       911
       -
                   const userFilter = d3.select("#userFilter").property("value");

     

       912
       912
       -
                   const linkFilter = d3.select("#linkFilter").property("value");

     

       913
       913
       -
                   

     

       914
       914
       -
                   let filteredNodes = graphData.nodes;

     

       915
       915
       -
                   let filteredLinks = graphData.links;

     

       916
       916
       -
                   

     

       917
       917
       -
                   if (userFilter !== "all") {

     

       918
       918
       -
                       filteredNodes = graphData.nodes.filter(n => n.username === userFilter);

     

       919
       919
       -
                       const nodeIds = new Set(filteredNodes.map(n => n.id));

     

       920
       920
       -
                       filteredLinks = graphData.links.filter(l => 

     

       921
       921
       -
                           nodeIds.has(l.source.id || l.source) && nodeIds.has(l.target.id || l.target)

     

       922
       922
       -
                       );

     

       923
       923
       -
                   }

     

       924
       924
       -
                   

     

       925
       925
       -
                   if (linkFilter !== "all") {

     

       926
       926
       -
                       filteredLinks = filteredLinks.filter(l => l.type === linkFilter);

     

       927
       927
       -
                   }

     

       928
       928
       -
                   

     

       929
       929
       -
                   // Clear existing elements

     

       930
       930
       -
                   g.selectAll(".link").remove();

     

       931
       931
       -
                   g.selectAll(".node").remove();

     

       932
       932
       -
                   

     

       933
       933
       -
                   // Create force simulation

     

       934
       934
       -
                   simulation = d3.forceSimulation(filteredNodes)

     

       935
       935
       -
                       .force("link", d3.forceLink(filteredLinks).id(d => d.id)

     

       936
       936
       -
                           .distance(d => {

     

       937
       937
       -
                               // Get source and target nodes

     

       938
       938
       -
                               const sourceNode = filteredNodes.find(n => n.id === (d.source.id || d.source));

     

       939
       939
       -
                               const targetNode = filteredNodes.find(n => n.id === (d.target.id || d.target));

     

       940
       940
       -
                               

     

       941
       941
       -
                               // If nodes are from different users, make them attract more (shorter distance)

     

       942
       942
       -
                               if (sourceNode && targetNode && sourceNode.username !== targetNode.username) {

     

       943
       943
       -
                                   return 30; // Shorter distance = stronger attraction

     

       944
       944
       -
                               }

     

       945
       945
       -
                               

     

       946
       946
       -
                               // Same user posts have normal distance

     

       947
       947
       -
                               return 60;

     

       948
       948
       -
                           })

     

       949
       949
       -
                           .strength(d => {

     

       950
       950
       -
                               // Get source and target nodes

     

       951
       951
       -
                               const sourceNode = filteredNodes.find(n => n.id === (d.source.id || d.source));

     

       952
       952
       -
                               const targetNode = filteredNodes.find(n => n.id === (d.target.id || d.target));

     

       953
       953
       -
                               

     

       954
       954
       -
                               // If nodes are from different users, make the link stronger

     

       955
       955
       -
                               if (sourceNode && targetNode && sourceNode.username !== targetNode.username) {

     

       956
       956
       -
                                   return 1.5; // Stronger link force

     

       957
       957
       -
                               }

     

       958
       958
       -
                               

     

       959
       959
       -
                               // Same user posts have normal strength

     

       960
       960
       -
                               return 1.0;

     

       961
       961
       -
                           }))

     

       962
       962
       -
                       .force("charge", d3.forceManyBody().strength(-200))

     

       963
       963
       -
                       .force("center", d3.forceCenter(width / 2, height / 2))

     

       964
       964
       -
                       .force("collision", d3.forceCollide().radius(15));

     

       965
       965
       -
                   

     

       966
       966
       -
                   // Create links

     

       967
       967
       -
                   link = g.append("g")

     

       968
       968
       -
                       .selectAll(".link")

     

       969
       969
       -
                       .data(filteredLinks)

     

       970
       970
       -
                       .enter().append("line")

     

       971
       971
       -
                       .attr("class", d => `link ${d.type}-link`)

     

       972
       972
       -
                       .attr("stroke-width", d => {

     

       973
       973
       -
                           // Get source and target nodes

     

       974
       974
       -
                           const sourceNode = filteredNodes.find(n => n.id === (d.source.id || d.source));

     

       975
       975
       -
                           const targetNode = filteredNodes.find(n => n.id === (d.target.id || d.target));

     

       976
       976
       -
                           

     

       977
       977
       -
                           // If nodes are from different users, make the line thicker

     

       978
       978
       -
                           if (sourceNode && targetNode && sourceNode.username !== targetNode.username) {

     

       979
       979
       -
                               return 2.5; // Thicker line for cross-user connections

     

       980
       980
       -
                           }

     

       981
       981
       -
                           

     

       982
       982
       -
                           // Same user posts have normal thickness

     

       983
       983
       -
                           return 1;

     

       984
       984
       -
                       });

     

       985
       985
       -
                   

     

       986
       986
       -
                   // Create nodes

     

       987
       987
       -
                   node = g.append("g")

     

       988
       988
       -
                       .selectAll(".node")

     

       989
       989
       -
                       .data(filteredNodes)

     

       990
       990
       -
                       .enter().append("circle")

     

       991
       991
       -
                       .attr("class", "node")

     

       992
       992
       -
                       .attr("r", d => Math.max(4, Math.log(d.outbound_count + d.backlink_count + 1) * 3))

     

       993
       993
       -
                       .attr("fill", d => d.color)

     

       994
       994
       -
                       .call(d3.drag()

     

       995
       995
       -
                           .on("start", dragstarted)

     

       996
       996
       -
                           .on("drag", dragged)

     

       997
       997
       -
                           .on("end", dragended))

     

       998
       998
       -
                       .on("mouseover", showTooltip)

     

       999
       999
       -
                       .on("mouseout", hideTooltip)

     

       1000
       1000
       -
                       .on("click", togglePin);

     

       1001
       1001
       -
                   

     

       1002
       1002
       -
                   // Update force simulation

     

       1003
       1003
       -
                   simulation.on("tick", () => {

     

       1004
       1004
       -
                       link

     

       1005
       1005
       -
                           .attr("x1", d => d.source.x)

     

       1006
       1006
       -
                           .attr("y1", d => d.source.y)

     

       1007
       1007
       -
                           .attr("x2", d => d.target.x)

     

       1008
       1008
       -
                           .attr("y2", d => d.target.y);

     

       1009
       1009
       -
                       

     

       1010
       1010
       -
                       node

     

       1011
       1011
       -
                           .attr("cx", d => d.x)

     

       1012
       1012
       -
                           .attr("cy", d => d.y);

     

       1013
       1013
       -
                   });

     

       1014
       1014
       -
                   

     

       1015
       1015
       -
                   updateStats(filteredNodes, filteredLinks);

     

       1016
       1016
       -
               }

     

       1017
       1017
       -
               

     

       1018
       1018
       -
               function updateForces() {

     

       1019
       1019
       -
                   const strength = +d3.select("#forceStrength").property("value");

     

       1020
       1020
       -
                   if (simulation) {

     

       1021
       1021
       -
                       simulation.force("charge").strength(-200 * strength);

     

       1022
       1022
       -
                       simulation.alpha(0.3).restart();

     

       1023
       1023
       -
                   }

     

       1024
       1024
       -
               }

     

       1025
       1025
       -
               

     

       1026
       1026
       -
               function updateNodeSizes() {

     

       1027
       1027
       -
                   const size = +d3.select("#nodeSize").property("value");

     

       1028
       1028
       -
                   if (node) {

     

       1029
       1029
       -
                       node.attr("r", d => Math.max(size * 0.5, Math.log(d.outbound_count + d.backlink_count + 1) * size * 0.5));

     

       1030
       1030
       -
                   }

     

       1031
       1031
       -
               }

     

       1032
       1032
       -
               

     

       1033
       1033
       -
               function dragstarted(event, d) {

     

       1034
       1034
       -
                   if (!event.active) simulation.alphaTarget(0.3).restart();

     

       1035
       1035
       -
                   d.fx = d.x;

     

       1036
       1036
       -
                   d.fy = d.y;

     

       1037
       1037
       -
               }

     

       1038
       1038
       -
               

     

       1039
       1039
       -
               function dragged(event, d) {

     

       1040
       1040
       -
                   d.fx = event.x;

     

       1041
       1041
       -
                   d.fy = event.y;

     

       1042
       1042
       -
               }

     

       1043
       1043
       -
               

     

       1044
       1044
       -
               function dragended(event, d) {

     

       1045
       1045
       -
                   if (!event.active) simulation.alphaTarget(0);

     

       1046
       1046
       -
                   if (!d.pinned) {

     

       1047
       1047
       -
                       d.fx = null;

     

       1048
       1048
       -
                       d.fy = null;

     

       1049
       1049
       -
                   }

     

       1050
       1050
       -
               }

     

       1051
       1051
       -
               

     

       1052
       1052
       -
               function togglePin(event, d) {

     

       1053
       1053
       -
                   d.pinned = !d.pinned;

     

       1054
       1054
       -
                   if (d.pinned) {

     

       1055
       1055
       -
                       d.fx = d.x;

     

       1056
       1056
       -
                       d.fy = d.y;

     

       1057
       1057
       -
                   } else {

     

       1058
       1058
       -
                       d.fx = null;

     

       1059
       1059
       -
                       d.fy = null;

     

       1060
       1060
       -
                   }

     

       1061
       1061
       -
               }

     

       1062
       1062
       -
               

     

       1063
       1063
       -
               function showTooltip(event, d) {

     

       1064
       1064
       -
                   const tooltip = d3.select("#tooltip");

     

       1065
       1065
       -
                   tooltip.style("display", "block")

     

       1066
       1066
       -
                       .html(`

     

       1067
       1067
       -
                           <strong>${d.title}</strong><br>

     

       1068
       1068
       -
                           <strong>User:</strong> ${d.username}<br>

     

       1069
       1069
       -
                           <strong>Date:</strong> ${d.date}<br>

     

       1070
       1070
       -
                           <strong>Outbound Links:</strong> ${d.outbound_count}<br>

     

       1071
       1071
       -
                           <strong>Backlinks:</strong> ${d.backlink_count}<br>

     

       1072
       1072
       -
                           <strong>Link Types:</strong> Self: ${d.link_types.self}, User: ${d.link_types.user}, External: ${d.link_types.external}

     

       1073
       1073
       -
                           ${d.summary ? '<br><br>' + d.summary : ''}

     

       1074
       1074
       -
                       `)

     

       1075
       1075
       -
                       .style("left", (event.pageX + 10) + "px")

     

       1076
       1076
       -
                       .style("top", (event.pageY - 10) + "px");

     

       1077
       1077
       -
               }

     

       1078
       1078
       -
               

     

       1079
       1079
       -
               function hideTooltip() {

     

       1080
       1080
       -
                   d3.select("#tooltip").style("display", "none");

     

       1081
       1081
       -
               }

     

       1082
       1082
       -
               

     

       1083
       1083
       -
               function updateStats(nodes = graphData.nodes, links = graphData.links) {

     

       1084
       1084
       -
                   const stats = d3.select("#stats");

     

       1085
       1085
       -
                   const userCounts = {};

     

       1086
       1086
       -
                   nodes.forEach(n => {

     

       1087
       1087
       -
                       userCounts[n.username] = (userCounts[n.username] || 0) + 1;

     

       1088
       1088
       -
                   });

     

       1089
       1089
       -
                   

     

       1090
       1090
       -
                   stats.html(`

     

       1091
       1091
       -
                       <div class="stat-item">

     

       1092
       1092
       -
                           <strong>${nodes.length}</strong> Nodes

     

       1093
       1093
       -
                       </div>

     

       1094
       1094
       -
                       <div class="stat-item">

     

       1095
       1095
       -
                           <strong>${links.length}</strong> Links

     

       1096
       1096
       -
                       </div>

     

       1097
       1097
       -
                       <div class="stat-item">

     

       1098
       1098
       -
                           <strong>${Object.keys(userCounts).length}</strong> Users

     

       1099
       1099
       -
                       </div>

     

       1100
       1100
       -
                       <div class="stat-item">

     

       1101
       1101
       -
                           Users: ${Object.entries(userCounts).map(([user, count]) => `${user} (${count})`).join(', ')}

     

       1102
       1102
       -
                       </div>

     

       1103
       1103
       -
                   `);

     

       1104
       1104
       -
               }

     

       1105
       1105
       -
               

     

       1106
       1106
       -
               // Initialize when page loads

     

       1107
       1107
       -
               init();

     

       1108
       1108
       -
           </script>

     

       1109
       1109
       -
       </body>

     

       1110
       1110
       -
       </html>

     

       1111
       1111
       -
       """

+1 -1

src/thicket/cli/main.py

···

       47
       47
        
       

     

       48
       48
        
       

     

       49
       49
        
       # Import commands to register them

     

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

     

       50
       50
       +
       from .commands import add, duplicates, info_cmd, init, list_cmd, sync  # noqa: F401

     

       51
       51
        
       

     

       52
       52
        
       if __name__ == "__main__":

     

       53
       53
        
           app()

+32 -20

src/thicket/cli/utils.py

···

       8
       8
        
       from rich.progress import Progress, SpinnerColumn, TextColumn

     

       9
       9
        
       from rich.table import Table

     

       10
       10
        
       

     

       11
       11
       -
       from ..models import ThicketConfig, UserMetadata

     

       12
       11
        
       from ..core.git_store import GitStore

     

       12
       12
       +
       from ..models import ThicketConfig, UserMetadata

     

       13
       13
        
       

     

       14
       14
        
       console = Console()

     

       15
       15
        
       

     
···

       17
       17
        
       def get_tsv_mode() -> bool:

     

       18
       18
        
           """Get the global TSV mode setting."""

     

       19
       19
        
           from .main import tsv_mode

     

       20
       20
       +
       

     

       20
       21
        
           return tsv_mode

     

       21
       22
        
       

     

       22
       23
        
       

     
···

       37
       38
        
               default_config = Path("thicket.yaml")

     

       38
       39
        
               if default_config.exists():

     

       39
       40
        
                   import yaml

     

       41
       41
       +
       

     

       40
       42
        
                   with open(default_config) as f:

     

       41
       43
        
                       config_data = yaml.safe_load(f)

     

       42
       44
        
                   return ThicketConfig(**config_data)

     

       43
       43
       -
               

     

       45
       45
       +
       

     

       44
       46
        
               # Fall back to environment variables

     

       45
       47
        
               return ThicketConfig()

     

       46
       48
        
           except Exception as e:

     

       47
       49
        
               console.print(f"[red]Error loading configuration: {e}[/red]")

     

       48
       48
       -
               console.print("[yellow]Run 'thicket init' to create a new configuration.[/yellow]")

     

       50
       50
       +
               console.print(

     

       51
       51
       +
                   "[yellow]Run 'thicket init' to create a new configuration.[/yellow]"

     

       52
       52
       +
               )

     

       49
       53
        
               raise typer.Exit(1) from e

     

       50
       54
        
       

     

       51
       55
        
       

     
···

       78
       82
        
           if get_tsv_mode():

     

       79
       83
        
               print_users_tsv(config)

     

       80
       84
        
               return

     

       81
       81
       -
               

     

       85
       85
       +
       

     

       82
       86
        
           table = Table(title="Users and Feeds")

     

       83
       87
        
           table.add_column("Username", style="cyan", no_wrap=True)

     

       84
       88
        
           table.add_column("Display Name", style="magenta")

     
···

       104
       108
        
           if get_tsv_mode():

     

       105
       109
        
               print_feeds_tsv(config, username)

     

       106
       110
        
               return

     

       107
       107
       -
               

     

       111
       111
       +
       

     

       108
       112
        
           table = Table(title=f"Feeds{f' for {username}' if username else ''}")

     

       109
       113
        
           table.add_column("Username", style="cyan", no_wrap=True)

     

       110
       114
        
           table.add_column("Feed URL", style="blue")

     
···

       154
       158
        
           if get_tsv_mode():

     

       155
       159
        
               print_users_tsv_from_git(users)

     

       156
       160
        
               return

     

       157
       157
       -
               

     

       161
       161
       +
       

     

       158
       162
        
           table = Table(title="Users and Feeds")

     

       159
       163
        
           table.add_column("Username", style="cyan", no_wrap=True)

     

       160
       164
        
           table.add_column("Display Name", style="magenta")

     
···

       175
       179
        
           console.print(table)

     

       176
       180
        
       

     

       177
       181
        
       

     

       178
       178
       -
       def print_feeds_table_from_git(git_store: GitStore, username: Optional[str] = None) -> None:

     

       182
       182
       +
       def print_feeds_table_from_git(

     

       183
       183
       +
           git_store: GitStore, username: Optional[str] = None

     

       184
       184
       +
       ) -> None:

     

       179
       185
        
           """Print a table of feeds from git repository."""

     

       180
       186
        
           if get_tsv_mode():

     

       181
       187
        
               print_feeds_tsv_from_git(git_store, username)

     

       182
       188
        
               return

     

       183
       183
       -
               

     

       189
       189
       +
       

     

       184
       190
        
           table = Table(title=f"Feeds{f' for {username}' if username else ''}")

     

       185
       191
        
           table.add_column("Username", style="cyan", no_wrap=True)

     

       186
       192
        
           table.add_column("Feed URL", style="blue")

     
···

       209
       215
        
           print("Username\tDisplay Name\tEmail\tHomepage\tFeeds")

     

       210
       216
        
           for user in config.users:

     

       211
       217
        
               feeds_str = ",".join(str(feed) for feed in user.feeds)

     

       212
       212
       -
               print(f"{user.username}\t{user.display_name or ''}\t{user.email or ''}\t{user.homepage or ''}\t{feeds_str}")

     

       218
       218
       +
               print(

     

       219
       219
       +
                   f"{user.username}\t{user.display_name or ''}\t{user.email or ''}\t{user.homepage or ''}\t{feeds_str}"

     

       220
       220
       +
               )

     

       213
       221
        
       

     

       214
       222
        
       

     

       215
       223
        
       def print_users_tsv_from_git(users: list[UserMetadata]) -> None:

     
···

       217
       225
        
           print("Username\tDisplay Name\tEmail\tHomepage\tFeeds")

     

       218
       226
        
           for user in users:

     

       219
       227
        
               feeds_str = ",".join(user.feeds)

     

       220
       220
       -
               print(f"{user.username}\t{user.display_name or ''}\t{user.email or ''}\t{user.homepage or ''}\t{feeds_str}")

     

       228
       228
       +
               print(

     

       229
       229
       +
                   f"{user.username}\t{user.display_name or ''}\t{user.email or ''}\t{user.homepage or ''}\t{feeds_str}"

     

       230
       230
       +
               )

     

       221
       231
        
       

     

       222
       232
        
       

     

       223
       233
        
       def print_feeds_tsv(config: ThicketConfig, username: Optional[str] = None) -> None:

     
···

       225
       235
        
           print("Username\tFeed URL\tStatus")

     

       226
       236
        
           users = [config.find_user(username)] if username else config.users

     

       227
       237
        
           users = [u for u in users if u is not None]

     

       228
       228
       -
           

     

       238
       238
       +
       

     

       229
       239
        
           for user in users:

     

       230
       240
        
               for feed in user.feeds:

     

       231
       241
        
                   print(f"{user.username}\t{feed}\tActive")

     

       232
       242
        
       

     

       233
       243
        
       

     

       234
       234
       -
       def print_feeds_tsv_from_git(git_store: GitStore, username: Optional[str] = None) -> None:

     

       244
       244
       +
       def print_feeds_tsv_from_git(

     

       245
       245
       +
           git_store: GitStore, username: Optional[str] = None

     

       246
       246
       +
       ) -> None:

     

       235
       247
        
           """Print feeds from git repository in TSV format."""

     

       236
       248
        
           print("Username\tFeed URL\tStatus")

     

       237
       237
       -
           

     

       249
       249
       +
       

     

       238
       250
        
           if username:

     

       239
       251
        
               user = git_store.get_user(username)

     

       240
       252
        
               users = [user] if user else []

     

       241
       253
        
           else:

     

       242
       254
        
               index = git_store._load_index()

     

       243
       255
        
               users = list(index.users.values())

     

       244
       244
       -
           

     

       256
       256
       +
       

     

       245
       257
        
           for user in users:

     

       246
       258
        
               for feed in user.feeds:

     

       247
       259
        
                   print(f"{user.username}\t{feed}\tActive")

     
···

       250
       262
        
       def print_entries_tsv(entries_by_user: list[list], usernames: list[str]) -> None:

     

       251
       263
        
           """Print entries in TSV format."""

     

       252
       264
        
           print("User\tAtom ID\tTitle\tUpdated\tURL")

     

       253
       253
       -
           

     

       265
       265
       +
       

     

       254
       266
        
           # Combine all entries with usernames

     

       255
       267
        
           all_entries = []

     

       256
       268
        
           for entries, username in zip(entries_by_user, usernames):

     

       257
       269
        
               for entry in entries:

     

       258
       270
        
                   all_entries.append((username, entry))

     

       259
       259
       -
           

     

       271
       271
       +
       

     

       260
       272
        
           # Sort by updated time (newest first)

     

       261
       273
        
           all_entries.sort(key=lambda x: x[1].updated, reverse=True)

     

       262
       262
       -
           

     

       274
       274
       +
       

     

       263
       275
        
           for username, entry in all_entries:

     

       264
       276
        
               # Format updated time

     

       265
       277
        
               updated_str = entry.updated.strftime("%Y-%m-%d %H:%M")

     

       266
       266
       -
               

     

       278
       278
       +
       

     

       267
       279
        
               # Escape tabs and newlines in title to preserve TSV format

     

       268
       268
       -
               title = entry.title.replace('\t', ' ').replace('\n', ' ').replace('\r', ' ')

     

       269
       269
       -
               

     

       280
       280
       +
               title = entry.title.replace("\t", " ").replace("\n", " ").replace("\r", " ")

     

       281
       281
       +
       

     

       270
       282
        
               print(f"{username}\t{entry.id}\t{title}\t{updated_str}\t{entry.link}")

+84 -55

src/thicket/core/feed_parser.py

···

       19
       19
        
               """Initialize the feed parser."""

     

       20
       20
        
               self.user_agent = user_agent

     

       21
       21
        
               self.allowed_tags = [

     

       22
       22
       -
                   "a", "abbr", "acronym", "b", "blockquote", "br", "code", "em",

     

       23
       23
       -
                   "i", "li", "ol", "p", "pre", "strong", "ul", "h1", "h2", "h3",

     

       24
       24
       -
                   "h4", "h5", "h6", "img", "div", "span",

     

       22
       22
       +
                   "a",

     

       23
       23
       +
                   "abbr",

     

       24
       24
       +
                   "acronym",

     

       25
       25
       +
                   "b",

     

       26
       26
       +
                   "blockquote",

     

       27
       27
       +
                   "br",

     

       28
       28
       +
                   "code",

     

       29
       29
       +
                   "em",

     

       30
       30
       +
                   "i",

     

       31
       31
       +
                   "li",

     

       32
       32
       +
                   "ol",

     

       33
       33
       +
                   "p",

     

       34
       34
       +
                   "pre",

     

       35
       35
       +
                   "strong",

     

       36
       36
       +
                   "ul",

     

       37
       37
       +
                   "h1",

     

       38
       38
       +
                   "h2",

     

       39
       39
       +
                   "h3",

     

       40
       40
       +
                   "h4",

     

       41
       41
       +
                   "h5",

     

       42
       42
       +
                   "h6",

     

       43
       43
       +
                   "img",

     

       44
       44
       +
                   "div",

     

       45
       45
       +
                   "span",

     

       25
       46
        
               ]

     

       26
       47
        
               self.allowed_attributes = {

     

       27
       48
        
                   "a": ["href", "title"],

     
···

       43
       64
        
                   response.raise_for_status()

     

       44
       65
        
                   return response.text

     

       45
       66
        
       

     

       46
       46
       -
           def parse_feed(self, content: str, source_url: Optional[HttpUrl] = None) -> tuple[FeedMetadata, list[AtomEntry]]:

     

       67
       67
       +
           def parse_feed(

     

       68
       68
       +
               self, content: str, source_url: Optional[HttpUrl] = None

     

       69
       69
       +
           ) -> tuple[FeedMetadata, list[AtomEntry]]:

     

       47
       70
        
               """Parse feed content and return metadata and entries."""

     

       48
       71
        
               parsed = feedparser.parse(content)

     

       49
       72
        
       

     
···

       74
       97
        
               author_email = None

     

       75
       98
        
               author_uri = None

     

       76
       99
        
       

     

       77
       77
       -
               if hasattr(feed, 'author_detail'):

     

       78
       78
       -
                   author_name = feed.author_detail.get('name')

     

       79
       79
       -
                   author_email = feed.author_detail.get('email')

     

       80
       80
       -
                   author_uri = feed.author_detail.get('href')

     

       81
       81
       -
               elif hasattr(feed, 'author'):

     

       100
       100
       +
               if hasattr(feed, "author_detail"):

     

       101
       101
       +
                   author_name = feed.author_detail.get("name")

     

       102
       102
       +
                   author_email = feed.author_detail.get("email")

     

       103
       103
       +
                   author_uri = feed.author_detail.get("href")

     

       104
       104
       +
               elif hasattr(feed, "author"):

     

       82
       105
        
                   author_name = feed.author

     

       83
       106
        
       

     

       84
       107
        
               # Parse managing editor for RSS feeds

     

       85
       85
       -
               if not author_email and hasattr(feed, 'managingEditor'):

     

       108
       108
       +
               if not author_email and hasattr(feed, "managingEditor"):

     

       86
       109
        
                   author_email = feed.managingEditor

     

       87
       110
        
       

     

       88
       111
        
               # Parse feed link

     

       89
       112
        
               feed_link = None

     

       90
       90
       -
               if hasattr(feed, 'link'):

     

       113
       113
       +
               if hasattr(feed, "link"):

     

       91
       114
        
                   try:

     

       92
       115
        
                       feed_link = HttpUrl(feed.link)

     

       93
       116
        
                   except ValidationError:

     
···

       98
       121
        
               icon = None

     

       99
       122
        
               image_url = None

     

       100
       123
        
       

     

       101
       101
       -
               if hasattr(feed, 'image'):

     

       124
       124
       +
               if hasattr(feed, "image"):

     

       102
       125
        
                   try:

     

       103
       103
       -
                       image_url = HttpUrl(feed.image.get('href', feed.image.get('url', '')))

     

       126
       126
       +
                       image_url = HttpUrl(feed.image.get("href", feed.image.get("url", "")))

     

       104
       127
        
                   except (ValidationError, AttributeError):

     

       105
       128
        
                       pass

     

       106
       129
        
       

     

       107
       107
       -
               if hasattr(feed, 'icon'):

     

       130
       130
       +
               if hasattr(feed, "icon"):

     

       108
       131
        
                   try:

     

       109
       132
        
                       icon = HttpUrl(feed.icon)

     

       110
       133
        
                   except ValidationError:

     

       111
       134
        
                       pass

     

       112
       135
        
       

     

       113
       113
       -
               if hasattr(feed, 'logo'):

     

       136
       136
       +
               if hasattr(feed, "logo"):

     

       114
       137
        
                   try:

     

       115
       138
        
                       logo = HttpUrl(feed.logo)

     

       116
       139
        
                   except ValidationError:

     

       117
       140
        
                       pass

     

       118
       141
        
       

     

       119
       142
        
               return FeedMetadata(

     

       120
       120
       -
                   title=getattr(feed, 'title', None),

     

       143
       143
       +
                   title=getattr(feed, "title", None),

     

       121
       144
        
                   author_name=author_name,

     

       122
       145
        
                   author_email=author_email,

     

       123
       146
        
                   author_uri=HttpUrl(author_uri) if author_uri else None,

     
···

       125
       148
        
                   logo=logo,

     

       126
       149
        
                   icon=icon,

     

       127
       150
        
                   image_url=image_url,

     

       128
       128
       -
                   description=getattr(feed, 'description', None),

     

       151
       151
       +
                   description=getattr(feed, "description", None),

     

       129
       152
        
               )

     

       130
       153
        
       

     

       131
       131
       -
           def _normalize_entry(self, entry: feedparser.FeedParserDict, source_url: Optional[HttpUrl] = None) -> AtomEntry:

     

       154
       154
       +
           def _normalize_entry(

     

       155
       155
       +
               self, entry: feedparser.FeedParserDict, source_url: Optional[HttpUrl] = None

     

       156
       156
       +
           ) -> AtomEntry:

     

       132
       157
        
               """Normalize an entry to Atom format."""

     

       133
       158
        
               # Parse timestamps

     

       134
       134
       -
               updated = self._parse_timestamp(entry.get('updated_parsed') or entry.get('published_parsed'))

     

       135
       135
       -
               published = self._parse_timestamp(entry.get('published_parsed'))

     

       159
       159
       +
               updated = self._parse_timestamp(

     

       160
       160
       +
                   entry.get("updated_parsed") or entry.get("published_parsed")

     

       161
       161
       +
               )

     

       162
       162
       +
               published = self._parse_timestamp(entry.get("published_parsed"))

     

       136
       163
        
       

     

       137
       164
        
               # Parse content

     

       138
       165
        
               content = self._extract_content(entry)

     
···

       143
       170
        
       

     

       144
       171
        
               # Parse categories/tags

     

       145
       172
        
               categories = []

     

       146
       146
       -
               if hasattr(entry, 'tags'):

     

       147
       147
       -
                   categories = [tag.get('term', '') for tag in entry.tags if tag.get('term')]

     

       173
       173
       +
               if hasattr(entry, "tags"):

     

       174
       174
       +
                   categories = [tag.get("term", "") for tag in entry.tags if tag.get("term")]

     

       148
       175
        
       

     

       149
       176
        
               # Sanitize HTML content

     

       150
       177
        
               if content:

     

       151
       178
        
                   content = self._sanitize_html(content)

     

       152
       179
        
       

     

       153
       153
       -
               summary = entry.get('summary', '')

     

       180
       180
       +
               summary = entry.get("summary", "")

     

       154
       181
        
               if summary:

     

       155
       182
        
                   summary = self._sanitize_html(summary)

     

       156
       183
        
       

     

       157
       184
        
               return AtomEntry(

     

       158
       158
       -
                   id=entry.get('id', entry.get('link', '')),

     

       159
       159
       -
                   title=entry.get('title', ''),

     

       160
       160
       -
                   link=HttpUrl(entry.get('link', '')),

     

       185
       185
       +
                   id=entry.get("id", entry.get("link", "")),

     

       186
       186
       +
                   title=entry.get("title", ""),

     

       187
       187
       +
                   link=HttpUrl(entry.get("link", "")),

     

       161
       188
        
                   updated=updated,

     

       162
       189
        
                   published=published,

     

       163
       190
        
                   summary=summary or None,

     
···

       165
       192
        
                   content_type=content_type,

     

       166
       193
        
                   author=author,

     

       167
       194
        
                   categories=categories,

     

       168
       168
       -
                   rights=entry.get('rights', None),

     

       195
       195
       +
                   rights=entry.get("rights", None),

     

       169
       196
        
                   source=str(source_url) if source_url else None,

     

       170
       197
        
               )

     

       171
       198
        
       

     
···

       178
       205
        
           def _extract_content(self, entry: feedparser.FeedParserDict) -> Optional[str]:

     

       179
       206
        
               """Extract the best content from an entry."""

     

       180
       207
        
               # Prefer content over summary

     

       181
       181
       -
               if hasattr(entry, 'content') and entry.content:

     

       208
       208
       +
               if hasattr(entry, "content") and entry.content:

     

       182
       209
        
                   # Find the best content (prefer text/html, then text/plain)

     

       183
       210
        
                   for content_item in entry.content:

     

       184
       184
       -
                       if content_item.get('type') in ['text/html', 'html']:

     

       185
       185
       -
                           return content_item.get('value', '')

     

       186
       186
       -
                       elif content_item.get('type') in ['text/plain', 'text']:

     

       187
       187
       -
                           return content_item.get('value', '')

     

       211
       211
       +
                       if content_item.get("type") in ["text/html", "html"]:

     

       212
       212
       +
                           return content_item.get("value", "")

     

       213
       213
       +
                       elif content_item.get("type") in ["text/plain", "text"]:

     

       214
       214
       +
                           return content_item.get("value", "")

     

       188
       215
        
                   # Fallback to first content item

     

       189
       189
       -
                   return entry.content[0].get('value', '')

     

       216
       216
       +
                   return entry.content[0].get("value", "")

     

       190
       217
        
       

     

       191
       218
        
               # Fallback to summary

     

       192
       192
       -
               return entry.get('summary', '')

     

       219
       219
       +
               return entry.get("summary", "")

     

       193
       220
        
       

     

       194
       221
        
           def _extract_content_type(self, entry: feedparser.FeedParserDict) -> str:

     

       195
       222
        
               """Extract content type from entry."""

     

       196
       196
       -
               if hasattr(entry, 'content') and entry.content:

     

       197
       197
       -
                   content_type = entry.content[0].get('type', 'html')

     

       223
       223
       +
               if hasattr(entry, "content") and entry.content:

     

       224
       224
       +
                   content_type = entry.content[0].get("type", "html")

     

       198
       225
        
                   # Normalize content type

     

       199
       199
       -
                   if content_type in ['text/html', 'html']:

     

       200
       200
       -
                       return 'html'

     

       201
       201
       -
                   elif content_type in ['text/plain', 'text']:

     

       202
       202
       -
                       return 'text'

     

       203
       203
       -
                   elif content_type == 'xhtml':

     

       204
       204
       -
                       return 'xhtml'

     

       205
       205
       -
               return 'html'

     

       226
       226
       +
                   if content_type in ["text/html", "html"]:

     

       227
       227
       +
                       return "html"

     

       228
       228
       +
                   elif content_type in ["text/plain", "text"]:

     

       229
       229
       +
                       return "text"

     

       230
       230
       +
                   elif content_type == "xhtml":

     

       231
       231
       +
                       return "xhtml"

     

       232
       232
       +
               return "html"

     

       206
       233
        
       

     

       207
       234
        
           def _extract_author(self, entry: feedparser.FeedParserDict) -> Optional[dict]:

     

       208
       235
        
               """Extract author information from entry."""

     

       209
       236
        
               author = {}

     

       210
       237
        
       

     

       211
       211
       -
               if hasattr(entry, 'author_detail'):

     

       212
       212
       -
                   author.update({

     

       213
       213
       -
                       'name': entry.author_detail.get('name'),

     

       214
       214
       -
                       'email': entry.author_detail.get('email'),

     

       215
       215
       -
                       'uri': entry.author_detail.get('href'),

     

       216
       216
       -
                   })

     

       217
       217
       -
               elif hasattr(entry, 'author'):

     

       218
       218
       -
                   author['name'] = entry.author

     

       238
       238
       +
               if hasattr(entry, "author_detail"):

     

       239
       239
       +
                   author.update(

     

       240
       240
       +
                       {

     

       241
       241
       +
                           "name": entry.author_detail.get("name"),

     

       242
       242
       +
                           "email": entry.author_detail.get("email"),

     

       243
       243
       +
                           "uri": entry.author_detail.get("href"),

     

       244
       244
       +
                       }

     

       245
       245
       +
                   )

     

       246
       246
       +
               elif hasattr(entry, "author"):

     

       247
       247
       +
                   author["name"] = entry.author

     

       219
       248
        
       

     

       220
       249
        
               return author if author else None

     

       221
       250
        
       

     
···

       236
       265
        
               # Start with the path component

     

       237
       266
        
               if parsed.path:

     

       238
       267
        
                   # Remove leading slash and replace problematic characters

     

       239
       239
       -
                   safe_id = parsed.path.lstrip('/').replace('/', '_').replace('\\', '_')

     

       268
       268
       +
                   safe_id = parsed.path.lstrip("/").replace("/", "_").replace("\\", "_")

     

       240
       269
        
               else:

     

       241
       270
        
                   # Use the entire ID as fallback

     

       242
       271
        
                   safe_id = entry_id

     
···

       244
       273
        
               # Replace problematic characters

     

       245
       274
        
               safe_chars = []

     

       246
       275
        
               for char in safe_id:

     

       247
       247
       -
                   if char.isalnum() or char in '-_.':

     

       276
       276
       +
                   if char.isalnum() or char in "-_.":

     

       248
       277
        
                       safe_chars.append(char)

     

       249
       278
        
                   else:

     

       250
       250
       -
                       safe_chars.append('_')

     

       279
       279
       +
                       safe_chars.append("_")

     

       251
       280
        
       

     

       252
       252
       -
               safe_id = ''.join(safe_chars)

     

       281
       281
       +
               safe_id = "".join(safe_chars)

     

       253
       282
        
       

     

       254
       283
        
               # Ensure it's not too long (max 200 chars)

     

       255
       284
        
               if len(safe_id) > 200:

+45 -18

src/thicket/core/git_store.py

···

       53
       53
        
               """Save the index to index.json."""

     

       54
       54
        
               index_path = self.repo_path / "index.json"

     

       55
       55
        
               with open(index_path, "w") as f:

     

       56
       56
       -
                   json.dump(index.model_dump(mode="json", exclude_none=True), f, indent=2, default=str)

     

       56
       56
       +
                   json.dump(

     

       57
       57
       +
                       index.model_dump(mode="json", exclude_none=True),

     

       58
       58
       +
                       f,

     

       59
       59
       +
                       indent=2,

     

       60
       60
       +
                       default=str,

     

       61
       61
       +
                   )

     

       57
       62
        
       

     

       58
       63
        
           def _load_index(self) -> GitStoreIndex:

     

       59
       64
        
               """Load the index from index.json."""

     
···

       86
       91
        
       

     

       87
       92
        
               return DuplicateMap(**data)

     

       88
       93
        
       

     

       89
       89
       -
           def add_user(self, username: str, display_name: Optional[str] = None,

     

       90
       90
       -
                        email: Optional[str] = None, homepage: Optional[str] = None,

     

       91
       91
       -
                        icon: Optional[str] = None, feeds: Optional[list[str]] = None) -> UserMetadata:

     

       94
       94
       +
           def add_user(

     

       95
       95
       +
               self,

     

       96
       96
       +
               username: str,

     

       97
       97
       +
               display_name: Optional[str] = None,

     

       98
       98
       +
               email: Optional[str] = None,

     

       99
       99
       +
               homepage: Optional[str] = None,

     

       100
       100
       +
               icon: Optional[str] = None,

     

       101
       101
       +
               feeds: Optional[list[str]] = None,

     

       102
       102
       +
           ) -> UserMetadata:

     

       92
       103
        
               """Add a new user to the Git store."""

     

       93
       104
        
               index = self._load_index()

     

       94
       105
        
       

     
···

       108
       119
        
                   created=datetime.now(),

     

       109
       120
        
                   last_updated=datetime.now(),

     

       110
       121
        
               )

     

       111
       111
       -
       

     

       112
       122
        
       

     

       113
       123
        
               # Update index

     

       114
       124
        
               index.add_user(user_metadata)

     
···

       136
       146
        
       

     

       137
       147
        
               user.update_timestamp()

     

       138
       148
        
       

     

       139
       139
       -
       

     

       140
       149
        
               # Update index

     

       141
       150
        
               index.add_user(user)

     

       142
       151
        
               self._save_index(index)

     
···

       151
       160
        
       

     

       152
       161
        
               # Sanitize entry ID for filename

     

       153
       162
        
               from .feed_parser import FeedParser

     

       163
       163
       +
       

     

       154
       164
        
               parser = FeedParser()

     

       155
       165
        
               safe_id = parser.sanitize_entry_id(entry.id)

     

       156
       166
        
       

     
···

       163
       173
        
       

     

       164
       174
        
               # Save entry

     

       165
       175
        
               with open(entry_path, "w") as f:

     

       166
       166
       -
                   json.dump(entry.model_dump(mode="json", exclude_none=True), f, indent=2, default=str)

     

       176
       176
       +
                   json.dump(

     

       177
       177
       +
                       entry.model_dump(mode="json", exclude_none=True),

     

       178
       178
       +
                       f,

     

       179
       179
       +
                       indent=2,

     

       180
       180
       +
                       default=str,

     

       181
       181
       +
                   )

     

       167
       182
        
       

     

       168
       183
        
               # Update user metadata if new entry

     

       169
       184
        
               if not entry_exists:

     
···

       181
       196
        
       

     

       182
       197
        
               # Sanitize entry ID

     

       183
       198
        
               from .feed_parser import FeedParser

     

       199
       199
       +
       

     

       184
       200
        
               parser = FeedParser()

     

       185
       201
        
               safe_id = parser.sanitize_entry_id(entry_id)

     

       186
       202
        
       

     
···

       193
       209
        
       

     

       194
       210
        
               return AtomEntry(**data)

     

       195
       211
        
       

     

       196
       196
       -
           def list_entries(self, username: str, limit: Optional[int] = None) -> list[AtomEntry]:

     

       212
       212
       +
           def list_entries(

     

       213
       213
       +
               self, username: str, limit: Optional[int] = None

     

       214
       214
       +
           ) -> list[AtomEntry]:

     

       197
       215
        
               """List entries for a user."""

     

       198
       216
        
               user = self.get_user(username)

     

       199
       217
        
               if not user:

     
···

       204
       222
        
                   return []

     

       205
       223
        
       

     

       206
       224
        
               entries = []

     

       207
       207
       -
               entry_files = sorted(user_dir.glob("*.json"), key=lambda p: p.stat().st_mtime, reverse=True)

     

       208
       208
       -
       

     

       225
       225
       +
               entry_files = sorted(

     

       226
       226
       +
                   user_dir.glob("*.json"), key=lambda p: p.stat().st_mtime, reverse=True

     

       227
       227
       +
               )

     

       209
       228
        
       

     

       210
       229
        
               if limit:

     

       211
       230
        
                   entry_files = entry_files[:limit]

     
···

       260
       279
        
                   "total_entries": index.total_entries,

     

       261
       280
        
                   "total_duplicates": len(duplicates.duplicates),

     

       262
       281
        
                   "last_updated": index.last_updated,

     

       263
       263
       -
                   "repository_size": sum(f.stat().st_size for f in self.repo_path.rglob("*") if f.is_file()),

     

       282
       282
       +
                   "repository_size": sum(

     

       283
       283
       +
                       f.stat().st_size for f in self.repo_path.rglob("*") if f.is_file()

     

       284
       284
       +
                   ),

     

       264
       285
        
               }

     

       265
       286
        
       

     

       266
       266
       -
           def search_entries(self, query: str, username: Optional[str] = None,

     

       267
       267
       -
                             limit: Optional[int] = None) -> list[tuple[str, AtomEntry]]:

     

       287
       287
       +
           def search_entries(

     

       288
       288
       +
               self, query: str, username: Optional[str] = None, limit: Optional[int] = None

     

       289
       289
       +
           ) -> list[tuple[str, AtomEntry]]:

     

       268
       290
        
               """Search entries by content."""

     

       269
       291
        
               results = []

     

       270
       292
        
       

     
···

       288
       310
        
                           entry = AtomEntry(**data)

     

       289
       311
        
       

     

       290
       312
        
                           # Simple text search in title, summary, and content

     

       291
       291
       -
                           searchable_text = " ".join(filter(None, [

     

       292
       292
       -
                               entry.title,

     

       293
       293
       -
                               entry.summary or "",

     

       294
       294
       -
                               entry.content or "",

     

       295
       295
       -
                           ])).lower()

     

       313
       313
       +
                           searchable_text = " ".join(

     

       314
       314
       +
                               filter(

     

       315
       315
       +
                                   None,

     

       316
       316
       +
                                   [

     

       317
       317
       +
                                       entry.title,

     

       318
       318
       +
                                       entry.summary or "",

     

       319
       319
       +
                                       entry.content or "",

     

       320
       320
       +
                                   ],

     

       321
       321
       +
                               )

     

       322
       322
       +
                           ).lower()

     

       296
       323
        
       

     

       297
       324
        
                           if query.lower() in searchable_text:

     

       298
       325
        
                               results.append((user.username, entry))

+24

src/thicket/models/config.py

···

       31
       31
        
           git_store: Path

     

       32
       32
        
           cache_dir: Path

     

       33
       33
        
           users: list[UserConfig] = []

     

       34
       34
       +
       

     

       35
       35
       +
           def find_user(self, username: str) -> Optional[UserConfig]:

     

       36
       36
       +
               """Find a user by username."""

     

       37
       37
       +
               for user in self.users:

     

       38
       38
       +
                   if user.username == username:

     

       39
       39
       +
                       return user

     

       40
       40
       +
               return None

     

       41
       41
       +
       

     

       42
       42
       +
           def add_user(self, user: UserConfig) -> bool:

     

       43
       43
       +
               """Add a user to the configuration. Returns True if added, False if already exists."""

     

       44
       44
       +
               if self.find_user(user.username) is not None:

     

       45
       45
       +
                   return False

     

       46
       46
       +
               self.users.append(user)

     

       47
       47
       +
               return True

     

       48
       48
       +
       

     

       49
       49
       +
           def add_feed_to_user(self, username: str, feed_url: HttpUrl) -> bool:

     

       50
       50
       +
               """Add a feed to an existing user. Returns True if added, False if user not found or feed already exists."""

     

       51
       51
       +
               user = self.find_user(username)

     

       52
       52
       +
               if user is None:

     

       53
       53
       +
                   return False

     

       54
       54
       +
               if feed_url in user.feeds:

     

       55
       55
       +
                   return False

     

       56
       56
       +
               user.feeds.append(feed_url)

     

       57
       57
       +
               return True

-2

src/thicket/models/feed.py

···

       29
       29
        
           categories: list[str] = []

     

       30
       30
        
           rights: Optional[str] = None  # Copyright info

     

       31
       31
        
           source: Optional[str] = None  # Source feed URL

     

       32
       32
       -
           links: list[str] = []  # URLs mentioned in this entry

     

       33
       33
       -
           backlinks: list[str] = []  # Entry IDs that link to this entry

     

       34
       32
        
       

     

       35
       33
        
       

     

       36
       34
        
       class FeedMetadata(BaseModel):

+1 -3

src/thicket/models/user.py

···

       38
       38
        
       class GitStoreIndex(BaseModel):

     

       39
       39
        
           """Index of all users and their directories in the Git store."""

     

       40
       40
        
       

     

       41
       41
       -
           model_config = ConfigDict(

     

       42
       42
       -
               json_encoders={datetime: lambda v: v.isoformat()}

     

       43
       43
       -
           )

     

       41
       41
       +
           model_config = ConfigDict(json_encoders={datetime: lambda v: v.isoformat()})

     

       44
       42
        
       

     

       45
       43
        
           users: dict[str, UserMetadata] = {}  # username -> UserMetadata

     

       46
       44
        
           created: datetime

+9 -211

uv.lock

···

       1
       1
        
       version = 1

     

       2
       2
       -
       revision = 2

     

       2
       2
       +
       revision = 3

     

       3
       3
        
       requires-python = ">=3.9"

     

       4
       4
        
       resolution-markers = [

     

       5
       5
        
           "python_full_version >= '3.10'",

     
···

       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 = "blinker"

     

       86
       86
       -
       version = "1.9.0"

     

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

     

       88
       88
       -
       sdist = { url = "https://files.pythonhosted.org/packages/21/28/9b3f50ce0e048515135495f198351908d99540d69bfdc8c1d15b73dc55ce/blinker-1.9.0.tar.gz", hash = "sha256:b4ce2265a7abece45e7cc896e98dbebe6cead56bcf805a3d23136d145f5445bf", size = 22460, upload-time = "2024-11-08T17:25:47.436Z" }

     

       89
       89
       -
       wheels = [

     

       90
       90
       -
           { url = "https://files.pythonhosted.org/packages/10/cb/f2ad4230dc2eb1a74edf38f1a38b9b52277f75bef262d8908e60d957e13c/blinker-1.9.0-py3-none-any.whl", hash = "sha256:ba0efaa9080b619ff2f3459d1d500c57bddea4a6b424b60a91141db6fd2f08bc", size = 8458, upload-time = "2024-11-08T17:25:46.184Z" },

     

       91
       82
        
       ]

     

       92
       83
        
       

     

       93
       84
        
       [[package]]

     
···

       264
       255
        
       ]

     

       265
       256
        
       

     

       266
       257
        
       [[package]]

     

       267
       267
       -
       name = "flask"

     

       268
       268
       -
       version = "3.1.1"

     

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

     

       270
       270
       -
       dependencies = [

     

       271
       271
       -
           { name = "blinker" },

     

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

     

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

     

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

     

       275
       275
       -
           { name = "itsdangerous" },

     

       276
       276
       -
           { name = "jinja2" },

     

       277
       277
       -
           { name = "markupsafe" },

     

       278
       278
       -
           { name = "werkzeug" },

     

       279
       279
       -
       ]

     

       280
       280
       -
       sdist = { url = "https://files.pythonhosted.org/packages/c0/de/e47735752347f4128bcf354e0da07ef311a78244eba9e3dc1d4a5ab21a98/flask-3.1.1.tar.gz", hash = "sha256:284c7b8f2f58cb737f0cf1c30fd7eaf0ccfcde196099d24ecede3fc2005aa59e", size = 753440, upload-time = "2025-05-13T15:01:17.447Z" }

     

       281
       281
       -
       wheels = [

     

       282
       282
       -
           { url = "https://files.pythonhosted.org/packages/3d/68/9d4508e893976286d2ead7f8f571314af6c2037af34853a30fd769c02e9d/flask-3.1.1-py3-none-any.whl", hash = "sha256:07aae2bb5eaf77993ef57e357491839f5fd9f4dc281593a81a9e4d79a24f295c", size = 103305, upload-time = "2025-05-13T15:01:15.591Z" },

     

       283
       283
       -
       ]

     

       284
       284
       -
       

     

       285
       285
       -
       [[package]]

     

       286
       258
        
       name = "gitdb"

     

       287
       259
        
       version = "4.0.12"

     

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

     
···

       353
       325
        
       ]

     

       354
       326
        
       

     

       355
       327
        
       [[package]]

     

       356
       356
       -
       name = "importlib-metadata"

     

       357
       357
       -
       version = "8.7.0"

     

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

     

       359
       359
       -
       dependencies = [

     

       360
       360
       -
           { name = "zipp", marker = "python_full_version < '3.10'" },

     

       361
       361
       -
       ]

     

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

     

       363
       363
       -
       wheels = [

     

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

     

       365
       365
       -
       ]

     

       366
       366
       -
       

     

       367
       367
       -
       [[package]]

     

       368
       328
        
       name = "iniconfig"

     

       369
       329
        
       version = "2.1.0"

     

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

     
···

       374
       334
        
       ]

     

       375
       335
        
       

     

       376
       336
        
       [[package]]

     

       377
       377
       -
       name = "itsdangerous"

     

       378
       378
       -
       version = "2.2.0"

     

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

     

       380
       380
       -
       sdist = { url = "https://files.pythonhosted.org/packages/9c/cb/8ac0172223afbccb63986cc25049b154ecfb5e85932587206f42317be31d/itsdangerous-2.2.0.tar.gz", hash = "sha256:e0050c0b7da1eea53ffaf149c0cfbb5c6e2e2b69c4bef22c81fa6eb73e5f6173", size = 54410, upload-time = "2024-04-16T21:28:15.614Z" }

     

       381
       381
       -
       wheels = [

     

       382
       382
       -
           { url = "https://files.pythonhosted.org/packages/04/96/92447566d16df59b2a776c0fb82dbc4d9e07cd95062562af01e408583fc4/itsdangerous-2.2.0-py3-none-any.whl", hash = "sha256:c6242fc49e35958c8b15141343aa660db5fc54d4f13a1db01a3f5891b98700ef", size = 16234, upload-time = "2024-04-16T21:28:14.499Z" },

     

       383
       383
       -
       ]

     

       384
       384
       -
       

     

       385
       385
       -
       [[package]]

     

       386
       386
       -
       name = "jinja2"

     

       387
       387
       -
       version = "3.1.6"

     

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

     

       389
       389
       -
       dependencies = [

     

       390
       390
       -
           { name = "markupsafe" },

     

       391
       391
       -
       ]

     

       392
       392
       -
       sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" }

     

       393
       393
       -
       wheels = [

     

       394
       394
       -
           { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" },

     

       395
       395
       -
       ]

     

       396
       396
       -
       

     

       397
       397
       -
       [[package]]

     

       398
       398
       -
       name = "linkify-it-py"

     

       399
       399
       -
       version = "2.0.3"

     

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

     

       401
       401
       -
       dependencies = [

     

       402
       402
       -
           { name = "uc-micro-py" },

     

       403
       403
       -
       ]

     

       404
       404
       -
       sdist = { url = "https://files.pythonhosted.org/packages/2a/ae/bb56c6828e4797ba5a4821eec7c43b8bf40f69cda4d4f5f8c8a2810ec96a/linkify-it-py-2.0.3.tar.gz", hash = "sha256:68cda27e162e9215c17d786649d1da0021a451bdc436ef9e0fa0ba5234b9b048", size = 27946, upload-time = "2024-02-04T14:48:04.179Z" }

     

       405
       405
       -
       wheels = [

     

       406
       406
       -
           { url = "https://files.pythonhosted.org/packages/04/1e/b832de447dee8b582cac175871d2f6c3d5077cc56d5575cadba1fd1cccfa/linkify_it_py-2.0.3-py3-none-any.whl", hash = "sha256:6bcbc417b0ac14323382aef5c5192c0075bf8a9d6b41820a2b66371eac6b6d79", size = 19820, upload-time = "2024-02-04T14:48:02.496Z" },

     

       407
       407
       -
       ]

     

       408
       408
       -
       

     

       409
       409
       -
       [[package]]

     

       410
       337
        
       name = "markdown-it-py"

     

       411
       338
        
       version = "3.0.0"

     

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

     
···

       416
       343
        
       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" }

     

       417
       344
        
       wheels = [

     

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

     

       419
       419
       -
       ]

     

       420
       420
       -
       

     

       421
       421
       -
       [package.optional-dependencies]

     

       422
       422
       -
       linkify = [

     

       423
       423
       -
           { name = "linkify-it-py" },

     

       424
       424
       -
       ]

     

       425
       425
       -
       plugins = [

     

       426
       426
       -
           { name = "mdit-py-plugins" },

     

       427
       427
       -
       ]

     

       428
       428
       -
       

     

       429
       429
       -
       [[package]]

     

       430
       430
       -
       name = "markupsafe"

     

       431
       431
       -
       version = "3.0.2"

     

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

     

       433
       433
       -
       sdist = { url = "https://files.pythonhosted.org/packages/b2/97/5d42485e71dfc078108a86d6de8fa46db44a1a9295e89c5d6d4a06e23a62/markupsafe-3.0.2.tar.gz", hash = "sha256:ee55d3edf80167e48ea11a923c7386f4669df67d7994554387f84e7d8b0a2bf0", size = 20537, upload-time = "2024-10-18T15:21:54.129Z" }

     

       434
       434
       -
       wheels = [

     

       435
       435
       -
           { url = "https://files.pythonhosted.org/packages/04/90/d08277ce111dd22f77149fd1a5d4653eeb3b3eaacbdfcbae5afb2600eebd/MarkupSafe-3.0.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7e94c425039cde14257288fd61dcfb01963e658efbc0ff54f5306b06054700f8", size = 14357, upload-time = "2024-10-18T15:20:51.44Z" },

     

       436
       436
       -
           { url = "https://files.pythonhosted.org/packages/04/e1/6e2194baeae0bca1fae6629dc0cbbb968d4d941469cbab11a3872edff374/MarkupSafe-3.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9e2d922824181480953426608b81967de705c3cef4d1af983af849d7bd619158", size = 12393, upload-time = "2024-10-18T15:20:52.426Z" },

     

       437
       437
       -
           { url = "https://files.pythonhosted.org/packages/1d/69/35fa85a8ece0a437493dc61ce0bb6d459dcba482c34197e3efc829aa357f/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:38a9ef736c01fccdd6600705b09dc574584b89bea478200c5fbf112a6b0d5579", size = 21732, upload-time = "2024-10-18T15:20:53.578Z" },

     

       438
       438
       -
           { url = "https://files.pythonhosted.org/packages/22/35/137da042dfb4720b638d2937c38a9c2df83fe32d20e8c8f3185dbfef05f7/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bbcb445fa71794da8f178f0f6d66789a28d7319071af7a496d4d507ed566270d", size = 20866, upload-time = "2024-10-18T15:20:55.06Z" },

     

       439
       439
       -
           { url = "https://files.pythonhosted.org/packages/29/28/6d029a903727a1b62edb51863232152fd335d602def598dade38996887f0/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:57cb5a3cf367aeb1d316576250f65edec5bb3be939e9247ae594b4bcbc317dfb", size = 20964, upload-time = "2024-10-18T15:20:55.906Z" },

     

       440
       440
       -
           { url = "https://files.pythonhosted.org/packages/cc/cd/07438f95f83e8bc028279909d9c9bd39e24149b0d60053a97b2bc4f8aa51/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3809ede931876f5b2ec92eef964286840ed3540dadf803dd570c3b7e13141a3b", size = 21977, upload-time = "2024-10-18T15:20:57.189Z" },

     

       441
       441
       -
           { url = "https://files.pythonhosted.org/packages/29/01/84b57395b4cc062f9c4c55ce0df7d3108ca32397299d9df00fedd9117d3d/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e07c3764494e3776c602c1e78e298937c3315ccc9043ead7e685b7f2b8d47b3c", size = 21366, upload-time = "2024-10-18T15:20:58.235Z" },

     

       442
       442
       -
           { url = "https://files.pythonhosted.org/packages/bd/6e/61ebf08d8940553afff20d1fb1ba7294b6f8d279df9fd0c0db911b4bbcfd/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b424c77b206d63d500bcb69fa55ed8d0e6a3774056bdc4839fc9298a7edca171", size = 21091, upload-time = "2024-10-18T15:20:59.235Z" },

     

       443
       443
       -
           { url = "https://files.pythonhosted.org/packages/11/23/ffbf53694e8c94ebd1e7e491de185124277964344733c45481f32ede2499/MarkupSafe-3.0.2-cp310-cp310-win32.whl", hash = "sha256:fcabf5ff6eea076f859677f5f0b6b5c1a51e70a376b0579e0eadef8db48c6b50", size = 15065, upload-time = "2024-10-18T15:21:00.307Z" },

     

       444
       444
       -
           { url = "https://files.pythonhosted.org/packages/44/06/e7175d06dd6e9172d4a69a72592cb3f7a996a9c396eee29082826449bbc3/MarkupSafe-3.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:6af100e168aa82a50e186c82875a5893c5597a0c1ccdb0d8b40240b1f28b969a", size = 15514, upload-time = "2024-10-18T15:21:01.122Z" },

     

       445
       445
       -
           { url = "https://files.pythonhosted.org/packages/6b/28/bbf83e3f76936960b850435576dd5e67034e200469571be53f69174a2dfd/MarkupSafe-3.0.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9025b4018f3a1314059769c7bf15441064b2207cb3f065e6ea1e7359cb46db9d", size = 14353, upload-time = "2024-10-18T15:21:02.187Z" },

     

       446
       446
       -
           { url = "https://files.pythonhosted.org/packages/6c/30/316d194b093cde57d448a4c3209f22e3046c5bb2fb0820b118292b334be7/MarkupSafe-3.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:93335ca3812df2f366e80509ae119189886b0f3c2b81325d39efdb84a1e2ae93", size = 12392, upload-time = "2024-10-18T15:21:02.941Z" },

     

       447
       447
       -
           { url = "https://files.pythonhosted.org/packages/f2/96/9cdafba8445d3a53cae530aaf83c38ec64c4d5427d975c974084af5bc5d2/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2cb8438c3cbb25e220c2ab33bb226559e7afb3baec11c4f218ffa7308603c832", size = 23984, upload-time = "2024-10-18T15:21:03.953Z" },

     

       448
       448
       -
           { url = "https://files.pythonhosted.org/packages/f1/a4/aefb044a2cd8d7334c8a47d3fb2c9f328ac48cb349468cc31c20b539305f/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a123e330ef0853c6e822384873bef7507557d8e4a082961e1defa947aa59ba84", size = 23120, upload-time = "2024-10-18T15:21:06.495Z" },

     

       449
       449
       -
           { url = "https://files.pythonhosted.org/packages/8d/21/5e4851379f88f3fad1de30361db501300d4f07bcad047d3cb0449fc51f8c/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1e084f686b92e5b83186b07e8a17fc09e38fff551f3602b249881fec658d3eca", size = 23032, upload-time = "2024-10-18T15:21:07.295Z" },

     

       450
       450
       -
           { url = "https://files.pythonhosted.org/packages/00/7b/e92c64e079b2d0d7ddf69899c98842f3f9a60a1ae72657c89ce2655c999d/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d8213e09c917a951de9d09ecee036d5c7d36cb6cb7dbaece4c71a60d79fb9798", size = 24057, upload-time = "2024-10-18T15:21:08.073Z" },

     

       451
       451
       -
           { url = "https://files.pythonhosted.org/packages/f9/ac/46f960ca323037caa0a10662ef97d0a4728e890334fc156b9f9e52bcc4ca/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:5b02fb34468b6aaa40dfc198d813a641e3a63b98c2b05a16b9f80b7ec314185e", size = 23359, upload-time = "2024-10-18T15:21:09.318Z" },

     

       452
       452
       -
           { url = "https://files.pythonhosted.org/packages/69/84/83439e16197337b8b14b6a5b9c2105fff81d42c2a7c5b58ac7b62ee2c3b1/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0bff5e0ae4ef2e1ae4fdf2dfd5b76c75e5c2fa4132d05fc1b0dabcd20c7e28c4", size = 23306, upload-time = "2024-10-18T15:21:10.185Z" },

     

       453
       453
       -
           { url = "https://files.pythonhosted.org/packages/9a/34/a15aa69f01e2181ed8d2b685c0d2f6655d5cca2c4db0ddea775e631918cd/MarkupSafe-3.0.2-cp311-cp311-win32.whl", hash = "sha256:6c89876f41da747c8d3677a2b540fb32ef5715f97b66eeb0c6b66f5e3ef6f59d", size = 15094, upload-time = "2024-10-18T15:21:11.005Z" },

     

       454
       454
       -
           { url = "https://files.pythonhosted.org/packages/da/b8/3a3bd761922d416f3dc5d00bfbed11f66b1ab89a0c2b6e887240a30b0f6b/MarkupSafe-3.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:70a87b411535ccad5ef2f1df5136506a10775d267e197e4cf531ced10537bd6b", size = 15521, upload-time = "2024-10-18T15:21:12.911Z" },

     

       455
       455
       -
           { url = "https://files.pythonhosted.org/packages/22/09/d1f21434c97fc42f09d290cbb6350d44eb12f09cc62c9476effdb33a18aa/MarkupSafe-3.0.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:9778bd8ab0a994ebf6f84c2b949e65736d5575320a17ae8984a77fab08db94cf", size = 14274, upload-time = "2024-10-18T15:21:13.777Z" },

     

       456
       456
       -
           { url = "https://files.pythonhosted.org/packages/6b/b0/18f76bba336fa5aecf79d45dcd6c806c280ec44538b3c13671d49099fdd0/MarkupSafe-3.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:846ade7b71e3536c4e56b386c2a47adf5741d2d8b94ec9dc3e92e5e1ee1e2225", size = 12348, upload-time = "2024-10-18T15:21:14.822Z" },

     

       457
       457
       -
           { url = "https://files.pythonhosted.org/packages/e0/25/dd5c0f6ac1311e9b40f4af06c78efde0f3b5cbf02502f8ef9501294c425b/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1c99d261bd2d5f6b59325c92c73df481e05e57f19837bdca8413b9eac4bd8028", size = 24149, upload-time = "2024-10-18T15:21:15.642Z" },

     

       458
       458
       -
           { url = "https://files.pythonhosted.org/packages/f3/f0/89e7aadfb3749d0f52234a0c8c7867877876e0a20b60e2188e9850794c17/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e17c96c14e19278594aa4841ec148115f9c7615a47382ecb6b82bd8fea3ab0c8", size = 23118, upload-time = "2024-10-18T15:21:17.133Z" },

     

       459
       459
       -
           { url = "https://files.pythonhosted.org/packages/d5/da/f2eeb64c723f5e3777bc081da884b414671982008c47dcc1873d81f625b6/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:88416bd1e65dcea10bc7569faacb2c20ce071dd1f87539ca2ab364bf6231393c", size = 22993, upload-time = "2024-10-18T15:21:18.064Z" },

     

       460
       460
       -
           { url = "https://files.pythonhosted.org/packages/da/0e/1f32af846df486dce7c227fe0f2398dc7e2e51d4a370508281f3c1c5cddc/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2181e67807fc2fa785d0592dc2d6206c019b9502410671cc905d132a92866557", size = 24178, upload-time = "2024-10-18T15:21:18.859Z" },

     

       461
       461
       -
           { url = "https://files.pythonhosted.org/packages/c4/f6/bb3ca0532de8086cbff5f06d137064c8410d10779c4c127e0e47d17c0b71/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:52305740fe773d09cffb16f8ed0427942901f00adedac82ec8b67752f58a1b22", size = 23319, upload-time = "2024-10-18T15:21:19.671Z" },

     

       462
       462
       -
           { url = "https://files.pythonhosted.org/packages/a2/82/8be4c96ffee03c5b4a034e60a31294daf481e12c7c43ab8e34a1453ee48b/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ad10d3ded218f1039f11a75f8091880239651b52e9bb592ca27de44eed242a48", size = 23352, upload-time = "2024-10-18T15:21:20.971Z" },

     

       463
       463
       -
           { url = "https://files.pythonhosted.org/packages/51/ae/97827349d3fcffee7e184bdf7f41cd6b88d9919c80f0263ba7acd1bbcb18/MarkupSafe-3.0.2-cp312-cp312-win32.whl", hash = "sha256:0f4ca02bea9a23221c0182836703cbf8930c5e9454bacce27e767509fa286a30", size = 15097, upload-time = "2024-10-18T15:21:22.646Z" },

     

       464
       464
       -
           { url = "https://files.pythonhosted.org/packages/c1/80/a61f99dc3a936413c3ee4e1eecac96c0da5ed07ad56fd975f1a9da5bc630/MarkupSafe-3.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:8e06879fc22a25ca47312fbe7c8264eb0b662f6db27cb2d3bbbc74b1df4b9b87", size = 15601, upload-time = "2024-10-18T15:21:23.499Z" },

     

       465
       465
       -
           { url = "https://files.pythonhosted.org/packages/83/0e/67eb10a7ecc77a0c2bbe2b0235765b98d164d81600746914bebada795e97/MarkupSafe-3.0.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ba9527cdd4c926ed0760bc301f6728ef34d841f405abf9d4f959c478421e4efd", size = 14274, upload-time = "2024-10-18T15:21:24.577Z" },

     

       466
       466
       -
           { url = "https://files.pythonhosted.org/packages/2b/6d/9409f3684d3335375d04e5f05744dfe7e9f120062c9857df4ab490a1031a/MarkupSafe-3.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f8b3d067f2e40fe93e1ccdd6b2e1d16c43140e76f02fb1319a05cf2b79d99430", size = 12352, upload-time = "2024-10-18T15:21:25.382Z" },

     

       467
       467
       -
           { url = "https://files.pythonhosted.org/packages/d2/f5/6eadfcd3885ea85fe2a7c128315cc1bb7241e1987443d78c8fe712d03091/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:569511d3b58c8791ab4c2e1285575265991e6d8f8700c7be0e88f86cb0672094", size = 24122, upload-time = "2024-10-18T15:21:26.199Z" },

     

       468
       468
       -
           { url = "https://files.pythonhosted.org/packages/0c/91/96cf928db8236f1bfab6ce15ad070dfdd02ed88261c2afafd4b43575e9e9/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:15ab75ef81add55874e7ab7055e9c397312385bd9ced94920f2802310c930396", size = 23085, upload-time = "2024-10-18T15:21:27.029Z" },

     

       469
       469
       -
           { url = "https://files.pythonhosted.org/packages/c2/cf/c9d56af24d56ea04daae7ac0940232d31d5a8354f2b457c6d856b2057d69/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f3818cb119498c0678015754eba762e0d61e5b52d34c8b13d770f0719f7b1d79", size = 22978, upload-time = "2024-10-18T15:21:27.846Z" },

     

       470
       470
       -
           { url = "https://files.pythonhosted.org/packages/2a/9f/8619835cd6a711d6272d62abb78c033bda638fdc54c4e7f4272cf1c0962b/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cdb82a876c47801bb54a690c5ae105a46b392ac6099881cdfb9f6e95e4014c6a", size = 24208, upload-time = "2024-10-18T15:21:28.744Z" },

     

       471
       471
       -
           { url = "https://files.pythonhosted.org/packages/f9/bf/176950a1792b2cd2102b8ffeb5133e1ed984547b75db47c25a67d3359f77/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:cabc348d87e913db6ab4aa100f01b08f481097838bdddf7c7a84b7575b7309ca", size = 23357, upload-time = "2024-10-18T15:21:29.545Z" },

     

       472
       472
       -
           { url = "https://files.pythonhosted.org/packages/ce/4f/9a02c1d335caabe5c4efb90e1b6e8ee944aa245c1aaaab8e8a618987d816/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:444dcda765c8a838eaae23112db52f1efaf750daddb2d9ca300bcae1039adc5c", size = 23344, upload-time = "2024-10-18T15:21:30.366Z" },

     

       473
       473
       -
           { url = "https://files.pythonhosted.org/packages/ee/55/c271b57db36f748f0e04a759ace9f8f759ccf22b4960c270c78a394f58be/MarkupSafe-3.0.2-cp313-cp313-win32.whl", hash = "sha256:bcf3e58998965654fdaff38e58584d8937aa3096ab5354d493c77d1fdd66d7a1", size = 15101, upload-time = "2024-10-18T15:21:31.207Z" },

     

       474
       474
       -
           { url = "https://files.pythonhosted.org/packages/29/88/07df22d2dd4df40aba9f3e402e6dc1b8ee86297dddbad4872bd5e7b0094f/MarkupSafe-3.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:e6a2a455bd412959b57a172ce6328d2dd1f01cb2135efda2e4576e8a23fa3b0f", size = 15603, upload-time = "2024-10-18T15:21:32.032Z" },

     

       475
       475
       -
           { url = "https://files.pythonhosted.org/packages/62/6a/8b89d24db2d32d433dffcd6a8779159da109842434f1dd2f6e71f32f738c/MarkupSafe-3.0.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:b5a6b3ada725cea8a5e634536b1b01c30bcdcd7f9c6fff4151548d5bf6b3a36c", size = 14510, upload-time = "2024-10-18T15:21:33.625Z" },

     

       476
       476
       -
           { url = "https://files.pythonhosted.org/packages/7a/06/a10f955f70a2e5a9bf78d11a161029d278eeacbd35ef806c3fd17b13060d/MarkupSafe-3.0.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a904af0a6162c73e3edcb969eeeb53a63ceeb5d8cf642fade7d39e7963a22ddb", size = 12486, upload-time = "2024-10-18T15:21:34.611Z" },

     

       477
       477
       -
           { url = "https://files.pythonhosted.org/packages/34/cf/65d4a571869a1a9078198ca28f39fba5fbb910f952f9dbc5220afff9f5e6/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4aa4e5faecf353ed117801a068ebab7b7e09ffb6e1d5e412dc852e0da018126c", size = 25480, upload-time = "2024-10-18T15:21:35.398Z" },

     

       478
       478
       -
           { url = "https://files.pythonhosted.org/packages/0c/e3/90e9651924c430b885468b56b3d597cabf6d72be4b24a0acd1fa0e12af67/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0ef13eaeee5b615fb07c9a7dadb38eac06a0608b41570d8ade51c56539e509d", size = 23914, upload-time = "2024-10-18T15:21:36.231Z" },

     

       479
       479
       -
           { url = "https://files.pythonhosted.org/packages/66/8c/6c7cf61f95d63bb866db39085150df1f2a5bd3335298f14a66b48e92659c/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d16a81a06776313e817c951135cf7340a3e91e8c1ff2fac444cfd75fffa04afe", size = 23796, upload-time = "2024-10-18T15:21:37.073Z" },

     

       480
       480
       -
           { url = "https://files.pythonhosted.org/packages/bb/35/cbe9238ec3f47ac9a7c8b3df7a808e7cb50fe149dc7039f5f454b3fba218/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6381026f158fdb7c72a168278597a5e3a5222e83ea18f543112b2662a9b699c5", size = 25473, upload-time = "2024-10-18T15:21:37.932Z" },

     

       481
       481
       -
           { url = "https://files.pythonhosted.org/packages/e6/32/7621a4382488aa283cc05e8984a9c219abad3bca087be9ec77e89939ded9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:3d79d162e7be8f996986c064d1c7c817f6df3a77fe3d6859f6f9e7be4b8c213a", size = 24114, upload-time = "2024-10-18T15:21:39.799Z" },

     

       482
       482
       -
           { url = "https://files.pythonhosted.org/packages/0d/80/0985960e4b89922cb5a0bac0ed39c5b96cbc1a536a99f30e8c220a996ed9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:131a3c7689c85f5ad20f9f6fb1b866f402c445b220c19fe4308c0b147ccd2ad9", size = 24098, upload-time = "2024-10-18T15:21:40.813Z" },

     

       483
       483
       -
           { url = "https://files.pythonhosted.org/packages/82/78/fedb03c7d5380df2427038ec8d973587e90561b2d90cd472ce9254cf348b/MarkupSafe-3.0.2-cp313-cp313t-win32.whl", hash = "sha256:ba8062ed2cf21c07a9e295d5b8a2a5ce678b913b45fdf68c32d95d6c1291e0b6", size = 15208, upload-time = "2024-10-18T15:21:41.814Z" },

     

       484
       484
       -
           { url = "https://files.pythonhosted.org/packages/4f/65/6079a46068dfceaeabb5dcad6d674f5f5c61a6fa5673746f42a9f4c233b3/MarkupSafe-3.0.2-cp313-cp313t-win_amd64.whl", hash = "sha256:e444a31f8db13eb18ada366ab3cf45fd4b31e4db1236a4448f68778c1d1a5a2f", size = 15739, upload-time = "2024-10-18T15:21:42.784Z" },

     

       485
       485
       -
           { url = "https://files.pythonhosted.org/packages/a7/ea/9b1530c3fdeeca613faeb0fb5cbcf2389d816072fab72a71b45749ef6062/MarkupSafe-3.0.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:eaa0a10b7f72326f1372a713e73c3f739b524b3af41feb43e4921cb529f5929a", size = 14344, upload-time = "2024-10-18T15:21:43.721Z" },

     

       486
       486
       -
           { url = "https://files.pythonhosted.org/packages/4b/c2/fbdbfe48848e7112ab05e627e718e854d20192b674952d9042ebd8c9e5de/MarkupSafe-3.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:48032821bbdf20f5799ff537c7ac3d1fba0ba032cfc06194faffa8cda8b560ff", size = 12389, upload-time = "2024-10-18T15:21:44.666Z" },

     

       487
       487
       -
           { url = "https://files.pythonhosted.org/packages/f0/25/7a7c6e4dbd4f867d95d94ca15449e91e52856f6ed1905d58ef1de5e211d0/MarkupSafe-3.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1a9d3f5f0901fdec14d8d2f66ef7d035f2157240a433441719ac9a3fba440b13", size = 21607, upload-time = "2024-10-18T15:21:45.452Z" },

     

       488
       488
       -
           { url = "https://files.pythonhosted.org/packages/53/8f/f339c98a178f3c1e545622206b40986a4c3307fe39f70ccd3d9df9a9e425/MarkupSafe-3.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:88b49a3b9ff31e19998750c38e030fc7bb937398b1f78cfa599aaef92d693144", size = 20728, upload-time = "2024-10-18T15:21:46.295Z" },

     

       489
       489
       -
           { url = "https://files.pythonhosted.org/packages/1a/03/8496a1a78308456dbd50b23a385c69b41f2e9661c67ea1329849a598a8f9/MarkupSafe-3.0.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cfad01eed2c2e0c01fd0ecd2ef42c492f7f93902e39a42fc9ee1692961443a29", size = 20826, upload-time = "2024-10-18T15:21:47.134Z" },

     

       490
       490
       -
           { url = "https://files.pythonhosted.org/packages/e6/cf/0a490a4bd363048c3022f2f475c8c05582179bb179defcee4766fb3dcc18/MarkupSafe-3.0.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:1225beacc926f536dc82e45f8a4d68502949dc67eea90eab715dea3a21c1b5f0", size = 21843, upload-time = "2024-10-18T15:21:48.334Z" },

     

       491
       491
       -
           { url = "https://files.pythonhosted.org/packages/19/a3/34187a78613920dfd3cdf68ef6ce5e99c4f3417f035694074beb8848cd77/MarkupSafe-3.0.2-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:3169b1eefae027567d1ce6ee7cae382c57fe26e82775f460f0b2778beaad66c0", size = 21219, upload-time = "2024-10-18T15:21:49.587Z" },

     

       492
       492
       -
           { url = "https://files.pythonhosted.org/packages/17/d8/5811082f85bb88410ad7e452263af048d685669bbbfb7b595e8689152498/MarkupSafe-3.0.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:eb7972a85c54febfb25b5c4b4f3af4dcc731994c7da0d8a0b4a6eb0640e1d178", size = 20946, upload-time = "2024-10-18T15:21:50.441Z" },

     

       493
       493
       -
           { url = "https://files.pythonhosted.org/packages/7c/31/bd635fb5989440d9365c5e3c47556cfea121c7803f5034ac843e8f37c2f2/MarkupSafe-3.0.2-cp39-cp39-win32.whl", hash = "sha256:8c4e8c3ce11e1f92f6536ff07154f9d49677ebaaafc32db9db4620bc11ed480f", size = 15063, upload-time = "2024-10-18T15:21:51.385Z" },

     

       494
       494
       -
           { url = "https://files.pythonhosted.org/packages/b3/73/085399401383ce949f727afec55ec3abd76648d04b9f22e1c0e99cb4bec3/MarkupSafe-3.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:6e296a513ca3d94054c2c881cc913116e90fd030ad1c656b3869762b754f5f8a", size = 15506, upload-time = "2024-10-18T15:21:52.974Z" },

     

       495
       495
       -
       ]

     

       496
       496
       -
       

     

       497
       497
       -
       [[package]]

     

       498
       498
       -
       name = "mdit-py-plugins"

     

       499
       499
       -
       version = "0.4.2"

     

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

     

       501
       501
       -
       dependencies = [

     

       502
       502
       -
           { name = "markdown-it-py" },

     

       503
       503
       -
       ]

     

       504
       504
       -
       sdist = { url = "https://files.pythonhosted.org/packages/19/03/a2ecab526543b152300717cf232bb4bb8605b6edb946c845016fa9c9c9fd/mdit_py_plugins-0.4.2.tar.gz", hash = "sha256:5f2cd1fdb606ddf152d37ec30e46101a60512bc0e5fa1a7002c36647b09e26b5", size = 43542, upload-time = "2024-09-09T20:27:49.564Z" }

     

       505
       505
       -
       wheels = [

     

       506
       506
       -
           { url = "https://files.pythonhosted.org/packages/a7/f7/7782a043553ee469c1ff49cfa1cdace2d6bf99a1f333cf38676b3ddf30da/mdit_py_plugins-0.4.2-py3-none-any.whl", hash = "sha256:0c673c3f889399a33b95e88d2f0d111b4447bdfea7f237dab2d488f459835636", size = 55316, upload-time = "2024-09-09T20:27:48.397Z" },

     

       507
       346
        
       ]

     

       508
       347
        
       

     

       509
       348
        
       [[package]]

     
···

       1028
       867
        
       ]

     

       1029
       868
        
       

     

       1030
       869
        
       [[package]]

     

       1031
       1031
       -
       name = "textual"

     

       1032
       1032
       -
       version = "4.0.0"

     

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

     

       1034
       1034
       -
       dependencies = [

     

       1035
       1035
       -
           { name = "markdown-it-py", extra = ["linkify", "plugins"] },

     

       1036
       1036
       -
           { name = "platformdirs" },

     

       1037
       1037
       -
           { name = "rich" },

     

       1038
       1038
       -
           { name = "typing-extensions" },

     

       1039
       1039
       -
       ]

     

       1040
       1040
       -
       sdist = { url = "https://files.pythonhosted.org/packages/f1/22/a2812ab1e5b0cb3a327a4ea79b430234c2271ba13462b989f435b40a247d/textual-4.0.0.tar.gz", hash = "sha256:1cab4ea3cfc0e47ae773405cdd6bc2a17ed76ff7b648379ac8017ea89c5ad28c", size = 1606128, upload-time = "2025-07-12T09:41:20.812Z" }

     

       1041
       1041
       -
       wheels = [

     

       1042
       1042
       -
           { url = "https://files.pythonhosted.org/packages/d8/e4/ebe27c54d2534cc41d00ea1d78b783763f97abf3e3d6dd41e5536daa52a5/textual-4.0.0-py3-none-any.whl", hash = "sha256:214051640f890676a670aa7d29cd2a37d27cfe6b2cf866e9d5abc3b6c89c5800", size = 692382, upload-time = "2025-07-12T09:41:18.828Z" },

     

       1043
       1043
       -
       ]

     

       1044
       1044
       -
       

     

       1045
       1045
       -
       [[package]]

     

       1046
       870
        
       name = "thicket"

     

       1047
       871
        
       source = { editable = "." }

     

       1048
       872
        
       dependencies = [

     

       1049
       873
        
           { name = "bleach" },

     

       1050
       874
        
           { name = "email-validator" },

     

       1051
       875
        
           { name = "feedparser" },

     

       1052
       1052
       -
           { name = "flask" },

     

       1053
       876
        
           { name = "gitpython" },

     

       1054
       877
        
           { name = "httpx" },

     

       1055
       878
        
           { name = "pendulum" },

     
···

       1058
       881
        
           { name = "pydantic-settings" },

     

       1059
       882
        
           { name = "pyyaml" },

     

       1060
       883
        
           { name = "rich" },

     

       1061
       1061
       -
           { name = "textual" },

     

       1062
       884
        
           { name = "typer" },

     

       1063
       885
        
       ]

     

       1064
       886
        
       

     
···

       1073
       895
        
           { name = "types-pyyaml" },

     

       1074
       896
        
       ]

     

       1075
       897
        
       

     

       898
       898
       +
       [package.dev-dependencies]

     

       899
       899
       +
       dev = [

     

       900
       900
       +
           { name = "pytest" },

     

       901
       901
       +
       ]

     

       902
       902
       +
       

     

       1076
       903
        
       [package.metadata]

     

       1077
       904
        
       requires-dist = [

     

       1078
       905
        
           { name = "black", marker = "extra == 'dev'", specifier = ">=24.0.0" },

     

       1079
       906
        
           { name = "bleach", specifier = ">=6.0.0" },

     

       1080
       907
        
           { name = "email-validator" },

     

       1081
       908
        
           { name = "feedparser", specifier = ">=6.0.11" },

     

       1082
       1082
       -
           { name = "flask", specifier = ">=3.1.1" },

     

       1083
       909
        
           { name = "gitpython", specifier = ">=3.1.40" },

     

       1084
       910
        
           { name = "httpx", specifier = ">=0.28.0" },

     

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

     
···

       1093
       919
        
           { name = "pyyaml", specifier = ">=6.0.0" },

     

       1094
       920
        
           { name = "rich", specifier = ">=13.0.0" },

     

       1095
       921
        
           { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.8.0" },

     

       1096
       1096
       -
           { name = "textual", specifier = ">=4.0.0" },

     

       1097
       922
        
           { name = "typer", specifier = ">=0.15.0" },

     

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

     

       1099
       924
        
       ]

     

       1100
       925
        
       provides-extras = ["dev"]

     

       926
       926
       +
       

     

       927
       927
       +
       [package.metadata.requires-dev]

     

       928
       928
       +
       dev = [{ name = "pytest", specifier = ">=8.4.1" }]

     

       1101
       929
        
       

     

       1102
       930
        
       [[package]]

     

       1103
       931
        
       name = "tomli"

     
···

       1194
       1022
        
       ]

     

       1195
       1023
        
       

     

       1196
       1024
        
       [[package]]

     

       1197
       1197
       -
       name = "uc-micro-py"

     

       1198
       1198
       -
       version = "1.0.3"

     

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

     

       1200
       1200
       -
       sdist = { url = "https://files.pythonhosted.org/packages/91/7a/146a99696aee0609e3712f2b44c6274566bc368dfe8375191278045186b8/uc-micro-py-1.0.3.tar.gz", hash = "sha256:d321b92cff673ec58027c04015fcaa8bb1e005478643ff4a500882eaab88c48a", size = 6043, upload-time = "2024-02-09T16:52:01.654Z" }

     

       1201
       1201
       -
       wheels = [

     

       1202
       1202
       -
           { url = "https://files.pythonhosted.org/packages/37/87/1f677586e8ac487e29672e4b17455758fce261de06a0d086167bb760361a/uc_micro_py-1.0.3-py3-none-any.whl", hash = "sha256:db1dffff340817673d7b466ec86114a9dc0e9d4d9b5ba229d9d60e5c12600cd5", size = 6229, upload-time = "2024-02-09T16:52:00.371Z" },

     

       1203
       1203
       -
       ]

     

       1204
       1204
       -
       

     

       1205
       1205
       -
       [[package]]

     

       1206
       1025
        
       name = "webencodings"

     

       1207
       1026
        
       version = "0.5.1"

     

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

     
···

       1210
       1029
        
       wheels = [

     

       1211
       1030
        
           { 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" },

     

       1212
       1031
        
       ]

     

       1213
       1213
       -
       

     

       1214
       1214
       -
       [[package]]

     

       1215
       1215
       -
       name = "werkzeug"

     

       1216
       1216
       -
       version = "3.1.3"

     

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

     

       1218
       1218
       -
       dependencies = [

     

       1219
       1219
       -
           { name = "markupsafe" },

     

       1220
       1220
       -
       ]

     

       1221
       1221
       -
       sdist = { url = "https://files.pythonhosted.org/packages/9f/69/83029f1f6300c5fb2471d621ab06f6ec6b3324685a2ce0f9777fd4a8b71e/werkzeug-3.1.3.tar.gz", hash = "sha256:60723ce945c19328679790e3282cc758aa4a6040e4bb330f53d30fa546d44746", size = 806925, upload-time = "2024-11-08T15:52:18.093Z" }

     

       1222
       1222
       -
       wheels = [

     

       1223
       1223
       -
           { url = "https://files.pythonhosted.org/packages/52/24/ab44c871b0f07f491e5d2ad12c9bd7358e527510618cb1b803a88e986db1/werkzeug-3.1.3-py3-none-any.whl", hash = "sha256:54b78bf3716d19a65be4fceccc0d1d7b89e608834989dfae50ea87564639213e", size = 224498, upload-time = "2024-11-08T15:52:16.132Z" },

     

       1224
       1224
       -
       ]

     

       1225
       1225
       -
       

     

       1226
       1226
       -
       [[package]]

     

       1227
       1227
       -
       name = "zipp"

     

       1228
       1228
       -
       version = "3.23.0"

     

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

     

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

     

       1231
       1231
       -
       wheels = [

     

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

     

       1233
       1233
       -
       ]