linkgnome 0.0.3__py3-none-any.whl

linkgnome/__init__.py

@@ -0,0 +1,3 @@
+"""LinkGnome - Terminal-based link aggregator for social feeds."""
+
+__version__ = "0.0.3"

linkgnome/cache.py

@@ -0,0 +1,57 @@
+"""Caching layer for fetched feed data."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from diskcache import Cache
+
+
+class FeedCache:
+    """Cache for feed data."""
+
+    def __init__(self, cache_dir: Path | None = None, ttl_seconds: int = 600):
+        self.cache_dir = cache_dir or Path.home() / ".cache" / "linkgnome"
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+        self.ttl_seconds = ttl_seconds
+        self._cache = Cache(str(self.cache_dir))
+
+    def get_feed(
+        self, platform: str, timeline_type: str
+    ) -> list[dict[str, Any]] | None:
+        """Get cached feed data if it hasn't expired."""
+        cache_key = f"{platform}:{timeline_type}"
+        cached = self._cache.get(cache_key)
+        if cached is None:
+            return None
+
+        data, timestamp = cached
+        if datetime.now().timestamp() - timestamp > self.ttl_seconds:
+            self._cache.delete(cache_key)
+            return None
+
+        return data
+
+    def set_feed(
+        self,
+        platform: str,
+        timeline_type: str,
+        posts: list[dict[str, Any]],
+    ) -> None:
+        """Cache feed data."""
+        cache_key = f"{platform}:{timeline_type}"
+        self._cache.set(
+            cache_key,
+            (posts, datetime.now().timestamp()),
+            expire=self.ttl_seconds,
+        )
+
+    def clear(self) -> None:
+        """Clear all cached data."""
+        self._cache.clear()
+
+    def close(self) -> None:
+        """Close the cache."""
+        self._cache.close()

linkgnome/cli.py

@@ -0,0 +1,124 @@
+"""CLI entry point for LinkGnome."""
+
+from __future__ import annotations
+
+import click
+from rich.console import Console
+
+from linkgnome.cache import FeedCache
+from linkgnome.config import ConfigManager
+from linkgnome.db import LinkgnomeDB
+from linkgnome.setup import run_setup
+from linkgnome.tui import run_tui
+
+console = Console()
+
+
+@click.group()
+@click.pass_context
+def main(ctx: click.Context) -> None:
+    """LinkGnome - Terminal-based link aggregator for social feeds."""
+    ctx.ensure_object(dict)
+    ctx.obj["config_manager"] = ConfigManager()
+
+
+@main.command()
+@click.pass_context
+def setup(ctx: click.Context) -> None:
+    """Walk through interactive configuration."""
+    config_manager = ctx.obj["config_manager"]
+    run_setup(config_manager)
+
+
+@main.command()
+@click.option("--period", type=str, default=None, help="Time period (e.g., 24h, 7d)")
+@click.option("--page", type=int, default=1, help="Page number (10 items per page)")
+@click.option(
+    "--limit", type=int, default=None, help="Number of links per page (default: 10)"
+)
+@click.option(
+    "--platform",
+    type=click.Choice(["mastodon", "bluesky"]),
+    default=None,
+    help="Filter by platform",
+)
+@click.pass_context
+def fetch(
+    ctx: click.Context, period: str | None, page: int, limit: int | None, platform: str | None
+) -> None:
+    """Fetch and display ranked links from your feeds."""
+    config_manager = ctx.obj["config_manager"]
+    settings = config_manager.get()
+
+    if not settings.mastodon.enabled and not settings.bluesky.enabled:
+        console.print(
+            "[bold yellow]No platforms configured. Run 'linkgnome setup' first.[/bold yellow]"
+        )
+        raise click.Abort()
+
+    hours = _parse_period(period) if period else settings.period_hours
+    page_size = limit or 10
+    run_tui(settings, hours=hours, page=page, page_size=page_size, platform_filter=platform)
+
+
+@main.command()
+@click.pass_context
+def config(ctx: click.Context) -> None:
+    """Show current configuration."""
+    config_manager = ctx.obj["config_manager"]
+    settings = config_manager.get()
+
+    console.print("[bold]LinkGnome Configuration[/bold]\n")
+
+    console.print("[bold]Mastodon:[/bold]")
+    if settings.mastodon.enabled:
+        console.print(f"  Instance: {settings.mastodon.instance_url}")
+        console.print("  Status: [green]Configured[/green]")
+    else:
+        console.print("  Status: [red]Not configured[/red]")
+
+    console.print("\n[bold]Bluesky:[/bold]")
+    if settings.bluesky.enabled:
+        console.print(f"  Handle: {settings.bluesky.handle}")
+        console.print("  Status: [green]Configured[/green]")
+    else:
+        console.print("  Status: [red]Not configured[/red]")
+
+    console.print("\n[bold]Settings:[/bold]")
+    console.print(f"  Period: {settings.period_hours} hours")
+    console.print(f"  Page size: {settings.page_size} items")
+
+
+@main.command()
+@click.pass_context
+def clear_cache(ctx: click.Context) -> None:
+    """Clear all cached data."""
+    console = Console()
+    
+    # Clear FeedCache
+    feed_cache = FeedCache()
+    feed_cache.clear()
+    feed_cache.close()
+    
+    # Clear database old posts
+    db = LinkgnomeDB()
+    deleted_count = db.clear_old_posts(0)  # Clear all posts
+    db.close()
+    
+    console.print("[green]Cache cleared successfully![/green]")
+    console.print(f"[yellow]Removed {deleted_count} old posts from database[/yellow]")
+
+
+def _parse_period(period_str: str) -> int:
+    """Parse period string like '24h' or '7d' into hours."""
+    period_str = period_str.strip().lower()
+    if period_str.endswith("h"):
+        return int(period_str[:-1])
+    elif period_str.endswith("d"):
+        return int(period_str[:-1]) * 24
+    else:
+        return int(period_str)
+
+
+if __name__ == "__main__":
+    main()

linkgnome/config.py

@@ -0,0 +1,169 @@
+"""Configuration management for LinkGnome."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel, Field
+from pydantic_settings import (
+    BaseSettings,
+    PydanticBaseSettingsSource,
+    SettingsConfigDict,
+    TomlConfigSettingsSource,
+)
+
+DEFAULT_CONFIG_DIR = Path.home() / ".config" / "linkgnome"
+DEFAULT_CONFIG_FILE = DEFAULT_CONFIG_DIR / "config.toml"
+DEFAULT_PERIOD_HOURS = 24
+DEFAULT_PAGE_SIZE = 42
+
+
+class MastodonConfig(BaseModel):
+    """Mastodon configuration."""
+
+    enabled: bool = False
+    instance_url: str = ""
+    client_id: str = ""
+    client_secret: str = ""
+    access_token: str = ""
+
+
+class BlueskyConfig(BaseModel):
+    """Bluesky configuration."""
+
+    enabled: bool = False
+    handle: str = ""
+    app_password: str = ""
+
+
+class LinkgnomeSettings(BaseSettings):
+    """Main settings for LinkGnome."""
+
+    model_config = SettingsConfigDict(
+        env_prefix="LINKGNOME_",
+        env_file=".env",
+    )
+
+    mastodon: MastodonConfig = Field(default_factory=MastodonConfig)
+    bluesky: BlueskyConfig = Field(default_factory=BlueskyConfig)
+    period_hours: int = DEFAULT_PERIOD_HOURS
+    page_size: int = DEFAULT_PAGE_SIZE
+    cache_ttl_seconds: int = 600
+
+    @classmethod
+    def settings_customise_sources(
+        cls,
+        settings_cls: type[BaseSettings],
+        init_settings: PydanticBaseSettingsSource,
+        env_settings: PydanticBaseSettingsSource,
+        dotenv_settings: PydanticBaseSettingsSource,
+        file_secret_settings: PydanticBaseSettingsSource,
+    ) -> tuple[PydanticBaseSettingsSource, ...]:
+        return (
+            init_settings,
+            file_secret_settings,
+            env_settings,
+            dotenv_settings,
+        )
+
+
+class ConfigManager:
+    """Manages loading and saving configuration."""
+
+    def __init__(self, config_path: Path | None = None):
+        self.config_path = config_path or DEFAULT_CONFIG_FILE
+        self._settings: LinkgnomeSettings | None = None
+
+    def load(self) -> LinkgnomeSettings:
+        """Load settings from config file."""
+        if self._settings is not None:
+            return self._settings
+
+        self.config_path.parent.mkdir(parents=True, exist_ok=True)
+
+        if not self.config_path.exists():
+            self._settings = LinkgnomeSettings()
+            return self._settings
+
+        class TomlSettings(LinkgnomeSettings):
+            model_config = SettingsConfigDict(
+                env_prefix="LINKGNOME_",
+                env_file=".env",
+            )
+
+            @classmethod
+            def settings_customise_sources(
+                cls,
+                settings_cls: type[BaseSettings],
+                init_settings: PydanticBaseSettingsSource,
+                env_settings: PydanticBaseSettingsSource,
+                dotenv_settings: PydanticBaseSettingsSource,
+                file_secret_settings: PydanticBaseSettingsSource,
+            ) -> tuple[PydanticBaseSettingsSource, ...]:
+                return (
+                    TomlConfigSettingsSource(settings_cls, cls.config_path),
+                    env_settings,
+                    dotenv_settings,
+                )
+
+            @property
+            def config_path(self) -> Path:
+                return Path(_get_toml_path())
+
+        try:
+            toml_data = _parse_toml_file(self.config_path)
+            self._settings = LinkgnomeSettings(**toml_data)
+        except Exception:
+            self._settings = LinkgnomeSettings()
+
+        return self._settings
+
+    def save(self, settings: LinkgnomeSettings) -> None:
+        """Save settings to config file."""
+        self.config_path.parent.mkdir(parents=True, exist_ok=True)
+        data = settings.model_dump(mode="json")
+        toml_content = _dict_to_toml(data)
+        self.config_path.write_text(toml_content)
+        self._settings = settings
+
+    def get(self) -> LinkgnomeSettings:
+        """Get current settings, loading if necessary."""
+        if self._settings is None:
+            self.load()
+        return self._settings
+
+
+def _get_toml_path() -> str:
+    return str(DEFAULT_CONFIG_FILE)
+
+
+def _parse_toml_file(path: Path) -> dict[str, Any]:
+    """Parse a TOML file manually (minimal implementation)."""
+    import tomllib
+
+    with open(path, "rb") as f:
+        return tomllib.load(f)
+
+
+def _dict_to_toml(data: dict[str, Any], indent: int = 0) -> str:
+    """Convert a dict to TOML string."""
+    lines = []
+    prefix = "    " * indent
+
+    for key, value in data.items():
+        if isinstance(value, dict):
+            lines.append(f"{prefix}[{key}]")
+            lines.append(_dict_to_toml(value, indent))
+            lines.append("")
+        elif isinstance(value, bool):
+            lines.append(f"{prefix}{key} = {str(value).lower()}")
+        elif isinstance(value, int):
+            lines.append(f"{prefix}{key} = {value}")
+        elif isinstance(value, str):
+            escaped = value.replace('"', '\\"')
+            lines.append(f'{prefix}{key} = "{escaped}"')
+        else:
+            lines.append(f"{prefix}{key} = {value!r}")
+
+    return "\n".join(lines)

linkgnome/db.py

@@ -0,0 +1,278 @@
+"""SQLite database layer for LinkGnome."""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any
+
+from linkgnome.fetchers.base import Platform, Post
+
+DB_DIR = Path.home() / ".local" / "share" / "linkgnome"
+DB_PATH = DB_DIR / "linkgnome.db"
+
+SCHEMA = """
+CREATE TABLE IF NOT EXISTS posts (
+    id TEXT PRIMARY KEY,
+    platform TEXT NOT NULL,
+    author TEXT NOT NULL,
+    author_display_name TEXT,
+    content TEXT,
+    created_at TEXT NOT NULL,
+    is_boost INTEGER DEFAULT 0,
+    original_post_id TEXT,
+    boosted_by TEXT,
+    boost_count INTEGER DEFAULT 0,
+    like_count INTEGER DEFAULT 0,
+    raw_data TEXT
+);
+
+CREATE TABLE IF NOT EXISTS post_urls (
+    post_id TEXT NOT NULL,
+    url TEXT NOT NULL,
+    PRIMARY KEY (post_id, url),
+    FOREIGN KEY (post_id) REFERENCES posts(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS url_metadata (
+    url TEXT PRIMARY KEY,
+    title TEXT,
+    status_code INTEGER,
+    fetched_at TEXT,
+    final_url TEXT
+);
+
+CREATE TABLE IF NOT EXISTS profiles (
+    platform TEXT NOT NULL,
+    handle TEXT NOT NULL,
+    display_name TEXT,
+    bio TEXT,
+    avatar_url TEXT,
+    last_updated TEXT,
+    PRIMARY KEY (platform, handle)
+);
+
+CREATE INDEX IF NOT EXISTS idx_posts_created ON posts(created_at);
+CREATE INDEX IF NOT EXISTS idx_posts_platform ON posts(platform);
+CREATE INDEX IF NOT EXISTS idx_post_urls_post ON post_urls(post_id);
+CREATE INDEX IF NOT EXISTS idx_post_urls_url ON post_urls(url);
+"""
+
+
+class LinkgnomeDB:
+    """SQLite-backed storage for posts, URLs, metadata, and profiles."""
+
+    def __init__(self, db_path: Path | None = None):
+        self.db_path = db_path or DB_PATH
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        self._conn: sqlite3.Connection | None = None
+
+    @property
+    def conn(self) -> sqlite3.Connection:
+        if self._conn is None:
+            self._conn = sqlite3.connect(str(self.db_path))
+            self._conn.row_factory = sqlite3.Row
+            self._conn.execute("PRAGMA journal_mode=WAL")
+            self._conn.execute("PRAGMA foreign_keys=ON")
+            self._conn.executescript(SCHEMA)
+            self._conn.commit()
+        return self._conn
+
+    def save_posts(self, posts: list[Post]) -> int:
+        """Batch insert posts. Returns count of new posts added."""
+        conn = self.conn
+        rows_added = 0
+        for post in posts:
+            existing = conn.execute(
+                "SELECT id FROM posts WHERE id = ?", (post.id,)
+            ).fetchone()
+            if existing:
+                continue
+
+            conn.execute(
+                """INSERT INTO posts
+                   (id, platform, author, author_display_name, content,
+                    created_at, is_boost, original_post_id, boosted_by,
+                    boost_count, like_count, raw_data)
+                   VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+                (
+                    post.id,
+                    post.platform.value,
+                    post.author,
+                    post.author_display_name,
+                    post.content,
+                    post.created_at.isoformat(),
+                    int(post.is_boost),
+                    post.original_post_id,
+                    post.boosted_by,
+                    post.boost_count,
+                    post.like_count,
+                    json.dumps(post.raw_data) if post.raw_data else None,
+                ),
+            )
+
+            for url in post.urls:
+                # Normalize URLs to prevent truncation issues
+                # Remove trailing ellipsis that might be present in Bluesky truncated URLs
+                normalized_url = url.rstrip('...')
+                conn.execute(
+                    "INSERT OR IGNORE INTO post_urls (post_id, url) VALUES (?, ?)",
+                    (post.id, normalized_url),
+                )
+
+            rows_added += 1
+
+        conn.commit()
+        return rows_added
+
+    def load_posts(
+        self,
+        platform: str | None = None,
+        since: datetime | None = None,
+        limit: int | None = None,
+    ) -> list[Post]:
+        """Load posts with their URLs."""
+        query = """
+            SELECT p.*, GROUP_CONCAT(DISTINCT pu.url) as urls
+            FROM posts p
+            LEFT JOIN post_urls pu ON p.id = pu.post_id
+        """
+        params: list[Any] = []
+        where_clauses = []
+
+        if platform:
+            where_clauses.append("p.platform = ?")
+            params.append(platform)
+        if since:
+            where_clauses.append("p.created_at >= ?")
+            params.append(since.isoformat())
+
+        if where_clauses:
+            query += " WHERE " + " AND ".join(where_clauses)
+
+        query += " GROUP BY p.id"
+
+        if limit:
+            query += " LIMIT ?"
+            params.append(limit)
+
+        rows = self.conn.execute(query, params).fetchall()
+        posts = []
+        for row in rows:
+            urls_str = row["urls"]
+            # Handle case where URL might contain commas or be malformed
+            if urls_str:
+                # Split by comma but be careful about URLs that might contain commas
+                urls = [url.strip() for url in urls_str.split(',')]
+            else:
+                urls = []
+            # Clean up any truncated URLs that may have been saved
+            cleaned_urls = [url.rstrip('...') for url in urls]
+            posts.append(
+                Post(
+                    id=row["id"],
+                    platform=Platform(row["platform"]),
+                    author=row["author"],
+                    author_display_name=row["author_display_name"] or "",
+                    content=row["content"] or "",
+                    urls=cleaned_urls,
+                    created_at=datetime.fromisoformat(row["created_at"]),
+                    is_boost=bool(row["is_boost"]),
+                    original_post_id=row["original_post_id"],
+                    boosted_by=row["boosted_by"],
+                    boost_count=row["boost_count"],
+                    like_count=row["like_count"],
+                    raw_data=json.loads(row["raw_data"]) if row["raw_data"] else None,
+                )
+            )
+        return posts
+
+    def count_posts(self, since: datetime | None = None) -> int:
+        """Count posts matching criteria."""
+        query = "SELECT COUNT(*) as cnt FROM posts"
+        params: list[Any] = []
+        if since:
+            query += " WHERE created_at >= ?"
+            params.append(since.isoformat())
+        row = self.conn.execute(query, params).fetchone()
+        return row["cnt"] if row else 0
+
+    def clear_old_posts(self, keep_hours: int = 24) -> int:
+        """Remove posts older than the specified window. Returns count deleted."""
+        cutoff = (
+            datetime.now(timezone.utc) - timedelta(hours=keep_hours)
+        ).isoformat()
+        cursor = self.conn.execute(
+            "DELETE FROM posts WHERE created_at < ?", (cutoff,)
+        )
+        self.conn.execute(
+            "DELETE FROM post_urls WHERE post_id NOT IN (SELECT id FROM posts)"
+        )
+        self.conn.commit()
+        return cursor.rowcount
+
+    def save_url_metadata(
+        self,
+        url: str,
+        title: str | None,
+        status_code: int,
+        final_url: str | None = None,
+    ) -> None:
+        """Cache fetched metadata for a URL."""
+        now = datetime.now(timezone.utc).isoformat()
+        self.conn.execute(
+            """INSERT OR REPLACE INTO url_metadata
+               (url, title, status_code, fetched_at, final_url)
+               VALUES (?, ?, ?, ?, ?)""",
+            (url, title, status_code, now, final_url),
+        )
+        self.conn.commit()
+
+    def get_url_metadata(self, url: str) -> dict[str, Any] | None:
+        """Get cached metadata for a URL."""
+        row = self.conn.execute(
+            "SELECT * FROM url_metadata WHERE url = ?", (url,)
+        ).fetchone()
+        if row is None:
+            return None
+        return {
+            "title": row["title"],
+            "status_code": row["status_code"],
+            "fetched_at": row["fetched_at"],
+            "final_url": row["final_url"],
+        }
+
+    def save_profile(
+        self,
+        platform: str,
+        handle: str,
+        display_name: str | None = None,
+        bio: str | None = None,
+        avatar_url: str | None = None,
+    ) -> None:
+        """Save or update a profile."""
+        now = datetime.now(timezone.utc).isoformat()
+        self.conn.execute(
+            """INSERT OR REPLACE INTO profiles
+               (platform, handle, display_name, bio, avatar_url, last_updated)
+               VALUES (?, ?, ?, ?, ?, ?)""",
+            (platform, handle, display_name, bio, avatar_url, now),
+        )
+        self.conn.commit()
+
+    def get_profile(self, platform: str, handle: str) -> dict[str, Any] | None:
+        """Get profile data."""
+        row = self.conn.execute(
+            "SELECT * FROM profiles WHERE platform = ? AND handle = ?",
+            (platform, handle),
+        ).fetchone()
+        if row is None:
+            return None
+        return dict(row)
+
+    def close(self) -> None:
+        if self._conn:
+            self._conn.close()
+            self._conn = None