nexo-brain 7.28.0 → 7.30.0

package/src/scripts/nexo-morning-agent.py

@@ -38,8 +38,12 @@ import signal
 import subprocess
 import sys
 import tempfile
+import urllib.parse
+import urllib.request
+import xml.etree.ElementTree as ET
 from datetime import date, datetime
 from pathlib import Path
+from typing import Any
 
 _script_dir = Path(__file__).resolve().parent
 _repo_src = _script_dir.parent
@@ -47,6 +51,7 @@ if str(_repo_src) not in sys.path:
     sys.path.insert(0, str(_repo_src))
 
 from agent_runner import AutomationBackendUnavailableError, run_automation_prompt
+from automation_preferences import format_automation_preferences_prompt_block, get_automation_preferences
 from automation_controls import (
     format_operator_extra_instructions_block,
     get_operator_briefing_recipient_status,
@@ -56,9 +61,16 @@ from automation_controls import (
 )
 from client_preferences import resolve_automation_backend, resolve_client_runtime_profile
 from core_prompts import render_core_prompt
+from email_presentation import build_email_presentation, normalize_agent_email_payload
 from email_sent_events import format_recent_sent_email_block, recent_sent_emails
+from morning_briefing import (
+    LATEST_MARKDOWN_FILE,
+    ensure_morning_briefing_runs_table as _ensure_briefing_schema,
+    mark_morning_briefing_sent as _persist_morning_briefing_sent,
+    write_latest_briefing_artifacts,
+)
 import db as nexo_db
-from paths import data_dir, logs_dir, operations_dir
+from paths import data_dir, logs_dir
 from runtime_home import export_resolved_nexo_home
 
 NEXO_HOME = export_resolved_nexo_home()
@@ -66,7 +78,7 @@ LOG_DIR = logs_dir()
 LOG_DIR.mkdir(parents=True, exist_ok=True)
 LOG_FILE = LOG_DIR / "morning-agent.log"
 STATE_FILE = data_dir() / "morning-agent-state.json"
-LATEST_BRIEFING_FILE = operations_dir() / "morning-briefing-latest.md"
+LATEST_BRIEFING_FILE = LATEST_MARKDOWN_FILE
 CALLER = "morning_agent"
 CLI_TIMEOUT = 1500
 MAX_DUE_ITEMS = 8
@@ -74,6 +86,8 @@ MAX_ACTIVE_ITEMS = 8
 MAX_DIARY_ITEMS = 6
 MORNING_BRIEFING_STALE_HOURS = 12
 _ACTIVE_CLAIM: dict[str, str] = {}
+HTTP_TIMEOUT = 7
+DEFAULT_NEWS_RSS_URL = "https://news.google.com/rss?hl=es&gl=ES&ceid=ES:es"
 
 
 def log(message: str) -> None:
@@ -105,29 +119,7 @@ def _morning_db_connection():
 
 
 def _ensure_morning_briefing_runs_table(conn) -> None:
-    conn.execute(
-        """CREATE TABLE IF NOT EXISTS morning_briefing_runs (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            local_date TEXT NOT NULL,
-            recipient TEXT NOT NULL,
-            status TEXT NOT NULL DEFAULT 'in_progress',
-            subject TEXT DEFAULT '',
-            send_output TEXT DEFAULT '',
-            error TEXT DEFAULT '',
-            started_at TEXT DEFAULT (datetime('now')),
-            finished_at TEXT DEFAULT NULL,
-            updated_at TEXT DEFAULT (datetime('now')),
-            UNIQUE(local_date, recipient)
-        )"""
-    )
-    conn.execute(
-        "CREATE INDEX IF NOT EXISTS idx_morning_briefing_runs_date "
-        "ON morning_briefing_runs(local_date)"
-    )
-    conn.execute(
-        "CREATE INDEX IF NOT EXISTS idx_morning_briefing_runs_status "
-        "ON morning_briefing_runs(status)"
-    )
+    _ensure_briefing_schema(conn)
 
 
 def _row_dict(row) -> dict:
@@ -189,8 +181,14 @@ def _claim_morning_briefing_send(local_date: str, recipient: str, *, force: bool
             ON CONFLICT(local_date, recipient) DO UPDATE SET
                 status = 'in_progress',
                 subject = '',
+                body_text = '',
+                body_html = '',
+                artifact_json = '',
                 send_output = '',
                 error = '',
+                desktop_shown_at = NULL,
+                desktop_opened_at = NULL,
+                desktop_dismissed_at = NULL,
                 started_at = excluded.started_at,
                 finished_at = NULL,
                 updated_at = excluded.updated_at
@@ -226,8 +224,14 @@ def _claim_morning_briefing_send(local_date: str, recipient: str, *, force: bool
             UPDATE morning_briefing_runs
             SET status = 'in_progress',
                 subject = '',
+                body_text = '',
+                body_html = '',
+                artifact_json = '',
                 send_output = '',
                 error = '',
+                desktop_shown_at = NULL,
+                desktop_opened_at = NULL,
+                desktop_dismissed_at = NULL,
                 started_at = ?,
                 finished_at = NULL,
                 updated_at = ?
@@ -268,24 +272,25 @@ def _record_existing_morning_briefing_sent(local_date: str, recipient: str, stat
     conn.commit()
 
 
-def _mark_morning_briefing_sent(local_date: str, recipient: str, *, subject: str, send_output: str) -> None:
-    now = datetime.now().astimezone().isoformat()
-    conn = _morning_db_connection()
-    _ensure_morning_briefing_runs_table(conn)
-    conn.execute(
-        """
-        UPDATE morning_briefing_runs
-        SET status = 'sent',
-            subject = ?,
-            send_output = ?,
-            error = '',
-            finished_at = ?,
-            updated_at = ?
-        WHERE local_date = ? AND recipient = ?
-        """,
-        (str(subject or ""), str(send_output or ""), now, now, str(local_date or ""), str(recipient or "")),
+def _mark_morning_briefing_sent(
+    local_date: str,
+    recipient: str,
+    *,
+    subject: str,
+    body_text: str,
+    body_html: str,
+    send_output: str,
+    artifact_payload: dict | None = None,
+) -> None:
+    _persist_morning_briefing_sent(
+        local_date=local_date,
+        recipient=recipient,
+        subject=subject,
+        body_text=body_text,
+        body_html=body_html,
+        send_output=send_output,
+        artifact_payload=artifact_payload,
     )
-    conn.commit()
 
 
 def _mark_morning_briefing_failed(local_date: str, recipient: str, *, error: str) -> None:
@@ -448,7 +453,250 @@ def _serialize_recent_sent_emails(*, limit: int = 8) -> list[dict]:
     return result
 
 
-def collect_context(profile: dict) -> dict:
+def _fetch_json_url(url: str, *, timeout: int = HTTP_TIMEOUT) -> dict:
+    request = urllib.request.Request(
+        url,
+        headers={"User-Agent": "NEXO-Morning-Agent/1.0"},
+    )
+    with urllib.request.urlopen(request, timeout=timeout) as response:
+        raw = response.read(512_000)
+    payload = json.loads(raw.decode("utf-8", errors="replace"))
+    return payload if isinstance(payload, dict) else {}
+
+
+def _fetch_text_url(url: str, *, timeout: int = HTTP_TIMEOUT) -> str:
+    request = urllib.request.Request(
+        url,
+        headers={"User-Agent": "NEXO-Morning-Agent/1.0"},
+    )
+    with urllib.request.urlopen(request, timeout=timeout) as response:
+        return response.read(512_000).decode("utf-8", errors="replace")
+
+
+def _desktop_settings_candidates() -> list[Path]:
+    home = Path.home()
+    candidates = [
+        Path(os.environ.get("NEXO_DESKTOP_SETTINGS", "")),
+        Path(os.environ.get("NEXO_DESKTOP_USER_DATA", "")) / "app-settings.json",
+        home / "Library" / "Application Support" / "nexo-desktop-mvp" / "app-settings.json",
+        home / "Library" / "Application Support" / "NEXO Desktop" / "app-settings.json",
+        home / "Library" / "Application Support" / "nexo-desktop" / "app-settings.json",
+    ]
+    return [candidate for candidate in candidates if str(candidate)]
+
+
+def _read_desktop_settings() -> dict:
+    for candidate in _desktop_settings_candidates():
+        try:
+            if candidate.is_file():
+                payload = json.loads(candidate.read_text())
+                if isinstance(payload, dict):
+                    return payload
+        except Exception:
+            continue
+    return {}
+
+
+def _normalize_location_candidate(value: object) -> dict:
+    if not value:
+        return {}
+    candidate = value
+    if isinstance(value, str):
+        text = value.strip()
+        if not text:
+            return {}
+        try:
+            candidate = json.loads(text)
+        except Exception:
+            return {"name": text}
+    if not isinstance(candidate, dict):
+        return {}
+    lat = candidate.get("lat", candidate.get("latitude"))
+    lon = candidate.get("lon", candidate.get("longitude"))
+    name = str(candidate.get("name") or candidate.get("display") or candidate.get("city") or "").strip()
+    try:
+        lat_value = float(lat)
+        lon_value = float(lon)
+    except Exception:
+        lat_value = None
+        lon_value = None
+    if lat_value is not None and lon_value is not None:
+        return {"lat": lat_value, "lon": lon_value, "name": name}
+    return {"name": name} if name else {}
+
+
+def _geocode_location_name(name: str, *, language: str = "es") -> dict:
+    clean = str(name or "").strip()
+    if not clean:
+        return {}
+    params = urllib.parse.urlencode({
+        "name": clean,
+        "count": "1",
+        "language": "en" if str(language).lower().startswith("en") else "es",
+        "format": "json",
+    })
+    payload = _fetch_json_url(f"https://geocoding-api.open-meteo.com/v1/search?{params}")
+    hit = (payload.get("results") or [None])[0]
+    if not isinstance(hit, dict):
+        return {}
+    try:
+        lat = float(hit.get("latitude"))
+        lon = float(hit.get("longitude"))
+    except Exception:
+        return {}
+    label_parts = [
+        str(hit.get("name") or clean).strip(),
+        str(hit.get("admin1") or "").strip(),
+        str(hit.get("country") or "").strip(),
+    ]
+    return {
+        "lat": lat,
+        "lon": lon,
+        "name": ", ".join(part for part in label_parts if part),
+    }
+
+
+def _resolve_weather_location(profile: dict) -> dict:
+    settings = _read_desktop_settings()
+    app = settings.get("app") if isinstance(settings.get("app"), dict) else {}
+    app_loc = app.get("location") if isinstance(app.get("location"), dict) else {}
+    language = str(app.get("ui_language") or profile.get("language") or "es")
+
+    explicit = _normalize_location_candidate(app_loc)
+    if explicit.get("lat") is not None and explicit.get("lon") is not None:
+        return explicit
+    if explicit.get("name"):
+        try:
+            geocoded = _geocode_location_name(str(explicit.get("name")), language=language)
+            if geocoded:
+                return geocoded
+        except Exception:
+            pass
+
+    desktop_profile = settings.get("profile") if isinstance(settings.get("profile"), dict) else {}
+    for source in [
+        desktop_profile.get("current_residence"),
+        profile.get("current_residence"),
+        profile.get("location"),
+        profile.get("coordinates"),
+    ]:
+        candidate = _normalize_location_candidate(source)
+        if candidate.get("lat") is not None and candidate.get("lon") is not None:
+            return candidate
+        if candidate.get("name"):
+            try:
+                geocoded = _geocode_location_name(str(candidate.get("name")), language=language)
+                if geocoded:
+                    return geocoded
+            except Exception:
+                continue
+
+    direct = _normalize_location_candidate({
+        "latitude": profile.get("latitude"),
+        "longitude": profile.get("longitude"),
+        "name": profile.get("current_residence") or "",
+    })
+    return direct
+
+
+def _weather_code_label(code: object) -> str:
+    try:
+        value = int(code)
+    except Exception:
+        return ""
+    if value == 0:
+        return "clear"
+    if value in {1, 2, 3}:
+        return "partly cloudy"
+    if value in {45, 48}:
+        return "fog"
+    if value in {51, 53, 55, 56, 57}:
+        return "drizzle"
+    if value in {61, 63, 65, 66, 67, 80, 81, 82}:
+        return "rain"
+    if value in {71, 73, 75, 77, 85, 86}:
+        return "snow"
+    if value in {95, 96, 99}:
+        return "storm"
+    return "unknown"
+
+
+def _collect_weather(profile: dict) -> dict:
+    try:
+        loc = _resolve_weather_location(profile)
+        if not loc or loc.get("lat") is None or loc.get("lon") is None:
+            return {"available": False, "error": "no_location"}
+        params = urllib.parse.urlencode({
+            "latitude": loc["lat"],
+            "longitude": loc["lon"],
+            "current_weather": "true",
+            "daily": "temperature_2m_max,temperature_2m_min,precipitation_probability_max",
+            "timezone": "auto",
+        })
+        payload = _fetch_json_url(f"https://api.open-meteo.com/v1/forecast?{params}")
+        current = payload.get("current_weather") if isinstance(payload.get("current_weather"), dict) else {}
+        daily = payload.get("daily") if isinstance(payload.get("daily"), dict) else {}
+        if not current:
+            return {"available": False, "error": "weather_unavailable", "location": loc.get("name") or ""}
+        code = current.get("weathercode")
+        return {
+            "available": True,
+            "source": "open-meteo",
+            "location": loc.get("name") or "",
+            "temperature_c": current.get("temperature"),
+            "weather_code": code,
+            "weather": _weather_code_label(code),
+            "high_c": (daily.get("temperature_2m_max") or [None])[0],
+            "low_c": (daily.get("temperature_2m_min") or [None])[0],
+            "precipitation_probability_max": (daily.get("precipitation_probability_max") or [None])[0],
+        }
+    except Exception as exc:
+        return {"available": False, "error": str(exc)[:240]}
+
+
+def _collect_news(profile: dict) -> dict:
+    try:
+        rss_url = str(profile.get("news_rss_url") or os.environ.get("NEXO_NEWS_RSS_URL") or DEFAULT_NEWS_RSS_URL).strip()
+        if not rss_url:
+            return {"available": False, "error": "no_news_source"}
+        xml_text = _fetch_text_url(rss_url)
+        root = ET.fromstring(xml_text)
+        items: list[dict] = []
+        for item in root.findall(".//item"):
+            title = _clean_text(item.findtext("title"), limit=220)
+            link = str(item.findtext("link") or "").strip()
+            source = _clean_text(item.findtext("source"), limit=80)
+            published = _clean_text(item.findtext("pubDate"), limit=120)
+            if title:
+                items.append({
+                    "title": title,
+                    "source": source,
+                    "published": published,
+                    "url": link[:500],
+                })
+            if len(items) >= 6:
+                break
+        return {
+            "available": bool(items),
+            "source": rss_url,
+            "headlines": items,
+            "error": "" if items else "empty_feed",
+        }
+    except Exception as exc:
+        return {"available": False, "error": str(exc)[:240], "headlines": []}
+
+
+def _collect_external_context(profile: dict, preferences: dict | None) -> dict:
+    values = preferences if isinstance(preferences, dict) else {}
+    external: dict[str, Any] = {}
+    if values.get("weather"):
+        external["weather"] = _collect_weather(profile)
+    if values.get("news"):
+        external["news"] = _collect_news(profile)
+    return external
+
+
+def collect_context(profile: dict, preferences: dict | None = None) -> dict:
     nexo_db.init_db()
     due_followups = _serialize_followups("due", limit=MAX_DUE_ITEMS)
     due_followup_ids = {row["id"] for row in due_followups}
@@ -465,6 +713,7 @@ def collect_context(profile: dict) -> dict:
         if row["id"] not in due_reminder_ids
     ][:MAX_ACTIVE_ITEMS]
     recent_sent = _serialize_recent_sent_emails()
+    external = _collect_external_context(profile, preferences)
     return {
         "generated_at": datetime.now().astimezone().isoformat(),
         "today": date.today().isoformat(),
@@ -472,6 +721,9 @@ def collect_context(profile: dict) -> dict:
             "name": str(profile.get("operator_name") or "the operator"),
             "language": str(profile.get("language") or "en"),
             "email": str(profile.get("operator_email") or ""),
+            "role": str(profile.get("role") or ""),
+            "technical_level": str(profile.get("technical_level") or ""),
+            "residence": str(profile.get("current_residence") or ""),
         },
         "assistant": {
             "name": str(profile.get("assistant_name") or "Nova"),
@@ -482,6 +734,7 @@ def collect_context(profile: dict) -> dict:
         "active_followups": active_followups,
         "recent_diaries": _serialize_diaries(limit=MAX_DIARY_ITEMS),
         "recent_sent_emails_24h": recent_sent,
+        "external": external,
         "counts": {
             "due_reminders": len(due_reminders),
             "active_reminders": len(active_reminders),
@@ -548,7 +801,7 @@ def _extract_json_payload(raw_text: str) -> dict:
     raise RuntimeError("Morning agent returned invalid JSON output.")
 
 
-def generate_briefing(prompt: str) -> tuple[str, str]:
+def generate_briefing(prompt: str):
     backend = resolve_automation_backend()
     profile = resolve_client_runtime_profile(backend) if backend != "none" else {"model": "", "reasoning_effort": ""}
     profile_label = profile.get("model") or "default"
@@ -576,33 +829,42 @@ def generate_briefing(prompt: str) -> tuple[str, str]:
         raise RuntimeError(detail or f"automation backend exited {result.returncode}")
 
     payload = _extract_json_payload(result.stdout or "")
-    subject = str(payload.get("subject") or "").strip()
-    body = str(payload.get("body") or "").strip()
-    if not subject or not body:
-        raise RuntimeError("Morning agent output is missing subject/body.")
-    return subject, body
-
-
-def write_latest_briefing(*, recipient: str, subject: str, body: str) -> None:
-    LATEST_BRIEFING_FILE.parent.mkdir(parents=True, exist_ok=True)
-    rendered = (
-        f"# Morning briefing\n\n"
-        f"- Generated at: {datetime.now().astimezone().isoformat()}\n"
-        f"- To: {recipient}\n"
-        f"- Subject: {subject}\n\n"
-        f"{body}\n"
+    try:
+        return normalize_agent_email_payload(payload)
+    except RuntimeError as exc:
+        raise RuntimeError("Morning agent output is missing subject/body.") from exc
+
+
+def write_latest_briefing(
+    *,
+    recipient: str,
+    subject: str,
+    body_text: str,
+    body_html: str,
+    local_date: str = "",
+    run_id: int | None = None,
+) -> dict:
+    return write_latest_briefing_artifacts(
+        recipient=recipient,
+        subject=subject,
+        body_text=body_text,
+        body_html=body_html,
+        local_date=local_date,
+        run_id=run_id,
     )
-    LATEST_BRIEFING_FILE.write_text(rendered, encoding="utf-8")
 
 
-def send_briefing(*, recipient: str, subject: str, body: str) -> str:
+def send_briefing(*, recipient: str, subject: str, body_text: str, body_html: str) -> str:
     sender = get_send_reply_script_path(local_script_dir=_script_dir)
     if not sender.exists():
         raise RuntimeError(f"nexo-send-reply.py not found at {sender}")
 
     tmp_fd, tmp_path = tempfile.mkstemp(prefix="morning-briefing-", suffix=".txt")
     os.close(tmp_fd)
-    Path(tmp_path).write_text(body, encoding="utf-8")
+    html_fd, html_path = tempfile.mkstemp(prefix="morning-briefing-", suffix=".html")
+    os.close(html_fd)
+    Path(tmp_path).write_text(body_text, encoding="utf-8")
+    Path(html_path).write_text(body_html, encoding="utf-8")
     try:
         result = subprocess.run(
             [
@@ -614,6 +876,12 @@ def send_briefing(*, recipient: str, subject: str, body: str) -> str:
                 subject,
                 "--body-file",
                 tmp_path,
+                "--html-file",
+                html_path,
+                "--audience",
+                "operator",
+                "--message-kind",
+                "morning_briefing",
             ],
             capture_output=True,
             text=True,
@@ -621,6 +889,7 @@ def send_briefing(*, recipient: str, subject: str, body: str) -> str:
         )
     finally:
         Path(tmp_path).unlink(missing_ok=True)
+        Path(html_path).unlink(missing_ok=True)
 
     if result.returncode != 0:
         detail = (result.stderr or result.stdout or "").strip()
@@ -667,28 +936,68 @@ def main(argv: list[str] | None = None) -> int:
         _set_active_claim(today, recipient)
 
     try:
-        context = collect_context(profile)
+        preference_contract = get_automation_preferences("morning-agent")
+        preference_values = (
+            (preference_contract.get("preferences") or {}).get("values")
+            if isinstance(preference_contract, dict)
+            else {}
+        )
+        context = collect_context(profile, preference_values if isinstance(preference_values, dict) else {})
+        extra_blocks = "\n".join(
+            block
+            for block in [
+                format_automation_preferences_prompt_block("morning-agent"),
+                format_operator_extra_instructions_block("morning-agent"),
+            ]
+            if block.strip()
+        )
         prompt = build_prompt(
             context,
-            extra_instructions_block=format_operator_extra_instructions_block("morning-agent"),
+            extra_instructions_block=extra_blocks,
+        )
+        presentation = generate_briefing(prompt)
+        body_text = append_recent_sent_email_block(presentation.body_text)
+        if body_text != presentation.body_text:
+            presentation = build_email_presentation(subject=presentation.subject, body_text=body_text)
+        artifact_payload = write_latest_briefing(
+            recipient=recipient or "[dry-run]",
+            subject=presentation.subject,
+            body_text=presentation.body_text,
+            body_html=presentation.body_html,
+            local_date=today,
         )
-        subject, body = generate_briefing(prompt)
-        body = append_recent_sent_email_block(body)
-        write_latest_briefing(recipient=recipient or "[dry-run]", subject=subject, body=body)
 
         if args.dry_run:
-            print(json.dumps({"subject": subject, "body": body}, indent=2, ensure_ascii=False))
+            print(json.dumps({
+                "subject": presentation.subject,
+                "body": presentation.body_text,
+                "body_text": presentation.body_text,
+                "body_html": presentation.body_html,
+            }, indent=2, ensure_ascii=False))
             return 0
 
         log(f"Sending morning briefing to {recipient}...")
-        send_output = send_briefing(recipient=recipient, subject=subject, body=body)
-        _mark_morning_briefing_sent(today, recipient, subject=subject, send_output=send_output)
+        send_output = send_briefing(
+            recipient=recipient,
+            subject=presentation.subject,
+            body_text=presentation.body_text,
+            body_html=presentation.body_html,
+        )
+        _mark_morning_briefing_sent(
+            today,
+            recipient,
+            subject=presentation.subject,
+            body_text=presentation.body_text,
+            body_html=presentation.body_html,
+            send_output=send_output,
+            artifact_payload=artifact_payload,
+        )
         _clear_active_claim()
         save_state({
             "last_sent_date": today,
             "last_sent_at": datetime.now().astimezone().isoformat(),
             "last_recipient": recipient,
-            "last_subject": subject,
+            "last_subject": presentation.subject,
             "last_send_output": send_output,
         })
         log("Morning briefing sent.")