skyintel 1.0.0__py3-none-any.whl

skyintel/__init__.py

@@ -0,0 +1 @@
+"""Open Sky Intelligence — real-time flight, military aircraft, and satellite tracking."""

skyintel/cli.py

@@ -0,0 +1,313 @@
+import typer
+from rich.console import Console
+from rich.table import Table
+
+app = typer.Typer(
+    name="skyintel",
+    help="Open Sky Intelligence — real-time flight, military aircraft, and satellite tracking.",
+    no_args_is_help=True,
+)
+console = Console()
+
+
+@app.command()
+def status():
+    """Show OpenSkyAI configuration and system status."""
+    from skyintel.config import get_settings
+
+    settings = get_settings()
+
+    table = Table(title="OpenSkyAI Status", show_header=False, border_style="dim")
+    table.add_column("Key", style="bold cyan")
+    table.add_column("Value")
+
+    table.add_row("Host", settings.host)
+    table.add_row("Port", str(settings.port))
+    table.add_row("Database", str(settings.db_path))
+    table.add_row("DB exists", "✓" if settings.db_path.exists() else "✗")
+    table.add_row("OpenSky OAuth2", "✓ configured" if settings.opensky_configured else "✗ not set")
+    table.add_row("Flight poll", f"{settings.flight_poll_interval}s")
+    table.add_row("Satellite poll", f"{settings.satellite_poll_interval}s")
+    table.add_row("LLM", f"{settings.llm_provider} / {settings.llm_model}" if settings.llm_configured else "✗ not set")
+
+    console.print()
+    console.print(table)
+    console.print()
+
+
+@app.command()
+def serve(
+    host: str = typer.Option(None, help="Bind host (overrides .env)"),
+    port: int = typer.Option(None, help="Bind port (overrides .env)"),
+    stdio: bool = typer.Option(False, "--stdio", help="Run as MCP stdio server for Claude Desktop / VS Code"),
+):
+    """Start the OpenSkyAI server (MCP + REST + Web UI)."""
+    import uvicorn
+    import logging
+    from skyintel.config import get_settings
+
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s %(name)s %(levelname)s %(message)s")
+
+    if stdio:
+        from skyintel.mcp_tools import mcp
+        mcp.run(transport="stdio")
+        return
+
+
+    settings = get_settings()
+    bind_host = host or settings.host
+    bind_port = port or settings.port
+
+    console.print(f"[bold green]🔭 OpenSkyAI[/] starting at [bold]http://{bind_host}:{bind_port}[/]")
+    #uvicorn.run("osai.server:app", host=bind_host, port=bind_port, log_level="info")
+    uvicorn.run("skyintel.server:app", host=bind_host, port=bind_port, log_level="info")
+
+
+
+@app.command()
+def init():
+    """Initialise the database (creates ~/.osai/osai.db)."""
+    import asyncio
+    from skyintel.config import get_settings
+    from skyintel.storage.database import get_db, close_db
+    from skyintel.storage.migrations import run_migrations
+
+    async def _init():
+        settings = get_settings()
+        db = await get_db(settings.db_path)
+        await run_migrations(db)
+        await close_db()
+        console.print(f"[green]✓[/] Database initialised at [bold]{settings.db_path}[/]")
+
+    asyncio.run(_init())
+
+
+@app.command()
+def config():
+    """Open or display the current .env configuration."""
+    from skyintel.config import get_settings
+
+    settings = get_settings()
+    console.print(settings.model_dump_json(indent=2))
+
+@app.command()
+def flights(
+    lat: float = typer.Option(None, help="Latitude"),
+    lon: float = typer.Option(None, help="Longitude"),
+    radius: float = typer.Option(100, help="Radius in km"),
+    military_only: bool = typer.Option(False, "--military", help="Military flights only"),
+    query: str = typer.Option(None, "--search", help="Search by callsign or ICAO24"),
+):
+    """List live flights — nearby, military, or search."""
+    import asyncio
+    from skyintel import service
+
+    async def _run():
+        if query:
+            results = await service.search_flight(query)
+        elif military_only:
+            results = await service.military_flights()
+        elif lat is not None and lon is not None:
+            results = await service.flights_near(lat, lon, radius)
+        else:
+            console.print("[red]Provide --search, --military, or --lat/--lon[/]")
+            return
+
+        table = Table(title=f"Flights ({len(results)})", border_style="dim")
+        for col in ["ICAO24", "Callsign", "Type", "Alt (ft)", "Speed (kt)", "Heading"]:
+            table.add_column(col)
+        for f in results:
+            alt = str(round(f["altitude_m"] * 3.28084)) if f.get("altitude_m") else ""
+            spd = str(round(f["velocity_ms"] * 1.94384)) if f.get("velocity_ms") else ""
+            hdg = str(round(f["heading"])) + "°" if f.get("heading") else ""
+            table.add_row(f["icao24"], f.get("callsign") or "", f.get("aircraft_type", ""), alt, spd, hdg)
+        console.print(table)
+        await service.cleanup()
+
+    asyncio.run(_run())
+
+@app.command()
+def satellites(
+    category: str = typer.Option(None, help="Filter by category (iss, military, weather, nav, science, starlink)"),
+):
+    """List current satellite positions."""
+    import asyncio
+    from skyintel import service
+
+    async def _run():
+        results = await service.get_satellites(category)
+        table = Table(title=f"Satellites ({len(results)})", border_style="dim")
+        for col in ["NORAD", "Name", "Category", "Alt (km)", "Speed (m/s)", "Lat", "Lon"]:
+            table.add_column(col)
+        for s in results:
+            table.add_row(
+                str(s["norad_id"]), s["name"], s["category"],
+                str(round(s.get("altitude_km", 0))),
+                str(round(s.get("speed_ms", 0))),
+                f'{s["latitude"]:.2f}', f'{s["longitude"]:.2f}',
+            )
+        console.print(table)
+        await service.cleanup()
+
+    asyncio.run(_run())
+
+@app.command()
+def above(
+    lat: float = typer.Option(..., help="Latitude"),
+    lon: float = typer.Option(..., help="Longitude"),
+    radius: float = typer.Option(100, help="Radius in km"),
+):
+    """Show flights and satellites above a location."""
+    import asyncio
+    from skyintel import service
+
+    async def _run():
+        flights_data, sats_data = await asyncio.gather(
+            service.flights_near(lat, lon, radius),
+            service.get_satellites(),
+        )
+
+        # Filter satellites by rough distance
+        import math
+        # nearby_sats = []
+        # for s in sats_data:
+        #     dlat = s["latitude"] - lat
+        #     dlon = s["longitude"] - lon
+        #     dist_km = math.sqrt(dlat**2 + dlon**2) * 111
+        #     if dist_km <= radius:
+        #         nearby_sats.append(s)
+
+        nearby_sats = []
+        for s in sats_data:
+            dlat = math.radians(s["latitude"] - lat)
+            dlon = math.radians(s["longitude"] - lon)
+            a = math.sin(dlat/2)**2 + math.cos(math.radians(lat)) * math.cos(math.radians(s["latitude"])) * math.sin(dlon/2)**2
+            dist_km = 6371 * 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))
+            if dist_km <= radius:
+                nearby_sats.append(s)
+
+
+        console.print(f"\n[bold cyan]📍 Above ({lat:.2f}, {lon:.2f}) — {radius}km radius[/]\n")
+
+        ft = Table(title=f"Flights ({len(flights_data)})", border_style="dim")
+        for col in ["ICAO24", "Callsign", "Type", "Alt (ft)", "Speed (kt)"]:
+            ft.add_column(col)
+        for f in flights_data:
+            alt = str(round(f["altitude_m"] * 3.28084)) if f.get("altitude_m") else ""
+            spd = str(round(f["velocity_ms"] * 1.94384)) if f.get("velocity_ms") else ""
+            ft.add_row(f["icao24"], f.get("callsign") or "", f.get("aircraft_type", ""), alt, spd)
+        console.print(ft)
+
+        st = Table(title=f"Satellites ({len(nearby_sats)})", border_style="dim")
+        for col in ["NORAD", "Name", "Category", "Alt (km)"]:
+            st.add_column(col)
+        for s in nearby_sats:
+            st.add_row(str(s["norad_id"]), s["name"], s["category"], str(round(s.get("altitude_km", 0))))
+        console.print(st)
+        await service.cleanup()
+
+    asyncio.run(_run())
+
+@app.command(name="mcp-config")
+def mcp_config(
+    stdio: bool = typer.Option(False, "--stdio", help="Print stdio config"),
+    vscode: bool = typer.Option(False, "--vscode", help="Print VS Code format"),
+):
+    """Print MCP configuration snippet for Claude Desktop / VS Code / Cursor."""
+    import json
+    from skyintel.config import get_settings
+
+    if stdio:
+        inner = {"command": "skyintel", "args": ["serve", "--stdio"]}
+    else:
+        settings = get_settings()
+        inner = {"url": f"http://localhost:{settings.port}/mcp"}
+
+    key = "servers" if vscode else "mcpServers"
+    config = {key: {"skyintel": inner}}
+
+    target = "VS Code" if vscode else "Claude Desktop / Cursor"
+    console.print(f"\n[bold cyan]Add this to your mcp.json ({target}):[/]\n")
+    console.print(json.dumps(config, indent=2))
+    console.print()
+
+@app.command()
+def ask(
+    question: str = typer.Argument(..., help="Question to ask the AI"),
+    provider: str = typer.Option(None, help="LLM provider (anthropic/openai/google)"),
+    api_key: str = typer.Option(None, "--api-key", help="API key"),
+    model: str = typer.Option(None, help="Model name"),
+):
+    """Ask the AI a question using your LLM API key."""
+    import asyncio
+    from skyintel.config import get_settings
+    from skyintel.llm.gateway import chat as llm_chat
+
+    settings = get_settings()
+    p = provider or settings.llm_provider
+    k = api_key or settings.llm_api_key
+    m = model or settings.llm_model
+
+    if not all([p, k, m]):
+        console.print("[red]LLM not configured.[/] Set SKYINTEL_LLM_PROVIDER, SKYINTEL_LLM_API_KEY, SKYINTEL_LLM_MODEL in .env or pass --provider, --api-key, --model")
+        raise typer.Exit(1)
+
+    async def _run():
+        with console.status("[cyan]Thinking…[/]"):
+            reply = await llm_chat([{"role": "user", "content": question}], p, k, m, output_format="markdown")
+        reply = reply.strip()
+        console.print()
+        from rich.markdown import Markdown
+        console.print(Markdown(reply))
+        
+
+    asyncio.run(_run())
+
+@app.command()
+def iss(
+    passes_flag: bool = typer.Option(False, "--passes", help="Show upcoming pass predictions"),
+    lat: float = typer.Option(None, help="Observer latitude (for --passes)"),
+    lon: float = typer.Option(None, help="Observer longitude (for --passes)"),
+    hours: int = typer.Option(24, help="Lookahead hours (for --passes)"),
+):
+    """Show ISS position, crew, and pass predictions."""
+    import asyncio
+    from skyintel import service
+
+    async def _run():
+        if passes_flag:
+            if lat is None or lon is None:
+                console.print("[red]--lat and --lon required for pass predictions[/]")
+                return
+            result = await service.iss_passes(lat, lon, hours)
+            table = Table(title=f"ISS Passes ({result['total_count']})", border_style="dim")
+            for col in ["Rise (UTC)", "Direction", "Max Elev", "Set (UTC)", "Duration"]:
+                table.add_column(col)
+            for p in result["passes"]:
+                table.add_row(
+                    p.get("rise_utc", "")[:19],
+                    p.get("rise_direction", ""),
+                    f'{p.get("max_elevation", 0)}°',
+                    p.get("set_utc", "")[:19],
+                    f'{p.get("duration_seconds", 0)}s',
+                )
+            console.print(table)
+        else:
+            pos, crew = await asyncio.gather(service.iss_position(), service.iss_crew())
+            table = Table(title="🛰 ISS Status", show_header=False, border_style="dim")
+            table.add_column("Key", style="bold cyan")
+            table.add_column("Value")
+            table.add_row("Latitude", f'{pos.get("latitude", 0):.4f}')
+            table.add_row("Longitude", f'{pos.get("longitude", 0):.4f}')
+            table.add_row("Altitude", f'{pos.get("altitude_km", 0):.0f} km')
+            table.add_row("Speed", f'{pos.get("speed_ms", 0):.0f} m/s')
+            table.add_row("Crew", str(crew.get("count", 0)))
+            for c in crew.get("crew", []):
+                table.add_row("", f' . {c["name"]}')
+            console.print(table)
+        await service.cleanup()    
+
+    asyncio.run(_run())
+
+
+

skyintel/config.py

@@ -0,0 +1,57 @@
+from pathlib import Path
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(
+        env_prefix="SKYINTEL_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="forbid",
+    )
+
+    # Server
+    host: str = "0.0.0.0"
+    port: int = 9096
+
+    # Database
+    #db_path: Path = Path.home() / ".osai" / "osai.db"
+    db_path: Path = Path.home() / ".skyintel" / "skyintel.db"
+
+
+    # OpenSky Network (OAuth2)
+    opensky_client_id: str | None = None
+    opensky_client_secret: str | None = None
+
+    # Poll intervals (seconds)
+    flight_poll_interval: int = 30
+    satellite_poll_interval: int = 3600
+
+    # LLM (web UI chat only)
+    llm_provider: str | None = None
+    llm_api_key: str | None = None
+    llm_model: str | None = None
+
+    # Cesium
+    cesium_ion_token: str | None = None
+
+    # LangFuse
+    langfuse_public_key: str | None = None
+    langfuse_secret_key: str | None = None
+    #langfuse_host: str = "https://cloud.langfuse.com"
+    langfuse_otel_host: str = "https://cloud.langfuse.com"
+
+
+
+
+    @property
+    def opensky_configured(self) -> bool:
+        return self.opensky_client_id is not None and self.opensky_client_secret is not None
+
+    @property
+    def llm_configured(self) -> bool:
+        return all([self.llm_provider, self.llm_api_key, self.llm_model])
+
+
+def get_settings() -> Settings:
+    return Settings()

skyintel/flights/__init__.py

@@ -0,0 +1 @@
+"""Open Sky Intelligence flight tracking."""

skyintel/flights/adsb_lol.py

@@ -0,0 +1,122 @@
+import httpx
+import logging
+from skyintel.models import NormalizedFlight
+
+logger = logging.getLogger(__name__)
+
+ALL_URL = "https://api.adsb.lol/v2/all"
+MIL_URL = "https://api.adsb.lol/v2/mil"
+
+# Conversion factors
+FT_TO_M = 0.3048
+KT_TO_MS = 0.514444
+FTMIN_TO_MS = 0.00508
+
+
+def _normalize(ac: dict, force_military: bool = False) -> NormalizedFlight | None:
+    """Convert an ADSB.lol aircraft dict to NormalizedFlight."""
+    hex_code = ac.get("hex", "").strip().lower()
+    if not hex_code:
+        return None
+
+    lat = ac.get("lat")
+    lon = ac.get("lon")
+    if lat is None or lon is None:
+        return None
+
+    # Skip ground traffic
+    alt_baro = ac.get("alt_baro")
+    if alt_baro == "ground" or alt_baro is None:
+        return None
+
+    # Unit conversions: ADSB.lol uses feet, knots, ft/min
+    altitude_m = float(alt_baro) * FT_TO_M if isinstance(alt_baro, (int, float)) else None
+    gs = ac.get("gs")
+    velocity_ms = float(gs) * KT_TO_MS if gs is not None else None
+    baro_rate = ac.get("baro_rate")
+    vertical_rate = float(baro_rate) * FTMIN_TO_MS if baro_rate is not None else None
+
+    callsign = (ac.get("flight") or "").strip() or None
+
+    return NormalizedFlight(
+        icao24=hex_code,
+        callsign=callsign,
+        aircraft_type="military" if force_military else "commercial",
+        model=ac.get("t"),
+        registration=ac.get("r"),
+        latitude=lat,
+        longitude=lon,
+        altitude_m=altitude_m,
+        velocity_ms=velocity_ms,
+        heading=ac.get("track"),
+        vertical_rate=vertical_rate,
+        squawk=ac.get("squawk"),
+        source="adsb_lol",
+    )
+
+
+class AdsbLolClient:
+    def __init__(self):
+        self._http = httpx.AsyncClient(timeout=30.0)
+
+    async def get_all(self) -> list[NormalizedFlight]:
+        """Fetch all worldwide flights."""
+        resp = await self._http.get(ALL_URL)
+        resp.raise_for_status()
+        data = resp.json()
+
+        flights = []
+        for ac in data.get("ac", []):
+            f = _normalize(ac, force_military=False)
+            if f:
+                flights.append(f)
+
+        logger.info("ADSB.lol all: %d airborne flights", len(flights))
+        return flights
+
+    async def get_military(self) -> list[NormalizedFlight]:
+        """Fetch military flights worldwide."""
+        resp = await self._http.get(MIL_URL)
+        resp.raise_for_status()
+        data = resp.json()
+
+        flights = []
+        for ac in data.get("ac", []):
+            f = _normalize(ac, force_military=True)
+            if f:
+                flights.append(f)
+
+        logger.info("ADSB.lol military: %d flights", len(flights))
+        return flights
+    
+    async def get_nearby(self, lat: float, lon: float, radius_m: int = 99999) -> list[NormalizedFlight]:
+        """Fetch flights within radius of a point (max 99999m)."""
+        radius_m = min(radius_m, 99999)
+        url = f"https://api.adsb.lol/v2/point/{lat}/{lon}/{radius_m}"
+        resp = await self._http.get(url)
+        resp.raise_for_status()
+        flights = [f for ac in resp.json().get("ac", []) if (f := _normalize(ac))]
+        logger.info("ADSB.lol nearby (%.2f,%.2f r=%dm): %d flights", lat, lon, radius_m, len(flights))
+        return flights
+
+    async def get_by_callsign(self, callsign: str) -> list[NormalizedFlight]:
+        """Fetch flights matching a callsign."""
+        url = f"https://api.adsb.lol/v2/callsign/{callsign.strip().upper()}"
+        resp = await self._http.get(url)
+        resp.raise_for_status()
+        flights = [f for ac in resp.json().get("ac", []) if (f := _normalize(ac))]
+        logger.info("ADSB.lol callsign %s: %d flights", callsign, len(flights))
+        return flights
+
+    async def get_by_hex(self, icao24: str) -> list[NormalizedFlight]:
+        """Fetch flight by ICAO24 hex code."""
+        url = f"https://api.adsb.lol/v2/hex/{icao24.strip().upper()}"
+        resp = await self._http.get(url)
+        resp.raise_for_status()
+        flights = [f for ac in resp.json().get("ac", []) if (f := _normalize(ac))]
+        logger.info("ADSB.lol hex %s: %d flights", icao24, len(flights))
+        return flights
+
+
+    async def close(self):
+        await self._http.aclose()

skyintel/flights/classifier.py

@@ -0,0 +1,66 @@
+"""Classify aircraft as military / commercial / private."""
+
+import re
+
+# Military callsign prefixes (common worldwide)
+MILITARY_CALLSIGN_PREFIXES = {
+    "RCH", "REACH", "DUKE", "NAVY", "EVAC", "COBRA", "VIPER",
+    "HAWK", "EAGLE", "RAPTOR", "BOXER", "DOOM", "SKULL", "IRON",
+    "FURY", "BLADE", "GHOST", "REAPER", "WEASEL", "KNIGHT",
+    "RAID", "TOPCAT", "STEEL", "TANGO", "WOLF", "TALON",
+    "HAVOC", "ROGUE", "STORM", "MAGMA", "ATLAS", "DRAKE",
+    "NATO", "ASCOT", "RAFALE", "CASA", "SHARK", "SIGINT",
+    "RRR", "CFC", "CNV", "PLF", "FAB", "IAM", "MMF",
+}
+
+# ICAO hex ranges allocated to military (partial list, major countries)
+MILITARY_HEX_RANGES = [
+    ("ae0000", "afffff"),  # US military
+    ("43c000", "43cfff"),  # UK military
+    ("3f0000", "3fffff"),  # Germany military
+    ("3a8000", "3abfff"),  # France military
+    ("300000", "33ffff"),  # Italy military (partial)
+]
+
+# Squawk codes associated with military
+MILITARY_SQUAWKS = {"7501", "7502", "7503", "7504", "7505", "0021", "0022", "0023"}
+
+_compiled_prefixes = re.compile(
+    r"^(" + "|".join(re.escape(p) for p in MILITARY_CALLSIGN_PREFIXES) + r")",
+    re.IGNORECASE,
+)
+
+
+def _hex_in_military_range(icao24: str) -> bool:
+    try:
+        val = int(icao24, 16)
+    except (ValueError, TypeError):
+        return False
+    for lo, hi in MILITARY_HEX_RANGES:
+        if int(lo, 16) <= val <= int(hi, 16):
+            return True
+    return False
+
+
+def classify(flight) -> str:
+    """
+    Classify a NormalizedFlight. Returns 'military', 'commercial', or 'private'.
+    If already tagged as military (e.g. from ADSB.lol /v2/mil), preserves that.
+    """
+    # Already tagged military by source
+    if flight.aircraft_type == "military":
+        return "military"
+
+    # Callsign match
+    if flight.callsign and _compiled_prefixes.match(flight.callsign):
+        return "military"
+
+    # ICAO hex range
+    if _hex_in_military_range(flight.icao24):
+        return "military"
+
+    # Squawk code
+    if flight.squawk and flight.squawk in MILITARY_SQUAWKS:
+        return "military"
+
+    return flight.aircraft_type