add find-stale-bsky-follows script and support custom PDS

- new script to identify inactive accounts you're following
- add BSKY_PDS_URL support to both bsky scripts

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[e-mail]>

README.md

···
 - [`check-files-for-bad-links`](#check-files-for-bad-links)
 - [`dm-me-when-a-flight-passes-over`](#dm-me-when-a-flight-passes-over)
 - [`find-longest-bsky-thread`](#find-longest-bsky-thread)
+- [`find-stale-bsky-follows`](#find-stale-bsky-follows)
 - [`kill-processes`](#kill-processes)
 - [`predict-github-stars`](#predict-github-stars)
 - [`update-lights`](#update-lights)
···
 Details:
 - uses [`atproto`](https://github.com/MarshalX/atproto) to fetch the thread
 - uses [`jinja2`](https://github.com/pallets/jinja) to render the thread
+
+---
+
+### `find-stale-bsky-follows`
+
+Find stale/inactive accounts among those you follow on Bluesky.
+
+Usage:
+
+```bash
+./find-stale-bsky-follows
+# or with custom inactivity threshold (days)
+./find-stale-bsky-follows --days 180
+```
+
+Details:
+- uses [`atproto`](https://github.com/MarshalX/atproto) to fetch following list
+- uses [`rich`](https://github.com/Textualize/rich) for pretty output
+- identifies accounts with no recent posts
 
 ---
 

find-longest-bsky-thread

···
 
     bsky_handle: str
     bsky_password: str
+    bsky_pds_url: str = "https://bsky.social"
 
 
 def extract_post_uri(bluesky_url: str) -> str:
···
         )
         return
 
-    client = Client()
+    client = Client(base_url=settings.bsky_pds_url)
     try:
         client.login(settings.bsky_handle, settings.bsky_password)
     except Exception as e:

find-stale-bsky-follows

···
+#!/usr/bin/env -S uv run --script --quiet
+# /// script
+# requires-python = ">=3.12"
+# dependencies = ["atproto", "pydantic-settings", "rich"]
+# ///
+"""
+Find stale/inactive accounts among those you follow on Bluesky.
+
+Usage:
+
+```bash
+./find-stale-bsky-follows
+# or with custom inactivity threshold (days)
+./find-stale-bsky-follows --days 180
+```
+
+Details:
+- uses [`atproto`](https://github.com/MarshalX/atproto) to fetch following list
+- uses [`rich`](https://github.com/Textualize/rich) for pretty output
+- identifies accounts with no recent posts
+"""
+
+import argparse
+import os
+from datetime import datetime, timedelta, timezone
+from typing import NamedTuple
+
+from atproto import Client
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.table import Table
+
+
+class Settings(BaseSettings):
+    """App settings loaded from environment variables"""
+
+    model_config = SettingsConfigDict(
+        env_file=os.environ.get("ENV_FILE", ".env"), extra="ignore"
+    )
+
+    bsky_handle: str
+    bsky_password: str
+    bsky_pds_url: str = "https://bsky.social"
+
+
+class AccountActivity(NamedTuple):
+    """Activity information for a Bluesky account"""
+
+    handle: str
+    display_name: str | None
+    did: str
+    posts_count: int
+    last_post_date: datetime | None
+    days_inactive: int | None
+    is_stale: bool
+
+
+def get_following_list(client: Client) -> list[dict]:
+    """Fetch all accounts the authenticated user follows"""
+    following = []
+    cursor = None
+
+    while True:
+        assert client.me, "client.me should be set"
+        response = client.get_follows(client.me.did, cursor=cursor)
+        following.extend(response.follows)
+
+        if not response.cursor:
+            break
+        cursor = response.cursor
+
+    return following
+
+
+def check_account_activity(
+    client: Client, actor: dict, inactivity_threshold_days: int
+) -> AccountActivity:
+    """
+    Check the activity of a single account.
+
+    Returns AccountActivity with stale status based on:
+    - No posts at all
+    - Last post older than threshold
+    """
+    handle = actor.handle
+    did = actor.did
+    display_name = getattr(actor, "display_name", None)
+
+    try:
+        # Get the user's profile to check post count
+        profile = client.get_profile(handle)
+        posts_count = profile.posts_count or 0
+
+        # If no posts, immediately mark as stale
+        if posts_count == 0:
+            return AccountActivity(
+                handle=handle,
+                display_name=display_name,
+                did=did,
+                posts_count=0,
+                last_post_date=None,
+                days_inactive=None,
+                is_stale=True,
+            )
+
+        # Get author feed to find last post
+        feed_response = client.get_author_feed(actor=handle, limit=1)
+
+        last_post_date = None
+        if feed_response.feed:
+            last_post = feed_response.feed[0].post
+            if hasattr(last_post.record, "created_at"):
+                created_at_str = last_post.record.created_at
+                # Parse ISO 8601 timestamp
+                last_post_date = datetime.fromisoformat(
+                    created_at_str.replace("Z", "+00:00")
+                )
+
+        # Calculate days inactive
+        if last_post_date:
+            days_inactive = (datetime.now(timezone.utc) - last_post_date).days
+            is_stale = days_inactive > inactivity_threshold_days
+        else:
+            # Has posts but couldn't determine date - consider stale
+            days_inactive = None
+            is_stale = True
+
+        return AccountActivity(
+            handle=handle,
+            display_name=display_name,
+            did=did,
+            posts_count=posts_count,
+            last_post_date=last_post_date,
+            days_inactive=days_inactive,
+            is_stale=is_stale,
+        )
+
+    except Exception as e:
+        # If we can't check activity, mark as potentially problematic
+        # (could be deleted, suspended, or private)
+        return AccountActivity(
+            handle=handle,
+            display_name=display_name,
+            did=did,
+            posts_count=0,
+            last_post_date=None,
+            days_inactive=None,
+            is_stale=True,
+        )
+
+
+def format_account_link(handle: str) -> str:
+    """Format a clickable Bluesky profile link"""
+    return f"https://bsky.app/profile/{handle}"
+
+
+def main(inactivity_threshold_days: int):
+    """Main function to find stale accounts"""
+    console = Console()
+
+    try:
+        settings = Settings()  # type: ignore
+    except Exception as e:
+        console.print(
+            f"[red]Error loading settings (ensure .env file exists with BSKY_HANDLE and BSKY_PASSWORD): {e}[/red]"
+        )
+        return
+
+    client = Client(base_url=settings.bsky_pds_url)
+    try:
+        client.login(settings.bsky_handle, settings.bsky_password)
+    except Exception as e:
+        console.print(f"[red]Error logging into Bluesky: {e}[/red]")
+        return
+
+    console.print(f"[blue]Logged in as {client.me.handle}[/blue]")
+    console.print(
+        f"[blue]Checking for accounts inactive for more than {inactivity_threshold_days} days...[/blue]\n"
+    )
+
+    # Fetch following list
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        task = progress.add_task("Fetching following list...", total=None)
+        following = get_following_list(client)
+        progress.update(task, completed=True)
+
+    console.print(f"[green]Found {len(following)} accounts you follow[/green]\n")
+
+    # Check activity for each account
+    stale_accounts = []
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        task = progress.add_task("Analyzing account activity...", total=len(following))
+
+        for actor in following:
+            activity = check_account_activity(
+                client, actor, inactivity_threshold_days
+            )
+            if activity.is_stale:
+                stale_accounts.append(activity)
+            progress.advance(task)
+
+    # Display results
+    console.print(f"\n[yellow]Found {len(stale_accounts)} stale accounts:[/yellow]\n")
+
+    if stale_accounts:
+        table = Table(show_header=True, header_style="bold magenta")
+        table.add_column("Handle", style="cyan")
+        table.add_column("Display Name", style="white")
+        table.add_column("Posts", justify="right", style="blue")
+        table.add_column("Last Post", style="yellow")
+        table.add_column("Days Inactive", justify="right", style="red")
+
+        # Sort by days inactive (None values last)
+        stale_accounts.sort(
+            key=lambda x: (x.days_inactive is None, x.days_inactive or 0),
+            reverse=True,
+        )
+
+        for account in stale_accounts:
+            last_post = (
+                account.last_post_date.strftime("%Y-%m-%d")
+                if account.last_post_date
+                else "Never"
+            )
+            days = str(account.days_inactive) if account.days_inactive else "Unknown"
+
+            table.add_row(
+                f"@{account.handle}",
+                account.display_name or "[dim]No name[/dim]",
+                str(account.posts_count),
+                last_post,
+                days,
+            )
+
+        console.print(table)
+
+        # Print links for easy access
+        console.print("\n[dim]Profile links:[/dim]")
+        for account in stale_accounts[:10]:  # Limit to first 10
+            console.print(f"  {format_account_link(account.handle)}")
+        if len(stale_accounts) > 10:
+            console.print(f"  [dim]... and {len(stale_accounts) - 10} more[/dim]")
+    else:
+        console.print("[green]All accounts you follow are active![/green]")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Find stale/inactive accounts you follow on Bluesky."
+    )
+    parser.add_argument(
+        "--days",
+        type=int,
+        default=180,
+        help="Number of days of inactivity to consider an account stale (default: 180)",
+    )
+    args = parser.parse_args()
+
+    main(args.days)