Topic 4: Host responsibilities

"""A consent prompt that shows what create_note will actually do: the file, and a diff."""
from __future__ import annotations

import difflib
import json
import re
import shutil
import tempfile
from collections.abc import Callable
from pathlib import Path
from typing import Any

import anyio

from mcp import Client

from m06_common import ROOT, ScriptedModel, notes_params
from notes_assistant.host import Host, console_approve
from notes_assistant.store import NoteError, NoteStore, slugify

HIDDEN = re.compile(r"[\u200b-\u200f\u202a-\u202e\u2060-\u2064]")  # zero-width and direction marks
URL = re.compile(r"https?://[^\s\u200b-\u200f\u202a-\u202e\u2060-\u2064]+")


def visible(text: str) -> str:
    """Make invisible characters visible, so the person sees what is really there."""
    return HIDDEN.sub(lambda m: f"<U+{ord(m.group()):04X}>", text)


def preview_create_note(notes_dir: Path, arguments: dict[str, Any]) -> list[str]:
    """Dry-run the real NoteStore on a scratch copy and return a unified diff plus warnings."""
    note_id = slugify(str(arguments.get("title", "")))
    lines = [f"Creates file: notes/{note_id}.md"]
    with tempfile.TemporaryDirectory() as scratch:
        shutil.copytree(notes_dir, scratch, dirs_exist_ok=True)
        try:
            note_path = NoteStore(scratch).create(arguments["title"], arguments["body"], arguments.get("tags", []))
            new_text = (Path(scratch) / f"{note_path.note_id}.md").read_text(encoding="utf-8")
        except (NoteError, KeyError) as exc:
            return lines + [f"WARNING: this call will fail: {exc}"]
    diff = difflib.unified_diff([], new_text.splitlines(), "/dev/null", f"notes/{note_id}.md", lineterm="")
    lines += [visible(line) for line in diff]
    body = str(arguments.get("body", ""))
    for url in URL.findall(body):
        lines.append(f"WARNING: the note contains a link: {url}")
    if HIDDEN.search(body):
        lines.append("WARNING: the note contains invisible characters.")
    return lines


def make_preview_approve(notes_dir: Path, answer: Callable[[str], str] = input) -> Callable[[str, dict[str, Any]], bool]:
    def approve(name: str, arguments: dict[str, Any]) -> bool:
        server, _, tool = name.partition("__")
        print(f"\n{server} wants to run {tool}.")
        if tool == "create_note":
            print("\n".join(preview_create_note(notes_dir, arguments)))
        else:
            for key, value in arguments.items():  # generic fallback: one readable line per argument
                print(f"  {key}: {value}")
        return answer("Allow? [y/N] ").strip().lower() == "y"
    return approve


BODY = (
    "Decision from the 2 September sync: 24 participants, not 16.\n"
    "Sleep lab booked for the weeks of 5 and 12 October.\n"
    "Consent form draft due 15 September (Nare).\n"
    "Protocol reference: https://example.org/nap-protocol\u200b"
)
ARGS = {"title": "Nap study plan", "body": BODY, "tags": ["sleep", "Nap Study"]}


async def main() -> None:
    print("=== console_approve (the Module 6 default) ===")
    console_approve("notes__create_note", ARGS)
    print("\n=== preview approve ===")
    with tempfile.TemporaryDirectory() as tmp:
        notes_dir = Path(tmp) / "notes"
        shutil.copytree(ROOT / "notes", notes_dir)
        approve = make_preview_approve(notes_dir, answer=lambda prompt: print(prompt + "y") or "y")
        model = ScriptedModel([[("notes__create_note", ARGS)], [("notes__create_note", ARGS)], "Saved."], verbose=False)
        async with Client(notes_params(notes_dir)) as notes:
            answer = await Host({"notes": notes}, chat_fn=model, approve=approve).ask("Save the nap study plan.")
        print(f"\n=> {[(c.name, c.ok, c.note) for c in answer.calls]}")
        print(f"files now: {sorted(p.name for p in notes_dir.glob('nap*'))}")


if __name__ == "__main__":
    anyio.run(main)