nanobot-runtime/skills/remind/scripts/remind_edit.py

#!/usr/bin/env python3
# /// script
# requires-python = ">=3.11"
# dependencies = ["croniter", "pyyaml"]
# ///
"""Deterministic CRUD for reminder.yaml.

CLI tool for LLM skills to create, list, and remove reminders atomically.
Never edits reminder.yaml directly — always writes to a .tmp file and renames.
"""

from __future__ import annotations

import argparse
import json
import os
import sys
from datetime import date, datetime
from pathlib import Path

import yaml
from croniter import croniter
from random_times import compute_fire_times

WORKSPACE = Path(__file__).resolve().parent.parent.parent.parent  # .../workspace
REMINDER_YAML = WORKSPACE / "reminder.yaml"


def _load() -> dict:
    if not REMINDER_YAML.exists():
        return {"reminders": []}
    data = yaml.safe_load(REMINDER_YAML.read_text(encoding="utf-8")) or {}
    if "reminders" not in data:
        data["reminders"] = []
    return data


def _save(data: dict) -> None:
    tmp = REMINDER_YAML.with_suffix(".yaml.tmp")
    tmp.write_text(
        yaml.safe_dump(data, allow_unicode=True, sort_keys=False, default_flow_style=False),
        encoding="utf-8",
    )
    os.replace(tmp, REMINDER_YAML)


def cmd_list(_args: argparse.Namespace) -> int:
    data = _load()
    print(json.dumps({"reminders": data["reminders"]}, ensure_ascii=False))
    return 0


def cmd_add(args: argparse.Namespace) -> int:
    text = (args.text or "").strip()
    if not text:
        print(json.dumps({"error": "text must not be empty"}), file=sys.stderr)
        return 1

    try:
        random_cfg = _build_random(args)
    except ValueError as exc:
        print(json.dumps({"error": str(exc)}), file=sys.stderr)
        return 1

    if not args.at and not args.cron and not random_cfg:
        print(json.dumps({"error": "provide --cron, --at, or --random-* options"}), file=sys.stderr)
        return 1

    item: dict = {"text": text}

    if args.at:
        for at_str in args.at:
            try:
                datetime.fromisoformat(at_str)
            except ValueError as exc:
                print(json.dumps({"error": f"invalid --at datetime: {exc}"}), file=sys.stderr)
                return 1
        if len(args.at) == 1:
            item["at"] = args.at[0]
        else:
            item["at_times"] = args.at

    if args.cron:
        for expr in args.cron:
            if not croniter.is_valid(expr):
                print(json.dumps({"error": f"invalid cron expression: {expr!r}"}), file=sys.stderr)
                return 1
        item["cron_exprs"] = args.cron

    if random_cfg:
        item["random"] = random_cfg

    data = _load()
    data["reminders"].append(item)
    _save(data)
    print(json.dumps({"added": item}, ensure_ascii=False))
    return 0


def _build_random(args: argparse.Namespace) -> dict | None:
    """Assemble and validate the random schedule block, or None if no --random-* flag given."""
    fields = {
        "times_per_day": args.random_times_per_day,
        "window": args.random_window,
        "days": args.random_days,
        "from": args.random_from,
        "until": args.random_until,
    }
    if all(value is None for value in fields.values()):
        return None
    if fields["times_per_day"] is None or fields["window"] is None:
        raise ValueError("random schedule needs --random-times-per-day and --random-window")

    cfg = {key: value for key, value in fields.items() if value is not None}
    compute_fire_times(date(2000, 1, 1), "validation", cfg)  # raises ValueError on a bad config
    return cfg


def cmd_remove(args: argparse.Namespace) -> int:
    keyword = (args.keyword or "").strip().lower()
    if not keyword:
        print(json.dumps({"error": "keyword must not be empty"}), file=sys.stderr)
        return 1

    data = _load()
    matches = [r for r in data["reminders"] if keyword in (r.get("text") or "").lower()]

    if len(matches) == 0:
        print(json.dumps({"error": "no match", "keyword": args.keyword}), file=sys.stderr)
        return 1

    if len(matches) > 1:
        print(
            json.dumps({"error": "ambiguous", "matches": [{"text": m["text"]} for m in matches]}, ensure_ascii=False),
            file=sys.stderr,
        )
        return 1

    removed = matches[0]
    data["reminders"] = [r for r in data["reminders"] if r is not removed]
    _save(data)
    print(json.dumps({"removed": removed}, ensure_ascii=False))
    return 0


def main() -> None:
    parser = argparse.ArgumentParser(description="CRUD for reminder.yaml")
    sub = parser.add_subparsers(dest="command", required=True)

    sub.add_parser("list", help="List all reminders as JSON")

    add_p = sub.add_parser("add", help="Add a new reminder")
    add_p.add_argument("--text", required=True, help="Reminder text")
    add_p.add_argument("--cron", action="append", metavar="EXPR", help="Cron expression (repeatable)")
    add_p.add_argument("--at", action="append", metavar="ISO_DATETIME", help="One-time datetime ISO 8601 (repeatable, combinable with --cron)")
    add_p.add_argument("--random-times-per-day", type=int, dest="random_times_per_day", metavar="N", help="Random schedule: fires per day")
    add_p.add_argument("--random-window", dest="random_window", metavar="HH:MM-HH:MM", help="Random schedule: daily time window")
    add_p.add_argument("--random-days", dest="random_days", metavar="DOW", help="Random schedule: cron day-of-week filter, e.g. '1-5' (optional)")
    add_p.add_argument("--random-from", dest="random_from", metavar="YYYY-MM-DD", help="Random schedule: start date, inclusive (optional)")
    add_p.add_argument("--random-until", dest="random_until", metavar="YYYY-MM-DD", help="Random schedule: end date, inclusive (optional)")

    remove_p = sub.add_parser("remove", help="Remove a reminder by keyword")
    remove_p.add_argument("--keyword", required=True, help="Substring to match against reminder text")

    args = parser.parse_args()
    dispatch = {"list": cmd_list, "add": cmd_add, "remove": cmd_remove}
    sys.exit(dispatch[args.command](args))


if __name__ == "__main__":
    main()