nexo-brain 7.28.0 → 7.30.0

package/src/automation_preferences.py

@@ -0,0 +1,367 @@
+"""Structured operator preferences for product automations."""
+
+from __future__ import annotations
+
+import copy
+import json
+import unicodedata
+from pathlib import Path
+from typing import Any
+
+
+AUTOMATION_PREFERENCES_METADATA_KEY = "automation_preferences"
+SUPPORTED_AUTOMATIONS = {"morning-agent"}
+
+
+MORNING_AGENT_SCHEMA: dict[str, Any] = {
+    "schema_version": 1,
+    "automation": "morning-agent",
+    "title": "Morning briefing content",
+    "groups": [
+        {
+            "id": "content",
+            "label": "Content",
+            "items": [
+                {
+                    "id": "priorities",
+                    "type": "boolean",
+                    "label": "Priorities",
+                    "default": True,
+                    "help": "The most important things NEXO thinks you should look at first.",
+                },
+                {
+                    "id": "agenda",
+                    "type": "boolean",
+                    "label": "Agenda",
+                    "default": True,
+                    "help": "Calendar-like items, dated work and events that affect today.",
+                },
+                {
+                    "id": "reminders",
+                    "type": "boolean",
+                    "label": "Reminders and tasks",
+                    "default": True,
+                    "help": "Pending reminders and tasks saved in NEXO.",
+                },
+                {
+                    "id": "followups",
+                    "type": "boolean",
+                    "label": "Follow-ups",
+                    "default": True,
+                    "help": "Open work that NEXO is tracking until it is resolved or clearly blocked.",
+                },
+                {
+                    "id": "decisions",
+                    "type": "boolean",
+                    "label": "Recent decisions",
+                    "default": True,
+                    "help": "Important decisions recorded recently so they are not forgotten.",
+                },
+                {
+                    "id": "email_activity",
+                    "type": "boolean",
+                    "label": "Recent sent email",
+                    "default": True,
+                    "help": "Emails NEXO sent recently, useful to know what moved while you were away.",
+                },
+                {
+                    "id": "blockers",
+                    "type": "boolean",
+                    "label": "Blockers and risks",
+                    "default": True,
+                    "help": "Things that may stop progress, need your decision or could become a problem.",
+                },
+                {
+                    "id": "internal_refs",
+                    "type": "boolean",
+                    "label": "Internal references",
+                    "default": False,
+                    "help": "Technical file names, IDs or internal references. Keep this off for a cleaner human summary.",
+                },
+                {
+                    "id": "news",
+                    "type": "boolean",
+                    "label": "News",
+                    "default": False,
+                    "help": "A short set of public headlines from the configured news feed. If the feed is unreachable, NEXO simply says it was unavailable.",
+                },
+                {
+                    "id": "weather",
+                    "type": "boolean",
+                    "label": "Weather",
+                    "default": True,
+                    "help": "Today's weather from the location saved in Desktop or your residence in the profile.",
+                },
+            ],
+        },
+        {
+            "id": "style",
+            "label": "Style",
+            "items": [
+                {
+                    "id": "length",
+                    "type": "choice",
+                    "label": "Length",
+                    "default": "normal",
+                    "options": ["short", "normal", "detailed"],
+                    "help": "How much detail the briefing should include.",
+                },
+                {
+                    "id": "tone",
+                    "type": "choice",
+                    "label": "Tone",
+                    "default": "direct",
+                    "options": ["direct", "warm", "executive", "personal"],
+                    "help": "How NEXO should write the summary.",
+                },
+                {
+                    "id": "format",
+                    "type": "choice",
+                    "label": "Format",
+                    "default": "sections",
+                    "options": ["sections", "bullets", "narrative"],
+                    "help": "How the briefing is organized visually.",
+                },
+            ],
+        },
+        {
+            "id": "delivery",
+            "label": "Delivery",
+            "items": [
+                {
+                    "id": "quiet_days",
+                    "type": "choice",
+                    "label": "Quiet days",
+                    "default": "summary_if_anything_important",
+                    "options": ["always_send", "summary_if_anything_important", "skip_if_empty"],
+                    "help": "What NEXO should do on days with little or no important activity.",
+                },
+            ],
+        },
+    ],
+}
+
+
+def _schema_for(name: str) -> dict[str, Any] | None:
+    clean = normalize_automation_name(name)
+    if clean == "morning-agent":
+        return copy.deepcopy(MORNING_AGENT_SCHEMA)
+    return None
+
+
+def normalize_automation_name(name: str) -> str:
+    return str(name or "").strip().lower().replace("_", "-")
+
+
+def supports_automation_preferences(name: str) -> bool:
+    return normalize_automation_name(name) in SUPPORTED_AUTOMATIONS
+
+
+def get_automation_preference_schema(name: str) -> dict[str, Any]:
+    schema = _schema_for(name)
+    if not schema:
+        return {
+            "schema_version": 1,
+            "automation": normalize_automation_name(name),
+            "title": "Automation content",
+            "groups": [],
+        }
+    return schema
+
+
+def _iter_schema_items(schema: dict[str, Any]):
+    for group in list(schema.get("groups") or []):
+        for item in list(group.get("items") or []):
+            if isinstance(item, dict) and item.get("id"):
+                yield item
+
+
+def default_automation_preferences(name: str) -> dict[str, Any]:
+    schema = get_automation_preference_schema(name)
+    values: dict[str, Any] = {}
+    for item in _iter_schema_items(schema):
+        values[str(item["id"])] = copy.deepcopy(item.get("default"))
+    return {
+        "schema_version": int(schema.get("schema_version") or 1),
+        "automation": normalize_automation_name(name),
+        "values": values,
+    }
+
+
+def validate_automation_preferences(name: str, payload: dict[str, Any] | None) -> dict[str, Any]:
+    schema = get_automation_preference_schema(name)
+    defaults = default_automation_preferences(name)
+    source_values = {}
+    if isinstance(payload, dict):
+        if isinstance(payload.get("values"), dict):
+            source_values = payload.get("values") or {}
+        else:
+            source_values = payload
+    values = dict(defaults["values"])
+    warnings: list[str] = []
+    for item in _iter_schema_items(schema):
+        key = str(item["id"])
+        if key not in source_values:
+            continue
+        if item.get("disabled"):
+            values[key] = copy.deepcopy(item.get("default"))
+            warnings.append(f"{key}: disabled")
+            continue
+        kind = str(item.get("type") or "text")
+        raw_value = source_values.get(key)
+        if kind == "boolean":
+            values[key] = bool(raw_value)
+        elif kind == "choice":
+            options = [str(v) for v in list(item.get("options") or [])]
+            clean = str(raw_value or "").strip()
+            if clean in options:
+                values[key] = clean
+            else:
+                warnings.append(f"{key}: invalid choice")
+        elif kind == "number":
+            try:
+                values[key] = int(raw_value)
+            except Exception:
+                warnings.append(f"{key}: invalid number")
+        else:
+            values[key] = str(raw_value or "").strip()[:1000]
+    return {
+        "schema_version": int(schema.get("schema_version") or 1),
+        "automation": normalize_automation_name(name),
+        "values": values,
+        "warnings": warnings,
+    }
+
+
+def _script_row_for(name_or_path: str) -> tuple[dict, dict] | tuple[None, None]:
+    from db import init_db
+    from db._personal_scripts import get_personal_script
+    from script_registry import resolve_script, sync_personal_scripts
+
+    init_db()
+    sync_personal_scripts()
+    script = get_personal_script(name_or_path, include_core=True) or resolve_script(name_or_path)
+    if not script and normalize_automation_name(name_or_path) == "morning-agent":
+        script_path = Path(__file__).resolve().parent / "scripts" / "nexo-morning-agent.py"
+        script = {
+            "name": "morning-agent",
+            "path": str(script_path),
+            "description": "Generate and send the operator's daily morning briefing email.",
+            "runtime": "python",
+            "core": True,
+            "metadata": {},
+            "origin": "core",
+        }
+    if not script:
+        return None, None
+    existing = get_personal_script(script.get("path", ""), include_core=True) or script
+    return script, existing
+
+
+def get_automation_preferences(name_or_path: str) -> dict[str, Any]:
+    clean_name = normalize_automation_name(name_or_path)
+    script, existing = _script_row_for(name_or_path)
+    if script:
+        clean_name = normalize_automation_name(script.get("name") or clean_name)
+    metadata = (existing or {}).get("metadata") if isinstance((existing or {}).get("metadata"), dict) else {}
+    stored = metadata.get(AUTOMATION_PREFERENCES_METADATA_KEY) if isinstance(metadata, dict) else {}
+    validated = validate_automation_preferences(clean_name, stored if isinstance(stored, dict) else {})
+    return {
+        "ok": True,
+        "name": clean_name,
+        "schema": get_automation_preference_schema(clean_name),
+        "preferences": validated,
+        "supports_automation_preferences": supports_automation_preferences(clean_name),
+    }
+
+
+def set_automation_preferences(name_or_path: str, payload: dict[str, Any]) -> dict[str, Any]:
+    from db._personal_scripts import upsert_personal_script
+
+    script, existing = _script_row_for(name_or_path)
+    if not script:
+        return {"ok": False, "error": f"Automation not found: {name_or_path}"}
+    clean_name = normalize_automation_name(script.get("name") or name_or_path)
+    if not supports_automation_preferences(clean_name):
+        return {"ok": False, "error": "This automation does not support structured preferences."}
+    validated = validate_automation_preferences(clean_name, payload)
+    metadata = dict((existing or script).get("metadata") or {})
+    metadata[AUTOMATION_PREFERENCES_METADATA_KEY] = {
+        "schema_version": validated["schema_version"],
+        "values": validated["values"],
+    }
+    script_origin = "core" if (bool(script.get("core")) or str(script.get("origin") or "") == "core") else "user"
+    upsert_personal_script(
+        name=script.get("name", clean_name),
+        path=script.get("path", ""),
+        description=script.get("description", ""),
+        runtime=script.get("runtime", "unknown"),
+        metadata=metadata,
+        created_by="nexo-core" if script_origin == "core" else "manual",
+        source="core-toggle" if script_origin == "core" else "filesystem",
+        origin=script_origin,
+        enabled=bool((existing or script).get("enabled", True)),
+        has_inline_metadata=bool(script.get("metadata")),
+    )
+    return {
+        "ok": True,
+        "name": clean_name,
+        "preferences": validated,
+        "supports_automation_preferences": True,
+    }
+
+
+def search_automation_preference_schema(name: str, query: str) -> list[dict[str, Any]]:
+    clean_query = _fold_text(query)
+    if not clean_query:
+        return []
+    matches: list[dict[str, Any]] = []
+    for group in list(get_automation_preference_schema(name).get("groups") or []):
+        for item in list(group.get("items") or []):
+            text = " ".join([
+                str(item.get("id") or ""),
+                str(item.get("label") or ""),
+                str(item.get("disabled_reason") or ""),
+                str(item.get("help") or ""),
+                str(group.get("label") or ""),
+            ])
+            if clean_query in _fold_text(text):
+                matches.append({"group": group.get("id"), **item})
+    return matches
+
+
+def _fold_text(value: str) -> str:
+    normalized = unicodedata.normalize("NFKD", str(value or ""))
+    asciiish = "".join(ch for ch in normalized if not unicodedata.combining(ch))
+    return asciiish.casefold()
+
+
+def format_automation_preferences_prompt_block(name_or_path: str) -> str:
+    result = get_automation_preferences(name_or_path)
+    if not result.get("supports_automation_preferences"):
+        return ""
+    prefs = result.get("preferences") or {}
+    values = prefs.get("values") if isinstance(prefs, dict) else {}
+    if not isinstance(values, dict):
+        values = {}
+    compact = json.dumps(values, ensure_ascii=False, sort_keys=True)
+    return (
+        "\n== STRUCTURED CONTENT PREFERENCES FOR THIS AUTOMATION ==\n"
+        f"{compact}\n"
+        "Use these preferences to decide what to include, omit, and emphasize. "
+        "Disabled/unavailable data sources must not be invented.\n"
+    )
+
+
+__all__ = [
+    "AUTOMATION_PREFERENCES_METADATA_KEY",
+    "default_automation_preferences",
+    "format_automation_preferences_prompt_block",
+    "get_automation_preference_schema",
+    "get_automation_preferences",
+    "normalize_automation_name",
+    "search_automation_preference_schema",
+    "set_automation_preferences",
+    "supports_automation_preferences",
+    "validate_automation_preferences",
+]

package/src/cli.py

@@ -1037,11 +1037,19 @@ def _automations_set_schedule(args):
         interval_seconds = int(args.every_seconds)
     elif getattr(args, "daily_at", None):
         daily_at = str(args.daily_at).strip()
+    if getattr(args, "weekdays", None) and not daily_at:
+        result = {"ok": False, "error": "--weekdays can only be used with --daily-at"}
+        if args.json:
+            print(json.dumps(result, indent=2, ensure_ascii=False))
+            return 1
+        print(result["error"], file=sys.stderr)
+        return 1
 
     result = set_automation_schedule(
         args.name,
         interval_seconds=interval_seconds,
         daily_at=daily_at,
+        weekdays=getattr(args, "weekdays", None),
         clear=bool(getattr(args, "reset", False)),
     )
     if args.json:
@@ -1059,6 +1067,89 @@ def _automations_set_schedule(args):
     return 0
 
 
+def _automations_preference_schema(args):
+    from automation_preferences import get_automation_preference_schema, search_automation_preference_schema
+
+    query = str(getattr(args, "query", "") or "").strip()
+    schema = get_automation_preference_schema(args.name)
+    payload = {
+        "ok": True,
+        "name": args.name,
+        "schema": schema,
+        "matches": search_automation_preference_schema(args.name, query) if query else [],
+    }
+    if args.json:
+        print(json.dumps(payload, indent=2, ensure_ascii=False))
+        return 0
+    print(schema.get("title") or args.name)
+    for group in list(schema.get("groups") or []):
+        print(f"\n{group.get('label') or group.get('id')}")
+        for item in list(group.get("items") or []):
+            marker = " (unavailable)" if item.get("disabled") else ""
+            print(f"  - {item.get('label') or item.get('id')}{marker}")
+    return 0
+
+
+def _automations_preferences(args):
+    from script_registry import get_automation_preference_contract, set_automation_preference_contract
+
+    has_payload = any([
+        str(getattr(args, "payload", "") or "").strip(),
+        str(getattr(args, "payload_file", "") or "").strip(),
+        bool(getattr(args, "payload_stdin", False)),
+    ])
+    if has_payload:
+        payload, error_code = _load_json_payload_arg(args, command_name="automations preferences")
+        if error_code is not None:
+            print(json.dumps(payload, indent=2, ensure_ascii=False))
+            return error_code
+        result = set_automation_preference_contract(args.name, payload)
+    else:
+        result = get_automation_preference_contract(args.name)
+    if args.json:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+        return 0 if result.get("ok", True) else 1
+    if not result.get("ok", True):
+        print(result.get("error", "Could not update automation preferences"), file=sys.stderr)
+        return 1
+    prefs = result.get("preferences") or {}
+    values = prefs.get("values") if isinstance(prefs, dict) else {}
+    print(f"Content preferences for {result.get('name') or args.name}:")
+    for key, value in sorted((values or {}).items()):
+        print(f"  {key}: {value}")
+    return 0
+
+
+def _morning_briefing(args):
+    from morning_briefing import latest_morning_briefing, mark_desktop_state
+
+    command = str(getattr(args, "morning_briefing_command", "") or "").strip()
+    if command == "latest":
+        result = latest_morning_briefing(include_non_sent=bool(getattr(args, "include_non_sent", False)))
+    elif command in {"mark-shown", "mark-opened", "mark-dismissed"}:
+        action = command.replace("mark-", "")
+        result = mark_desktop_state(action, briefing_id=getattr(args, "briefing_id", None))
+    else:
+        result = {"ok": False, "error": "Unknown morning briefing command."}
+
+    if getattr(args, "json", False):
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+        return 0 if result.get("ok", True) else 1
+    if not result.get("ok", True):
+        print(result.get("error", "Could not read morning briefing"), file=sys.stderr)
+        return 1
+    briefing = result.get("briefing")
+    if not briefing:
+        print("No morning briefing is available yet.")
+        return 0
+    print(briefing.get("subject") or "Morning briefing")
+    body = str(briefing.get("body_text") or "").strip()
+    if body:
+        print()
+        print(body)
+    return 0
+
+
 def _agents_list(args):
     from script_registry import list_agents
 
@@ -2529,6 +2620,28 @@ def _preferences(args):
         _load_user_default_resonance,
     )
 
+    action = str(getattr(args, "preferences_action", "") or "").strip().lower()
+    if action in {"catalog", "get", "set", "explain"}:
+        from preference_catalog import build_preference_catalog, explain_preference, set_preference
+
+        if action == "catalog":
+            payload = build_preference_catalog(
+                include_values=bool(getattr(args, "include_values", False)),
+                query=str(getattr(args, "query", "") or "").strip() or None,
+            )
+        elif action in {"get", "explain"}:
+            pref_id = str(getattr(args, "preferences_id", "") or "").strip()
+            payload = explain_preference(pref_id)
+        else:
+            pref_id = str(getattr(args, "preferences_id", "") or "").strip()
+            value = getattr(args, "preferences_value", None)
+            payload = set_preference(pref_id, value, dry_run=bool(getattr(args, "dry_run", False)))
+        if getattr(args, "json", False):
+            print(json.dumps(payload, indent=2, ensure_ascii=False))
+        else:
+            print(json.dumps(payload, ensure_ascii=False))
+        return 0 if payload.get("ok", True) else 1
+
     prefs = load_client_preferences()
     if not isinstance(prefs, dict):
         prefs = {}
@@ -4067,8 +4180,37 @@ def main():
     automations_schedule_group.add_argument("--every-seconds", type=int, help="Run the automation every N seconds")
     automations_schedule_group.add_argument("--daily-at", type=str, help="Run the automation every day at HH:MM (24h)")
     automations_schedule_group.add_argument("--reset", action="store_true", help="Restore the shipped default cadence")
+    automations_schedule_p.add_argument("--weekdays", default=None, help="Optional calendar days, e.g. Mon-Fri or Tue,Sat")
     automations_schedule_p.add_argument("--json", action="store_true", help="JSON output")
 
+    automations_schema_p = automations_sub.add_parser(
+        "preference-schema",
+        help="Read structured content options for an automation",
+    )
+    automations_schema_p.add_argument("name", help="Automation name or path")
+    automations_schema_p.add_argument("--query", default="", help="Local search inside the preference options")
+    automations_schema_p.add_argument("--json", action="store_true", help="JSON output")
+
+    automations_preferences_p = automations_sub.add_parser(
+        "preferences",
+        help="Read or update structured content preferences for an automation",
+    )
+    automations_preferences_p.add_argument("name", help="Automation name or path")
+    automations_preferences_p.add_argument("--payload", default="", help="JSON object to persist")
+    automations_preferences_p.add_argument("--payload-file", default="", help="Path to a JSON object to persist")
+    automations_preferences_p.add_argument("--payload-stdin", action="store_true", help="Read JSON object from stdin")
+    automations_preferences_p.add_argument("--json", action="store_true", help="JSON output")
+
+    morning_briefing_parser = sub.add_parser("morning-briefing", help="Read the latest operator morning briefing")
+    morning_briefing_sub = morning_briefing_parser.add_subparsers(dest="morning_briefing_command")
+    morning_latest_p = morning_briefing_sub.add_parser("latest", help="Show the latest sent morning briefing")
+    morning_latest_p.add_argument("--include-non-sent", action="store_true", help="Include failed/in-progress rows for diagnostics")
+    morning_latest_p.add_argument("--json", action="store_true", help="JSON output")
+    for mark_command in ("mark-shown", "mark-opened", "mark-dismissed"):
+        mark_p = morning_briefing_sub.add_parser(mark_command, help=f"{mark_command.replace('-', ' ')} for Desktop")
+        mark_p.add_argument("--id", dest="briefing_id", type=int, default=None, help="Specific briefing id")
+        mark_p.add_argument("--json", action="store_true", help="JSON output")
+
     core_schedules_parser = sub.add_parser("core-schedules", help="Manage structural core cron cadences")
     core_schedules_sub = core_schedules_parser.add_subparsers(dest="core_schedules_command")
 
@@ -4170,6 +4312,12 @@ def main():
         "preferences",
         help="Read or change NEXO user preferences (resonance, default client, ...)",
     )
+    preferences_parser.add_argument("preferences_action", nargs="?", choices=["catalog", "get", "set", "explain"], help="Catalog operation")
+    preferences_parser.add_argument("preferences_id", nargs="?", help="Preference id or alias")
+    preferences_parser.add_argument("preferences_value", nargs="?", help="Value for `preferences set`")
+    preferences_parser.add_argument("--query", default="", help="Filter catalog entries")
+    preferences_parser.add_argument("--include-values", action="store_true", help="Include current values in catalog output")
+    preferences_parser.add_argument("--dry-run", action="store_true", help="Preview a preference change")
     preferences_parser.add_argument(
         "--resonance",
         choices=["maximo", "alto", "medio", "bajo"],
@@ -4658,8 +4806,17 @@ def main():
             return _automations_set_instructions(args)
         elif args.automations_command == "schedule":
             return _automations_set_schedule(args)
+        elif args.automations_command == "preference-schema":
+            return _automations_preference_schema(args)
+        elif args.automations_command == "preferences":
+            return _automations_preferences(args)
         automations_parser.print_help()
         return 0
+    elif args.command == "morning-briefing":
+        if args.morning_briefing_command in {"latest", "mark-shown", "mark-opened", "mark-dismissed"}:
+            return _morning_briefing(args)
+        morning_briefing_parser.print_help()
+        return 0
     elif args.command == "core-schedules":
         if args.core_schedules_command == "list":
             return _core_schedules_list(args)