nostr-dev 1.0.0__py3-none-any.whl

nostr_dev/__init__.py

@@ -0,0 +1,3 @@
+"""Developer tooling for Nostr workflows."""
+
+__version__ = "1.0.0"

nostr_dev/cli.py

@@ -0,0 +1,62 @@
+"""Command-line interface for nostr-dev."""
+
+import typer
+
+from nostr_dev import __version__
+from nostr_dev.commands.common import handle_command_errors, set_debug_enabled
+from nostr_dev.commands.events import events
+from nostr_dev.commands.github import github_app
+from nostr_dev.commands.keys import import_command, keygen, whoami
+from nostr_dev.commands.publish import publish
+from nostr_dev.commands.relay import relay_app
+from nostr_dev.logging import setup_logging
+
+app = typer.Typer(
+    add_completion=False,
+    help="Developer tooling for Nostr workflows.",
+    no_args_is_help=True,
+    pretty_exceptions_show_locals=False,
+)
+
+
+def version_callback(value: bool) -> None:
+    """Print the application version and exit."""
+    if value:
+        typer.echo(f"nostr-dev {__version__}")
+        raise typer.Exit
+
+
+@app.callback()
+@handle_command_errors
+def main(
+    version: bool = typer.Option(
+        False,
+        "--version",
+        callback=version_callback,
+        help="Show the application version and exit.",
+        is_eager=True,
+    ),
+    verbose: bool = typer.Option(
+        False,
+        "--verbose",
+        "-v",
+        help="Show more detailed progress output.",
+    ),
+    debug: bool = typer.Option(
+        False,
+        "--debug",
+        help="Show debug logs and full tracebacks for unexpected errors.",
+    ),
+) -> None:
+    """Developer tooling for Nostr workflows."""
+    set_debug_enabled(debug)
+    setup_logging(verbose=verbose, debug=debug)
+
+
+app.command("keygen")(keygen)
+app.command("import")(import_command)
+app.command("whoami")(whoami)
+app.command("publish")(publish)
+app.command("events")(events)
+app.add_typer(relay_app, name="relay")
+app.add_typer(github_app, name="github")

nostr_dev/commands/__init__.py

@@ -0,0 +1 @@
+"""CLI command modules."""

nostr_dev/commands/common.py

@@ -0,0 +1,80 @@
+"""Shared CLI command helpers."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterator
+from contextlib import contextmanager
+from functools import wraps
+
+import structlog
+import typer
+from rich.console import Console
+from sqlalchemy.exc import SQLAlchemyError
+from sqlmodel import Session, SQLModel
+
+from nostr_dev.config import load_config
+from nostr_dev.db import create_db_engine, get_session
+from nostr_dev.exceptions import ConfigError, NostrDevError
+
+console = Console()
+err_console = Console(stderr=True)
+debug_enabled = False
+
+
+def set_debug_enabled(value: bool) -> None:
+    """Set whether unexpected command exceptions should be re-raised."""
+    global debug_enabled
+    debug_enabled = value
+
+
+def handle_command_errors[**P, R](command: Callable[P, R]) -> Callable[P, R]:
+    """Print clean CLI errors for expected failures and short errors otherwise."""
+
+    @wraps(command)
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        try:
+            return command(*args, **kwargs)
+        except NostrDevError as exc:
+            err_console.print(str(exc), style="red")
+            raise typer.Exit(1) from exc
+        except typer.Exit:
+            raise
+        except Exception as exc:
+            structlog.get_logger(__name__).exception("unexpected_cli_error")
+            if debug_enabled:
+                raise
+            err_console.print(
+                f"Unexpected error: {exc}. Run with --debug for full traceback.",
+                style="red",
+            )
+            raise typer.Exit(1) from exc
+
+    return wrapper
+
+
+@contextmanager
+def managed_session() -> Iterator[Session]:
+    """Yield a command session after ensuring the local database exists."""
+    ensure_database()
+    try:
+        with get_session() as session:
+            yield session
+    except SQLAlchemyError as exc:
+        raise ConfigError("Database operation failed.") from exc
+
+
+def ensure_database() -> None:
+    """Ensure database tables exist for command execution."""
+    try:
+        config = load_config()
+        engine = create_db_engine(config)
+        try:
+            SQLModel.metadata.create_all(engine)
+        finally:
+            engine.dispose()
+    except NostrDevError:
+        raise
+    except SQLAlchemyError as exc:
+        raise ConfigError("Database setup failed.") from exc
+    except OSError as exc:
+        raise ConfigError("Could not prepare nostr-dev data directory.") from exc

nostr_dev/commands/events.py

@@ -0,0 +1,86 @@
+"""Query Nostr events."""
+
+from __future__ import annotations
+
+import asyncio
+from datetime import UTC, datetime
+
+import typer
+from nostr_sdk import Event, Filter
+from rich.console import Console
+from rich.table import Table
+from sqlmodel import Session, col, select
+
+from nostr_dev.commands.common import handle_command_errors, managed_session
+from nostr_dev.exceptions import ConfigError
+from nostr_dev.models import Relay
+from nostr_dev.services.nostr import NostrEventSummary, build_subscription_filter, summarize_event
+from nostr_dev.services.relay import RelayPool
+
+console = Console()
+_managed_session = managed_session
+
+
+@handle_command_errors
+def events(
+    author: str | None = typer.Option(None, "--author", help="Filter by author npub."),
+    limit: int = typer.Option(20, "--limit", min=1, help="Maximum number of events to show."),
+    kind: int | None = typer.Option(None, "--kind", min=0, help="Filter by event kind."),
+    timeout_seconds: float = typer.Option(
+        8.0,
+        "--timeout",
+        min=0.1,
+        help="Subscription timeout in seconds.",
+    ),
+) -> None:
+    """Query active relays for Nostr events."""
+    with _managed_session() as session:
+        relay_urls = _active_relay_urls(session)
+    if not relay_urls:
+        raise ConfigError("No active relays found. Run `nostr-dev relay add <url>`.")
+
+    subscription_filter = build_subscription_filter(author=author, kind=kind, limit=limit)
+    sdk_events = asyncio.run(_subscribe_events(subscription_filter, relay_urls, timeout_seconds))
+    summaries = [summarize_event(event) for event in sdk_events[:limit]]
+    _print_events(summaries)
+
+
+async def _subscribe_events(
+    subscription_filter: Filter,
+    relay_urls: list[str],
+    timeout_seconds: float,
+) -> list[Event]:
+    pool = RelayPool(relay_urls)
+    return await pool.subscribe(subscription_filter, relay_urls, timeout_seconds)
+
+
+def _print_events(event_summaries: list[NostrEventSummary]) -> None:
+    table = Table(title="Nostr Events")
+    table.add_column("Author", style="cyan")
+    table.add_column("Kind")
+    table.add_column("Created")
+    table.add_column("Content")
+    for event in event_summaries:
+        table.add_row(
+            event.author,
+            str(event.kind),
+            _format_timestamp(event.created_at),
+            _preview(event.content),
+        )
+    console.print(table)
+
+
+def _preview(content: str, max_length: int = 80) -> str:
+    normalized = " ".join(content.split())
+    if len(normalized) <= max_length:
+        return normalized
+    return f"{normalized[: max_length - 1]}..."
+
+
+def _format_timestamp(timestamp: int) -> str:
+    return datetime.fromtimestamp(timestamp, tz=UTC).isoformat(timespec="seconds")
+
+
+def _active_relay_urls(session: Session) -> list[str]:
+    statement = select(Relay).where(Relay.is_active).order_by(col(Relay.url).asc())
+    return [relay.url for relay in session.exec(statement).all()]