tools.py

"""Hermes tools for nostrcalendar — in-memory enclave, singleton per session."""

from __future__ import annotations

import time
from typing import Any, Optional

from nostrcalendar import (
    AvailabilityRule,
    CalendarEnclave,
    CalendarEvent,
    DayOfWeek,
    TimeSlot,
    compute_free_slots,
)
from nostrkey.keys import npub_to_hex

from tools.registry import tool_error, tool_result

_enclave: Optional[CalendarEnclave] = None


def _require_enclave() -> CalendarEnclave:
    if _enclave is None:
        raise RuntimeError("Calendar not initialized. Call calendar_init first.")
    return _enclave


def _resolve_pubkey(npub_or_hex: str) -> str:
    s = (npub_or_hex or "").strip()
    if s.startswith("npub1"):
        return npub_to_hex(s)
    return s


def _day_from_str(s: str) -> DayOfWeek:
    return DayOfWeek[s.upper()]


# -----------------------------
# calendar_init
# -----------------------------

CALENDAR_INIT_SCHEMA = {
    "type": "function",
    "function": {
        "name": "calendar_init",
        "description": "Create the calendar enclave for this session. Held in module memory; restart clears it.",
        "parameters": {
            "type": "object",
            "properties": {
                "relay_url": {"type": "string", "description": "wss:// relay URL for publishing/querying events. Optional — can be set later via calendar_set_availability."},
            },
            "required": [],
        },
    },
}


def handle_calendar_init(args: dict[str, Any], **kw) -> str:
    global _enclave
    try:
        relay = args.get("relay_url") or ""
        _enclave = CalendarEnclave.create(relay_url=relay)
        return tool_result({"configured": _enclave.is_configured, "relay_url": relay or None})
    except Exception as e:
        return tool_error(f"calendar_init failed: {type(e).__name__}: {e}")


# -----------------------------
# calendar_set_availability
# -----------------------------

CALENDAR_SET_AVAILABILITY_SCHEMA = {
    "type": "function",
    "function": {
        "name": "calendar_set_availability",
        "description": "Set the working-hours rule. Slots is a map of weekday → list of {start,end} 24h time strings.",
        "parameters": {
            "type": "object",
            "properties": {
                "slots": {
                    "type": "object",
                    "description": "Map e.g. {\"MONDAY\": [{\"start\":\"09:00\",\"end\":\"17:00\"}], \"TUESDAY\": [...]}.",
                },
                "slot_duration_minutes": {"type": "integer", "default": 30},
                "buffer_minutes":        {"type": "integer", "default": 15},
                "max_per_day":           {"type": "integer", "default": 8},
                "timezone":              {"type": "string",  "description": "IANA timezone, e.g. 'America/Toronto'.", "default": "UTC"},
                "relay_url":             {"type": "string"},
            },
            "required": ["slots"],
        },
    },
}


def handle_calendar_set_availability(args: dict[str, Any], **kw) -> str:
    try:
        enclave = _require_enclave()
        raw = args.get("slots") or {}
        slots = {
            _day_from_str(day): [TimeSlot(start=w["start"], end=w["end"]) for w in windows]
            for day, windows in raw.items()
        }
        rule = AvailabilityRule(
            slots=slots,
            slot_duration_minutes=int(args.get("slot_duration_minutes", 30)),
            buffer_minutes=int(args.get("buffer_minutes", 15)),
            max_per_day=int(args.get("max_per_day", 8)),
            timezone=args.get("timezone") or "UTC",
        )
        relay = args.get("relay_url") or (enclave.relay_url if enclave.is_configured else None)
        if relay:
            enclave.configure(rule=rule, relay_url=relay)
        return tool_result({"days_configured": [d.name for d in slots.keys()], "timezone": rule.timezone})
    except Exception as e:
        return tool_error(f"calendar_set_availability failed: {type(e).__name__}: {e}")


# -----------------------------
# calendar_add_event
# -----------------------------

CALENDAR_ADD_EVENT_SCHEMA = {
    "type": "function",
    "function": {
        "name": "calendar_add_event",
        "description": "Add a calendar event to the enclave. Times are unix seconds.",
        "parameters": {
            "type": "object",
            "properties": {
                "d_tag":       {"type": "string",  "description": "Unique identifier for the event (replaceable)."},
                "title":       {"type": "string"},
                "start":       {"type": "integer", "description": "Unix seconds."},
                "end":         {"type": "integer", "description": "Unix seconds."},
                "description": {"type": "string"},
                "location":    {"type": "string"},
                "participants": {"type": "array", "items": {"type": "string"}, "description": "Hex pubkeys or npubs of participants."},
            },
            "required": ["d_tag", "title", "start", "end"],
        },
    },
}


def handle_calendar_add_event(args: dict[str, Any], **kw) -> str:
    try:
        enclave = _require_enclave()
        participants = [_resolve_pubkey(p) for p in (args.get("participants") or [])]
        event = CalendarEvent(
            d_tag=args["d_tag"],
            title=args["title"],
            start=int(args["start"]),
            end=int(args["end"]),
            description=args.get("description") or "",
            location=args.get("location") or "",
            participants=participants,
        )
        enclave.add_event(event)
        return tool_result({"added": event.d_tag, "event_count": enclave.event_count})
    except Exception as e:
        return tool_error(f"calendar_add_event failed: {type(e).__name__}: {e}")


# -----------------------------
# calendar_list_events
# -----------------------------

CALENDAR_LIST_EVENTS_SCHEMA = {
    "type": "function",
    "function": {
        "name": "calendar_list_events",
        "description": "Return all events currently held in the enclave.",
        "parameters": {"type": "object", "properties": {}, "required": []},
    },
}


def handle_calendar_list_events(args: dict[str, Any], **kw) -> str:
    try:
        enclave = _require_enclave()
        events = [
            {"d_tag": e.d_tag, "title": e.title, "start": e.start, "end": e.end,
             "description": e.description, "location": e.location, "participants": list(e.participants)}
            for e in enclave.events
        ]
        return tool_result({"count": len(events), "events": events})
    except Exception as e:
        return tool_error(f"calendar_list_events failed: {type(e).__name__}: {e}")


# -----------------------------
# calendar_free_slots
# -----------------------------

CALENDAR_FREE_SLOTS_SCHEMA = {
    "type": "function",
    "function": {
        "name": "calendar_free_slots",
        "description": "Compute free slots in [window_start, window_end] given availability rule + booked events.",
        "parameters": {
            "type": "object",
            "properties": {
                "window_start": {"type": "integer", "description": "Unix seconds."},
                "window_end":   {"type": "integer", "description": "Unix seconds."},
            },
            "required": ["window_start", "window_end"],
        },
    },
}


def handle_calendar_free_slots(args: dict[str, Any], **kw) -> str:
    try:
        enclave = _require_enclave()
        rule = enclave.rule
        if rule is None:
            return tool_error("availability rule not set — call calendar_set_availability first")
        slots = compute_free_slots(
            events=enclave.events,
            rule=rule,
            window_start=int(args["window_start"]),
            window_end=int(args["window_end"]),
        )
        return tool_result({
            "count": len(slots),
            "slots": [{"start": s[0], "end": s[1]} for s in slots],
        })
    except Exception as e:
        return tool_error(f"calendar_free_slots failed: {type(e).__name__}: {e}")