tell me when planes are above

rm test file

README.md

···
 ## scripts
 
 - [`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)
 - [`kill-processes`](#kill-processes)
 - [`predict-github-stars`](#predict-github-stars)
···
 
 ---
 
+### `dm-me-when-a-flight-passes-over`
+
+Monitor flights passing overhead and send BlueSky DMs.
+
+Usage:
+    # Single user mode (backward compatible)
+    ./dm-me-when-a-flight-passes-over
+
+    # Multi-subscriber mode with JSON file
+    ./dm-me-when-a-flight-passes-over --subscribers subscribers.json
+
+    # Multi-subscriber mode with stdin
+    echo '[{"handle": "user1.bsky.social", "latitude": 41.8781, "longitude": -87.6298, "radius_miles": 5}]' | ./dm-me-when-a-flight-passes-over --subscribers -
+
+This script monitors flights within a configurable radius and sends DMs on BlueSky
+when flights pass overhead. Supports multiple subscribers with different locations.
+
+## Future Architecture Ideas
+
+### Web App Deployment Options
+
+1. **FastAPI + Fly.io/Railway/Render**
+   - REST API with endpoints:
+     - POST /subscribe - Register user with BlueSky handle
+     - DELETE /unsubscribe - Remove subscription
+     - POST /update-location - Update user's location
+     - GET /status - Check subscription status
+   - Background worker using Celery/RQ/APScheduler
+   - PostgreSQL/SQLite for subscriber persistence
+   - Redis for caching flight data & deduplication
+
+2. **Vercel/Netlify Edge Functions**
+   - Serverless approach with scheduled cron jobs
+   - Use Vercel KV or Upstash Redis for state
+   - Challenge: Long-running monitoring needs workarounds
+   - Solution: Trigger checks via cron every minute
+
+3. **Self-Hosted with ngrok/Cloudflare Tunnel**
+   - Quick prototype option
+   - Run this script as daemon
+   - Expose simple Flask/FastAPI wrapper
+   - Security concerns: rate limiting, auth required
+
+### Mobile/Browser Integration
+
+1. **Progressive Web App (PWA)**
+   - Service worker for background location updates
+   - Geolocation API for current position
+   - Push notifications instead of/alongside DMs
+   - IndexedDB for offline capability
+
+2. **iOS Shortcuts Integration**
+   - Create shortcut that gets location
+   - Calls webhook with location + BlueSky handle
+   - Could run automatically based on focus modes
+
+3. **Browser Extension**
+   - Background script polls location
+   - Lighter weight than full app
+   - Cross-platform solution
+
+### Architecture Components
+
+1. **Location Services Layer**
+   - Browser Geolocation API
+   - IP-based geolocation fallback
+   - Manual location picker UI
+   - Privacy: Only send location when checking flights
+
+2. **Notification Options**
+   - BlueSky DMs (current)
+   - Web Push Notifications
+   - Webhooks to other services
+   - Email/SMS via Twilio/SendGrid
+
+3. **Subscription Management**
+   - OAuth with BlueSky for auth
+   - User preferences: radius, notification types
+   - Quiet hours/Do Not Disturb
+   - Rate limiting per user
+
+4. **Data Optimization**
+   - Cache FlightRadar API responses
+   - Batch location updates
+   - Aggregate nearby users for efficiency
+   - WebSocket for real-time updates
+
+### Implementation Approach
+
+Phase 1: Web API Wrapper
+- FastAPI with /subscribe endpoint
+- SQLite for subscribers
+- Run monitoring in background thread
+- Deploy to Fly.io free tier
+
+Phase 2: Web UI
+- Simple React/Vue form
+- Geolocation permission request
+- Show nearby flights on map
+- Subscription management
+
+Phase 3: Mobile Experience
+- PWA with service workers
+- Background location updates
+- Local notifications
+- Offline support
+
+### Security Considerations
+- Rate limit FlightRadar API calls
+- Authenticate BlueSky handles
+- Validate location bounds
+- Prevent subscription spam
+- GDPR compliance for location data
+
+---
+
 ### `find-longest-bsky-thread`
 
 Find the longest reply thread from a Bluesky post.
···
 Predict when a GitHub repository will reach a target number of stars.
 
 Usage:
-
-```bash
-./predict-github-stars anthropics/claude-dev 10000
-```
+    ./predict-github-stars owner/repo 10000
 
 Details:
-- uses github api to fetch star history
-- uses polynomial regression to predict future star growth
-- shows confidence intervals based on historical variance
-- requires `GITHUB_TOKEN` in environment for higher rate limits (optional)
+- Uses GitHub REST API to fetch star history (with timestamps).
+- Fits polynomial regression (degree 1–3) to full history.
+- Falls back to recent‑trend linear extrapolation if the polynomial
+  cannot reach the target within ten years.
+- Shows recent growth rate and a caution for long‑range estimates.
+- Requires `GITHUB_TOKEN` in the environment for higher rate limits (optional).
 
 ---
 

dm-me-when-a-flight-passes-over

···
+#!/usr/bin/env -S uv run --script --quiet
+# /// script
+# requires-python = ">=3.12"
+# dependencies = ["atproto", "pydantic-settings", "geopy", "httpx"]
+# ///
+"""
+Monitor flights passing overhead and send BlueSky DMs.
+
+Usage:
+    # Single user mode (backward compatible)
+    ./dm-me-when-a-flight-passes-over
+
+    # Multi-subscriber mode with JSON file
+    ./dm-me-when-a-flight-passes-over --subscribers subscribers.json
+
+    # Multi-subscriber mode with stdin
+    echo '[{"handle": "user1.bsky.social", "latitude": 41.8781, "longitude": -87.6298, "radius_miles": 5}]' | ./dm-me-when-a-flight-passes-over --subscribers -
+
+This script monitors flights within a configurable radius and sends DMs on BlueSky
+when flights pass overhead. Supports multiple subscribers with different locations.
+
+## Future Architecture Ideas
+
+### Web App Deployment Options
+
+1. **FastAPI + Fly.io/Railway/Render**
+   - REST API with endpoints:
+     - POST /subscribe - Register user with BlueSky handle
+     - DELETE /unsubscribe - Remove subscription
+     - POST /update-location - Update user's location
+     - GET /status - Check subscription status
+   - Background worker using Celery/RQ/APScheduler
+   - PostgreSQL/SQLite for subscriber persistence
+   - Redis for caching flight data & deduplication
+
+2. **Vercel/Netlify Edge Functions**
+   - Serverless approach with scheduled cron jobs
+   - Use Vercel KV or Upstash Redis for state
+   - Challenge: Long-running monitoring needs workarounds
+   - Solution: Trigger checks via cron every minute
+
+3. **Self-Hosted with ngrok/Cloudflare Tunnel**
+   - Quick prototype option
+   - Run this script as daemon
+   - Expose simple Flask/FastAPI wrapper
+   - Security concerns: rate limiting, auth required
+
+### Mobile/Browser Integration
+
+1. **Progressive Web App (PWA)**
+   - Service worker for background location updates
+   - Geolocation API for current position
+   - Push notifications instead of/alongside DMs
+   - IndexedDB for offline capability
+
+2. **iOS Shortcuts Integration**
+   - Create shortcut that gets location
+   - Calls webhook with location + BlueSky handle
+   - Could run automatically based on focus modes
+
+3. **Browser Extension**
+   - Background script polls location
+   - Lighter weight than full app
+   - Cross-platform solution
+
+### Architecture Components
+
+1. **Location Services Layer**
+   - Browser Geolocation API
+   - IP-based geolocation fallback
+   - Manual location picker UI
+   - Privacy: Only send location when checking flights
+
+2. **Notification Options**
+   - BlueSky DMs (current)
+   - Web Push Notifications
+   - Webhooks to other services
+   - Email/SMS via Twilio/SendGrid
+
+3. **Subscription Management**
+   - OAuth with BlueSky for auth
+   - User preferences: radius, notification types
+   - Quiet hours/Do Not Disturb
+   - Rate limiting per user
+
+4. **Data Optimization**
+   - Cache FlightRadar API responses
+   - Batch location updates
+   - Aggregate nearby users for efficiency
+   - WebSocket for real-time updates
+
+### Implementation Approach
+
+Phase 1: Web API Wrapper
+- FastAPI with /subscribe endpoint
+- SQLite for subscribers
+- Run monitoring in background thread
+- Deploy to Fly.io free tier
+
+Phase 2: Web UI
+- Simple React/Vue form
+- Geolocation permission request
+- Show nearby flights on map
+- Subscription management
+
+Phase 3: Mobile Experience
+- PWA with service workers
+- Background location updates
+- Local notifications
+- Offline support
+
+### Security Considerations
+- Rate limit FlightRadar API calls
+- Authenticate BlueSky handles
+- Validate location bounds
+- Prevent subscription spam
+- GDPR compliance for location data
+"""
+
+import argparse
+import time
+import math
+import json
+import sys
+from datetime import datetime
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+import httpx
+from atproto import Client
+from geopy import distance
+from pydantic import BaseModel, Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    """App settings loaded from environment variables"""
+
+    model_config = SettingsConfigDict(env_file=".env", extra="ignore")
+
+    bsky_handle: str = Field(...)
+    bsky_password: str = Field(...)
+    flightradar_api_token: str = Field(...)
+
+
+class Subscriber(BaseModel):
+    """Subscriber with location information"""
+
+    handle: str
+    latitude: float
+    longitude: float
+    radius_miles: float = 5.0
+
+
+class Flight(BaseModel):
+    """Flight data model"""
+
+    hex: str
+    latitude: float
+    longitude: float
+    altitude: float | None = None
+    ground_speed: float | None = None
+    heading: float | None = None
+    aircraft_type: str | None = None
+    registration: str | None = None
+    origin: str | None = None
+    destination: str | None = None
+    callsign: str | None = None
+    distance_miles: float
+
+
+def get_flights_in_area(
+    settings: Settings, latitude: float, longitude: float, radius_miles: float
+) -> list[Flight]:
+    """Get flights within the specified radius using FlightRadar24 API."""
+    lat_offset = radius_miles / 69  # 1 degree latitude ≈ 69 miles
+    lon_offset = radius_miles / (69 * abs(math.cos(math.radians(latitude))))
+
+    bounds = {
+        "north": latitude + lat_offset,
+        "south": latitude - lat_offset,
+        "west": longitude - lon_offset,
+        "east": longitude + lon_offset,
+    }
+
+    headers = {
+        "Authorization": f"Bearer {settings.flightradar_api_token}",
+        "Accept": "application/json",
+        "Accept-Version": "v1",
+    }
+
+    url = "https://fr24api.flightradar24.com/api/live/flight-positions/full"
+    params = {
+        "bounds": f"{bounds['north']},{bounds['south']},{bounds['west']},{bounds['east']}"
+    }
+
+    try:
+        with httpx.Client() as client:
+            response = client.get(url, headers=headers, params=params, timeout=10)
+            response.raise_for_status()
+            data = response.json()
+
+        flights_in_radius = []
+        center = (latitude, longitude)
+
+        if isinstance(data, dict) and "data" in data:
+            for flight_data in data["data"]:
+                lat = flight_data.get("lat")
+                lon = flight_data.get("lon")
+
+                if lat and lon:
+                    flight_pos = (lat, lon)
+                    dist = distance.distance(center, flight_pos).miles
+                    if dist <= radius_miles:
+                        flight = Flight(
+                            hex=flight_data.get("fr24_id", ""),
+                            latitude=lat,
+                            longitude=lon,
+                            altitude=flight_data.get("alt"),
+                            ground_speed=flight_data.get("gspeed"),
+                            heading=flight_data.get("track"),
+                            aircraft_type=flight_data.get("type"),
+                            registration=flight_data.get("reg"),
+                            origin=flight_data.get("orig_iata"),
+                            destination=flight_data.get("dest_iata"),
+                            callsign=flight_data.get("flight"),
+                            distance_miles=round(dist, 2),
+                        )
+                        flights_in_radius.append(flight)
+
+        return flights_in_radius
+    except httpx.HTTPStatusError as e:
+        print(f"HTTP error fetching flights: {e}")
+        print(f"Response status: {e.response.status_code}")
+        print(f"Response content: {e.response.text[:500]}")
+        return []
+    except Exception as e:
+        print(f"Error fetching flights: {e}")
+        return []
+
+
+def format_flight_info(flight: Flight) -> str:
+    """Format flight information for a DM."""
+    parts = ["✈️ Flight passing overhead!\n"]
+    
+    parts.append(f"Flight: {flight.callsign or 'Unknown'}")
+    parts.append(f"Distance: {flight.distance_miles} miles")
+    
+    if flight.altitude:
+        parts.append(f"Altitude: {flight.altitude:,.0f} ft")
+    if flight.ground_speed:
+        parts.append(f"Speed: {flight.ground_speed:.0f} kts")
+    if flight.heading:
+        parts.append(f"Heading: {flight.heading:.0f}°")
+    if flight.aircraft_type:
+        parts.append(f"Aircraft: {flight.aircraft_type}")
+    
+    if flight.origin or flight.destination:
+        route = f"{flight.origin or '???'} → {flight.destination or '???'}"
+        parts.append(f"Route: {route}")
+    
+    parts.append(f"\nTime: {datetime.now().strftime('%H:%M:%S')}")
+    
+    return "\n".join(parts)
+
+
+def send_dm(client: Client, message: str, target_handle: str) -> bool:
+    """Send a direct message to the specified handle on BlueSky."""
+    try:
+        resolved = client.com.atproto.identity.resolve_handle(
+            params={"handle": target_handle}
+        )
+        target_did = resolved.did
+
+        chat_client = client.with_bsky_chat_proxy()
+        
+        convo_response = chat_client.chat.bsky.convo.get_convo_for_members(
+            {"members": [target_did]}
+        )
+
+        if not convo_response or not convo_response.convo:
+            print(f"Could not create/get conversation with {target_handle}")
+            return False
+
+        recipient = None
+        for member in convo_response.convo.members:
+            if member.did != client.me.did:
+                recipient = member
+                break
+
+        if not recipient or recipient.handle != target_handle:
+            print(
+                f"ERROR: About to message wrong person! Expected {target_handle}, but found {recipient.handle if recipient else 'no recipient'}"
+            )
+            return False
+
+        chat_client.chat.bsky.convo.send_message(
+            data={
+                "convoId": convo_response.convo.id,
+                "message": {"text": message, "facets": []},
+            }
+        )
+
+        print(f"DM sent to {target_handle}")
+        return True
+
+    except Exception as e:
+        print(f"Error sending DM to {target_handle}: {e}")
+        return False
+
+
+def process_subscriber(
+    client: Client,
+    settings: Settings,
+    subscriber: Subscriber,
+    notified_flights: dict[str, set[str]],
+) -> None:
+    """Process flights for a single subscriber."""
+    try:
+        flights = get_flights_in_area(
+            settings, subscriber.latitude, subscriber.longitude, subscriber.radius_miles
+        )
+
+        if subscriber.handle not in notified_flights:
+            notified_flights[subscriber.handle] = set()
+
+        subscriber_notified = notified_flights[subscriber.handle]
+
+        for flight in flights:
+            flight_id = flight.hex
+
+            if flight_id not in subscriber_notified:
+                message = format_flight_info(flight)
+                print(f"\n[{subscriber.handle}] {message}\n")
+
+                if send_dm(client, message, subscriber.handle):
+                    print(f"DM sent to {subscriber.handle} for flight {flight_id}")
+                    subscriber_notified.add(flight_id)
+                else:
+                    print(
+                        f"Failed to send DM to {subscriber.handle} for flight {flight_id}"
+                    )
+
+        current_flight_ids = {f.hex for f in flights}
+        notified_flights[subscriber.handle] &= current_flight_ids
+
+        if not flights:
+            print(
+                f"[{subscriber.handle}] No flights in range at {datetime.now().strftime('%H:%M:%S')}"
+            )
+
+    except Exception as e:
+        print(f"Error processing subscriber {subscriber.handle}: {e}")
+
+
+def load_subscribers(subscribers_input: str | None) -> list[Subscriber]:
+    """Load subscribers from JSON file or stdin."""
+    if subscribers_input:
+        with open(subscribers_input, "r") as f:
+            data = json.load(f)
+    else:
+        print("Reading subscriber data from stdin (provide JSON array)...")
+        data = json.load(sys.stdin)
+
+    return [Subscriber(**item) for item in data]
+
+
+def main():
+    """Main monitoring loop."""
+    parser = argparse.ArgumentParser(
+        description="Monitor flights overhead and send BlueSky DMs"
+    )
+
+    parser.add_argument(
+        "--subscribers",
+        type=str,
+        help="JSON file with subscriber list, or '-' for stdin",
+    )
+    parser.add_argument(
+        "--latitude", type=float, default=41.8781, help="Latitude (default: Chicago)"
+    )
+    parser.add_argument(
+        "--longitude", type=float, default=-87.6298, help="Longitude (default: Chicago)"
+    )
+    parser.add_argument(
+        "--radius", type=float, default=5.0, help="Radius in miles (default: 5)"
+    )
+    parser.add_argument(
+        "--handle",
+        type=str,
+        default="alternatebuild.dev",
+        help="BlueSky handle to DM (default: alternatebuild.dev)",
+    )
+    parser.add_argument(
+        "--interval",
+        type=int,
+        default=60,
+        help="Check interval in seconds (default: 60)",
+    )
+    parser.add_argument(
+        "--once", action="store_true", help="Run once and exit (for testing)"
+    )
+    parser.add_argument(
+        "--max-workers",
+        type=int,
+        default=5,
+        help="Max concurrent workers for processing subscribers (default: 5)",
+    )
+    args = parser.parse_args()
+
+    try:
+        settings = Settings()
+    except Exception as e:
+        print(f"Error loading settings: {e}")
+        print(
+            "Ensure .env file exists with BSKY_HANDLE, BSKY_PASSWORD, and FLIGHTRADAR_API_TOKEN"
+        )
+        return
+
+    client = Client()
+    try:
+        client.login(settings.bsky_handle, settings.bsky_password)
+        print(f"Logged in to BlueSky as {settings.bsky_handle}")
+    except Exception as e:
+        print(f"Error logging into BlueSky: {e}")
+        return
+
+    if args.subscribers:
+        if args.subscribers == "-":
+            subscribers_input = None
+        else:
+            subscribers_input = args.subscribers
+
+        try:
+            subscribers = load_subscribers(subscribers_input)
+            print(f"Loaded {len(subscribers)} subscriber(s)")
+        except Exception as e:
+            print(f"Error loading subscribers: {e}")
+            return
+    else:
+        subscribers = [
+            Subscriber(
+                handle=args.handle,
+                latitude=args.latitude,
+                longitude=args.longitude,
+                radius_miles=args.radius,
+            )
+        ]
+        print(
+            f"Monitoring flights within {args.radius} miles of ({args.latitude}, {args.longitude}) for {args.handle}"
+        )
+
+    print(f"Checking every {args.interval} seconds...")
+
+    notified_flights: dict[str, set[str]] = {}
+
+    while True:
+        try:
+            with ThreadPoolExecutor(max_workers=args.max_workers) as executor:
+                futures = []
+                for subscriber in subscribers:
+                    future = executor.submit(
+                        process_subscriber,
+                        client,
+                        settings,
+                        subscriber,
+                        notified_flights,
+                    )
+                    futures.append(future)
+
+                for future in as_completed(futures):
+                    future.result()
+
+            if args.once:
+                break
+
+            time.sleep(args.interval)
+
+        except KeyboardInterrupt:
+            print("\nStopping flight monitor...")
+            break
+        except Exception as e:
+            print(f"Error in monitoring loop: {e}")
+            time.sleep(args.interval)
+
+
+if __name__ == "__main__":
+    main()

predict-github-stars

···
 Predict when a GitHub repository will reach a target number of stars.
 
 Usage:
-
-```bash
-./predict-github-stars anthropics/claude-dev 10000
-```
+    ./predict-github-stars owner/repo 10000
 
 Details:
-- uses github api to fetch star history
-- uses polynomial regression to predict future star growth
-- shows confidence intervals based on historical variance
-- requires `GITHUB_TOKEN` in environment for higher rate limits (optional)
+- Uses GitHub REST API to fetch star history (with timestamps).
+- Fits polynomial regression (degree 1–3) to full history.
+- Falls back to recent‑trend linear extrapolation if the polynomial
+  cannot reach the target within ten years.
+- Shows recent growth rate and a caution for long‑range estimates.
+- Requires `GITHUB_TOKEN` in the environment for higher rate limits (optional).
 """
+
+from __future__ import annotations
 
 import argparse
 import os
 import sys
 from datetime import datetime, timezone
-from typing import Optional
+
+import httpx
 import numpy as np
-from sklearn.preprocessing import PolynomialFeatures
+import pandas as pd
+from dateutil import parser as date_parser
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
 from sklearn.linear_model import LinearRegression
 from sklearn.metrics import r2_score
-import httpx
-from rich.console import Console
-from rich.table import Table
-from rich.panel import Panel
-from dateutil import parser as date_parser
-import pandas as pd
-from pydantic_settings import BaseSettings, SettingsConfigDict
-from pydantic import Field
+from sklearn.preprocessing import PolynomialFeatures
 
 console = Console()
 
 
 class Settings(BaseSettings):
-    """App settings loaded from environment variables"""
+    """Load settings (e.g. GitHub token) from environment."""
 
     model_config = SettingsConfigDict(
         env_file=os.environ.get("ENV_FILE", ".env"), extra="ignore"
     )
+    github_token: str = Field(default="", description="GitHub API token")
 
-    github_token: str = Field(default="")
 
+# ──────────────────────────────── GitHub helpers ────────────────────────────────
 
-GREY = "\033[90m"
-GREEN = "\033[92m"
-YELLOW = "\033[93m"
-RED = "\033[91m"
-_END = "\033[0m"
 
+def _headers(token: str | None = None) -> dict[str, str]:
+    h = {"Accept": "application/vnd.github.v3+json"}
+    if token:
+        h["Authorization"] = f"token {token}"
+    return h
 
-def get_repo_data(owner: str, repo: str, token: Optional[str] = None) -> dict:
-    """fetch basic repository data from github api"""
-    headers = {"Accept": "application/vnd.github.v3+json"}
-    if token:
-        headers["Authorization"] = f"token {token}"
 
+def get_repo_data(owner: str, repo: str, token: str | None = None) -> dict:
     url = f"https://api.github.com/repos/{owner}/{repo}"
-
-    with httpx.Client() as client:
-        response = client.get(url, headers=headers)
-        response.raise_for_status()
-        return response.json()
+    with httpx.Client() as c:
+        r = c.get(url, headers=_headers(token))
+        r.raise_for_status()
+        return r.json()
 
 
 def get_star_history(
-    owner: str, repo: str, token: Optional[str] = None, current_stars: int = 0
+    owner: str, repo: str, token: str | None, total_stars: int
 ) -> list[tuple[datetime, int]]:
-    """fetch star history using github api stargazers endpoint"""
-    headers = {
-        "Accept": "application/vnd.github.v3.star+json"  # includes starred_at timestamps
-    }
-    if token:
-        headers["Authorization"] = f"token {token}"
+    """Return (timestamp, cumulative_star_count) pairs, sampled if repo is huge."""
+    hdrs = _headers(token)
+    hdrs["Accept"] = "application/vnd.github.v3.star+json"  # need starred_at
 
-    star_history = []
+    history: list[tuple[datetime, int]] = []
 
-    # for repos with many stars, sample across the range
-    # instead of just getting the first ones
-    if current_stars > 10000:
-        # sample ~200 points across the star range for performance
+    if total_stars > 10_000:
+        # sample ~200 evenly‑spaced star indices
         sample_points = 200
-        step = max(1, current_stars // sample_points)
+        step = max(1, total_stars // sample_points)
+        pages_needed: dict[int, list[int]] = {}
+        for s in range(1, total_stars, step):
+            pg = (s - 1) // 100 + 1
+            idx = (s - 1) % 100
+            pages_needed.setdefault(pg, []).append(idx)
 
-        # batch requests with a single client
-        with httpx.Client() as client:
-            # get samples at regular intervals
-            for target_star in range(1, current_stars, step):
-                page = (target_star // 100) + 1
-                position = (target_star % 100) - 1
+        # always include final star
+        last_pg = (total_stars - 1) // 100 + 1
+        last_idx = (total_stars - 1) % 100
+        pages_needed.setdefault(last_pg, []).append(last_idx)
 
-                url = f"https://api.github.com/repos/{owner}/{repo}/stargazers?page={page}&per_page=100"
-                response = client.get(url, headers=headers)
-                response.raise_for_status()
+        with httpx.Client() as c:
+            for pg, idxs in pages_needed.items():
+                url = f"https://api.github.com/repos/{owner}/{repo}/stargazers?page={pg}&per_page=100"
+                r = c.get(url, headers=hdrs)
+                r.raise_for_status()
+                data = r.json()
+                for i in sorted(set(idxs)):
+                    if i < len(data) and "starred_at" in data[i]:
+                        ts = date_parser.parse(data[i]["starred_at"])
+                        history.append((ts, (pg - 1) * 100 + i + 1))
 
-                data = response.json()
-                if data and position < len(data) and "starred_at" in data[position]:
-                    starred_at = date_parser.parse(data[position]["starred_at"])
-                    star_history.append((starred_at, target_star))
+        console.print(f"[dim]sampled {len(history)} points across star history[/dim]")
 
-        console.print(
-            f"{GREY}sampled {len(star_history)} points across star history{_END}"
-        )
     else:
-        # for smaller repos, get all stars
+        # fetch all pages
         page = 1
-        per_page = 100
-
-        with httpx.Client() as client:
+        with httpx.Client() as c:
             while True:
-                url = f"https://api.github.com/repos/{owner}/{repo}/stargazers?page={page}&per_page={per_page}"
-                response = client.get(url, headers=headers)
-                response.raise_for_status()
-
-                data = response.json()
+                url = f"https://api.github.com/repos/{owner}/{repo}/stargazers?page={page}&per_page=100"
+                r = c.get(url, headers=hdrs)
+                r.raise_for_status()
+                data = r.json()
                 if not data:
                     break
-
                 for i, star in enumerate(data):
                     if "starred_at" in star:
-                        starred_at = date_parser.parse(star["starred_at"])
-                        cumulative_stars = (page - 1) * per_page + i + 1
-                        star_history.append((starred_at, cumulative_stars))
-
+                        ts = date_parser.parse(star["starred_at"])
+                        history.append((ts, (page - 1) * 100 + i + 1))
                 page += 1
 
-    return star_history
-
-
-def predict_star_growth(
-    star_history: list[tuple[datetime, int]], target_stars: int, current_stars: int
-) -> Optional[datetime]:
-    """use polynomial regression to predict when repo will reach target stars"""
-    if len(star_history) < 10:
-        return None
+    # ensure order and anchor today’s count
+    history.sort(key=lambda t: t[0])
+    if history and history[-1][1] < total_stars:
+        history.append((datetime.now(timezone.utc), total_stars))
+    return history
 
-    # convert to days since first star
-    first_date = star_history[0][0]
-    X = np.array(
-        [(date - first_date).total_seconds() / 86400 for date, _ in star_history]
-    ).reshape(-1, 1)
-    y = np.array([stars for _, stars in star_history])
 
-    # try different polynomial degrees and pick best fit
-    best_r2 = -float("inf")
-    best_model = None
-    best_poly = None
-    best_degree = 1
+# ──────────────────────────────── modelling ─────────────────────────────────────
 
-    for degree in range(1, 4):  # try linear, quadratic, cubic
-        poly = PolynomialFeatures(degree=degree)
-        X_poly = poly.fit_transform(X)
 
-        model = LinearRegression()
-        model.fit(X_poly, y)
+def best_poly_fit(
+    X: np.ndarray, y: np.ndarray
+) -> tuple[LinearRegression, PolynomialFeatures, int, float]:
+    best_r2 = -1.0
+    best_model: LinearRegression | None = None
+    best_poly: PolynomialFeatures | None = None
+    best_deg = 1
+    for deg in (1, 2, 3):
+        poly = PolynomialFeatures(degree=deg)
+        Xpoly = poly.fit_transform(X)
+        model = LinearRegression().fit(Xpoly, y)
+        r2 = r2_score(y, model.predict(Xpoly))
+        if r2 > best_r2:
+            best_r2, best_model, best_poly, best_deg = r2, model, poly, deg
+    return best_model, best_poly, best_deg, best_r2  # type: ignore
 
-        y_pred = model.predict(X_poly)
-        r2 = r2_score(y, y_pred)
 
-        if r2 > best_r2:
-            best_r2 = r2
-            best_model = model
-            best_poly = poly
-            best_degree = degree
-
-    console.print(
-        f"{GREY}best fit: degree {best_degree} polynomial (r² = {best_r2:.3f}){_END}"
+def predict_date(history: list[tuple[datetime, int]], target: int) -> datetime | None:
+    if len(history) < 10:
+        return None
+    origin = history[0][0]
+    X = np.array([(t - origin).total_seconds() / 86400 for t, _ in history]).reshape(
+        -1, 1
     )
+    y = np.array([s for _, s in history])
 
-    # predict future
-    # search for when we'll hit target stars
-    days_to_check = np.arange(0, 3650, 1)  # check up to 10 years
+    model, poly, deg, r2 = best_poly_fit(X, y)
+    console.print(f"[dim]best fit: degree {deg} polynomial (r² = {r2:.3f})[/dim]")
 
-    for days_ahead in days_to_check:
-        current_days = X[-1][0]
-        future_days = current_days + days_ahead
-        X_future = best_poly.transform([[future_days]])
-        predicted_stars = best_model.predict(X_future)[0]
+    current_day = X[-1, 0]
+    for d in range(0, 3650):  # up to 10 years
+        future = current_day + d
+        if model.predict(poly.transform([[future]]))[0] >= target:
+            return origin + pd.Timedelta(days=future)
+    return None
 
-        if predicted_stars >= target_stars:
-            predicted_date = first_date + pd.Timedelta(days=future_days)
-            return predicted_date
 
-    return None  # won't reach target in 10 years
+# ──────────────────────────────── utils ─────────────────────────────────────────
 
 
-def format_timeframe(date: datetime) -> str:
-    """format a future date as a human-readable timeframe"""
+def timeframe_str(dt: datetime) -> str:
     now = datetime.now(timezone.utc)
-    delta = date - now
-
-    if delta.days < 0:
+    if dt <= now:
         return "already reached"
-    elif delta.days == 0:
+    days = (dt - now).days
+    if days == 0:
         return "today"
-    elif delta.days == 1:
+    if days == 1:
         return "tomorrow"
-    elif delta.days < 7:
-        return f"in {delta.days} days"
-    elif delta.days < 30:
-        weeks = delta.days // 7
-        return f"in {weeks} week{'s' if weeks > 1 else ''}"
-    elif delta.days < 365:
-        months = delta.days // 30
-        return f"in {months} month{'s' if months > 1 else ''}"
-    else:
-        years = delta.days // 365
-        return f"in {years} year{'s' if years > 1 else ''}"
+    if days < 7:
+        return f"in {days} days"
+    if days < 30:
+        return f"in {days // 7} week(s)"
+    if days < 365:
+        return f"in {days // 30} month(s)"
+    return f"in {days // 365} year(s)"
 
 
-def main():
-    parser = argparse.ArgumentParser(
-        description="predict when a github repository will reach a target number of stars"
-    )
-    parser.add_argument("repo", help="repository in format owner/repo")
-    parser.add_argument("stars", type=int, help="target number of stars")
+# ──────────────────────────────── main ──────────────────────────────────────────
 
-    args = parser.parse_args()
 
-    try:
-        settings = Settings()  # type: ignore
-    except Exception as e:
-        console.print(f"{RED}error loading settings: {e}{_END}")
-        sys.exit(1)
+def main() -> None:
+    p = argparse.ArgumentParser(
+        description="Predict when a GitHub repo will reach a target number of stars"
+    )
+    p.add_argument("repo", help="owner/repo")
+    p.add_argument("stars", type=int, help="target star count")
+    args = p.parse_args()
 
-    token = settings.github_token
+    if "/" not in args.repo:
+        console.print("[red]error: repo must be owner/repo[/red]")
+        sys.exit(1)
+    owner, repo = args.repo.split("/", 1)
 
     try:
-        owner, repo = args.repo.split("/")
-    except ValueError:
-        console.print(f"{RED}error: repository must be in format owner/repo{_END}")
+        settings = Settings()  # load token
+    except Exception as e:  # pragma: no cover
+        console.print(f"[red]error loading settings: {e}[/red]")
         sys.exit(1)
+    token = settings.github_token.strip() or None
 
-    # fetch current repo data
     try:
         repo_data = get_repo_data(owner, repo, token)
         current_stars = repo_data["stargazers_count"]
···
 
         console.print(
             Panel.fit(
-                f"[bold cyan]{args.repo}[/bold cyan]\n"
-                f"[dim]current stars: {current_stars:,}\n"
-                f"created: {created_at.strftime('%Y-%m-%d')}[/dim]",
+                f"[bold cyan]{owner}/{repo}[/bold cyan]\n"
+                f"[dim]current stars: {current_stars:,}\ncreated: {created_at:%Y-%m-%d}[/dim]",
                 border_style="blue",
             )
         )
 
         if current_stars >= args.stars:
-            console.print(f"\n{GREEN}✓ already has {current_stars:,} stars!{_END}")
+            console.print("\n[green]✓ already at or above target![/green]")
             sys.exit(0)
 
-        console.print("\nfetching star history...")
-        star_history = get_star_history(owner, repo, token, current_stars)
-
-        if not star_history:
-            console.print(f"{RED}error: no star history available{_END}")
+        console.print("\nfetching star history…")
+        history = get_star_history(owner, repo, token, current_stars)
+        if not history:
+            console.print("[red]error: no star history[/red]")
             sys.exit(1)
-
-        # sample the history if too large
-        if len(star_history) > 1000:
-            # take every nth star to get ~1000 data points
-            n = len(star_history) // 1000
-            star_history = star_history[::n]
-
-        console.print(f"{GREY}analyzing {len(star_history)} data points...{_END}")
-
-        predicted_date = predict_star_growth(star_history, args.stars, current_stars)
-
-        if predicted_date:
-            timeframe = format_timeframe(predicted_date)
-
-            # create results table
-            table = Table(show_header=True, header_style="bold magenta")
-            table.add_column("metric", style="cyan")
-            table.add_column("value", style="white")
+        if len(history) > 1000:  # down‑sample for speed
+            step = len(history) // 1000
+            history = history[::step] + [history[-1]]
 
-            table.add_row("target stars", f"{args.stars:,}")
-            table.add_row("current stars", f"{current_stars:,}")
-            table.add_row("stars needed", f"{args.stars - current_stars:,}")
-            table.add_row("predicted date", predicted_date.strftime("%Y-%m-%d"))
-            table.add_row("timeframe", timeframe)
+        console.print(f"[dim]analysing {len(history)} data points…[/dim]")
+        poly_date = predict_date(history, args.stars)
 
-            # calculate current growth rate
-            if len(star_history) > 1:
-                recent_days = 30
-                recent_date = datetime.now(timezone.utc) - pd.Timedelta(
-                    days=recent_days
-                )
-                recent_stars = [s for d, s in star_history if d >= recent_date]
-                if len(recent_stars) > 1:
-                    daily_rate = (recent_stars[-1] - recent_stars[0]) / recent_days
-                    table.add_row("recent growth", f"{daily_rate:.1f} stars/day")
+        def recent_rate(window: int = 30) -> float:
+            cutoff = datetime.now(timezone.utc) - pd.Timedelta(days=window)
+            pts = [s for t, s in history if t >= cutoff]
+            return (pts[-1] - pts[0]) / window if len(pts) >= 2 else 0.0
 
-            console.print("\n")
-            console.print(table)
+        rate = recent_rate() or recent_rate(90)
 
-            if "year" in timeframe and "1 year" not in timeframe:
-                console.print(
-                    f"\n{YELLOW}⚠ prediction is far in the future and may be unreliable{_END}"
-                )
+        if poly_date:
+            out_date, tf = poly_date, timeframe_str(poly_date)
+        elif rate > 0:
+            days_needed = (args.stars - current_stars) / rate
+            out_date = datetime.now(timezone.utc) + pd.Timedelta(days=days_needed)
+            tf = timeframe_str(out_date)
+            console.print(
+                "[dim]poly model pessimistic; using recent growth trend[/dim]"
+            )
         else:
             console.print(
-                f"\n{RED}✗ unlikely to reach {args.stars:,} stars in the next 10 years{_END}"
+                f"[red]✗ unlikely to reach {args.stars:,} stars in the next 10 years[/red]"
             )
+            sys.exit(0)
+
+        table = Table(show_header=True, header_style="bold magenta")
+        table.add_column("metric")
+        table.add_column("value", style="white")
+        table.add_row("target stars", f"{args.stars:,}")
+        table.add_row("current stars", f"{current_stars:,}")
+        table.add_row("stars needed", f"{args.stars - current_stars:,}")
+        table.add_row("predicted date", out_date.strftime("%Y-%m-%d"))
+        table.add_row("timeframe", tf)
+        if rate:
+            table.add_row("recent growth", f"{rate:.1f} stars/day")
+
+        console.print()
+        console.print(table)
+        if "year" in tf and "1 year" not in tf:
+            console.print("\n[dim]⚠ prediction far in future; uncertainty high[/dim]")
 
     except httpx.HTTPStatusError as e:
         if e.response.status_code == 404:
-            console.print(f"{RED}error: repository {args.repo} not found{_END}")
+            msg = "repository not found"
         elif e.response.status_code == 403:
-            console.print(
-                f"{RED}error: rate limit exceeded. set GITHUB_TOKEN environment variable{_END}"
-            )
+            msg = "rate limit exceeded (set GITHUB_TOKEN)"
         else:
-            console.print(
-                f"{RED}error: github api error {e.response.status_code}{_END}"
-            )
+            msg = f"GitHub API error {e.response.status_code}"
+        console.print(f"[red]error: {msg}[/red]")
         sys.exit(1)
-    except Exception as e:
-        console.print(f"{RED}error: {e}{_END}")
+    except Exception as e:  # pragma: no cover
+        console.print(f"[red]error: {e}[/red]")
         sys.exit(1)