Skip to content

gerodp/hermes-productivity-skills / calendar/meeting-reminder

meeting-reminder

Flagged

Desktop reminder N minutes before each meeting starts, with a deep link to the matching Obsidian note (runs from hermes cron).

FileKindSize
SKILL.mdskill md8.7 KB
scripts/meeting_reminder.pyscript35.5 KB
scripts/test_meeting_reminder.pyscript21.0 KB

scripts/test_meeting_reminder.py

View on GitHub
#!/usr/bin/env python3
"""Offline unit tests for meeting_reminder — no subprocess, no network.

Calendar fetching and notification subprocesses are monkeypatched; the vault
and state file live in tempdirs. Run:  python3 test_meeting_reminder.py
"""
import argparse
import json
import os
import tempfile
import unittest
from datetime import datetime, timedelta, timezone
from unittest import mock

import meeting_reminder as mr

TZ = timezone(timedelta(hours=2))
NOW = datetime(2026, 7, 22, 16, 0, tzinfo=TZ)


def ev(id_, summary, start, location=""):
    return {"id": id_, "summary": summary, "start": start,
            "end": start, "location": location}


class TestMatching(unittest.TestCase):
    NOTES = [
        ("Notion/Acme/Weeklies con Alex.md", "Weeklies con Alex", 100.0),
        ("Notion/Acme/Weekly IA Viernes.md", "Weekly IA Viernes", 200.0),
        ("Notion/Personal/Gas.md", "Gas", 50.0),
        ("Reports/Weekly report.md", "Weekly report", 300.0),
    ]

    def test_exact_match_beats_containment(self):
        self.assertEqual(mr.match_note("Weeklies con Alex", self.NOTES),
                         "Notion/Acme/Weeklies con Alex.md")

    def test_accents_and_case_ignored(self):
        self.assertEqual(mr.match_note("WEEKLIES CON ÁLEX", self.NOTES),
                         "Notion/Acme/Weeklies con Alex.md")

    def test_containment_event_longer_than_note(self):
        self.assertEqual(mr.match_note("Weekly IA Viernes — Plan 2026", self.NOTES),
                         "Notion/Acme/Weekly IA Viernes.md")

    def test_stopwords_dont_match_alone(self):
        self.assertIsNone(mr.match_note("con la de", self.NOTES))

    def test_no_shared_tokens_no_match(self):
        self.assertIsNone(mr.match_note("Dentista", self.NOTES))

    def test_low_jaccard_rejected(self):
        # Shares only "weekly" with two multi-token notes → jaccard < 0.5,
        # no containment → no match.
        self.assertIsNone(
            mr.match_note("Weekly totally different thing here", self.NOTES))

    def test_tie_breaks_on_mtime(self):
        notes = [("A/Sync.md", "Sync", 10.0), ("B/Sync.md", "Sync", 20.0)]
        self.assertEqual(mr.match_note("Sync", notes), "B/Sync.md")

    def test_single_token_exact(self):
        self.assertEqual(mr.match_note("Gas", self.NOTES),
                         "Notion/Personal/Gas.md")

    def test_folder_path_tokens_beat_hub_note(self):
        notes = self.NOTES + [
            ("Notion/Acme/Acme.md", "Acme", 400.0),
            ("Notion/Acme/Acme 3.0/Kick-off, definición, diseño.md",
             "Kick-off, definición, diseño", 150.0),
        ]
        self.assertEqual(
            mr.match_note("Kick-off Acme 3.0", notes),
            "Notion/Acme/Acme 3.0/Kick-off, definición, diseño.md")

    def test_path_only_needs_full_coverage(self):
        notes = [("Notion/Acme/Acme 3.0/Agenda.md", "Agenda", 1.0)]
        # Whole title covered by folder tokens (≥2) → match…
        self.assertEqual(mr.match_note("Acme 3.0", notes),
                         "Notion/Acme/Acme 3.0/Agenda.md")
        # …but a single shared folder token is not enough.
        self.assertIsNone(mr.match_note("Coordinación temas Acme", notes))

    def test_override_wins_and_requires_existing_note(self):
        overrides = {mr.norm_key("Weeklies con Alex"): "Notion/Personal/Gas.md"}
        self.assertEqual(
            mr.match_note("Weeklies con Alex", self.NOTES, overrides),
            "Notion/Personal/Gas.md")
        # Override pointing at a deleted note falls back to scoring.
        gone = {mr.norm_key("Weeklies con Alex"): "Deleted/Nope.md"}
        self.assertEqual(
            mr.match_note("Weeklies con Alex", self.NOTES, gone),
            "Notion/Acme/Weeklies con Alex.md")

    def test_one_shared_word_of_three_is_not_enough(self):
        # "IA" appears in the basename and folder, but 2 of the 3 title words
        # are unexplained — must NOT latch onto a recent note sharing one word.
        notes = self.NOTES + [
            ("Notion/Acme/Plan IA 2026/Devkit Acme - Estandarizando.md",
             "Devkit Acme - Estandarizando", 500.0)]
        self.assertIsNone(mr.match_note("Coordinación temas IA", notes))

    def test_norm_key_stable_across_instances(self):
        self.assertEqual(mr.norm_key("Weekly IA Viernes"),
                         mr.norm_key("  WEEKLY ia viernés "))


class TestEventExcludes(unittest.TestCase):
    def test_substring_case_insensitive(self):
        ex = ["dentista", "Fisio"]
        self.assertTrue(mr.event_excluded("Revisión DENTISTA - Clínica", ex))
        self.assertTrue(mr.event_excluded("fisio 18:00", ex))
        self.assertFalse(mr.event_excluded("Weekly sync", ex))
        self.assertFalse(mr.event_excluded("Weekly sync", []))

    def test_resolve_precedence_cli_env_dotenv(self):
        with mock.patch.dict(mr.os.environ, {"CALENDAR_EXCLUDE": "a, b"}):
            self.assertEqual(mr.resolve_cal_excludes(), ["a", "b"])
            self.assertEqual(mr.resolve_cal_excludes("c"), ["c"])
        with mock.patch.dict(mr.os.environ, {}, clear=False), \
             mock.patch.object(mr, "_env_file_value",
                               lambda n: "x,y" if n == "CALENDAR_EXCLUDE" else None):
            mr.os.environ.pop("CALENDAR_EXCLUDE", None)
            self.assertEqual(mr.resolve_cal_excludes(), ["x", "y"])

    def test_scan_skips_excluded_event(self):
        with tempfile.TemporaryDirectory() as td:
            vault = os.path.join(td, "vault")
            os.makedirs(vault)
            state_path = os.path.join(td, "state.json")
            events = [ev("a", "Dentista anual", (NOW + timedelta(minutes=4)).isoformat()),
                      ev("b", "Sync", (NOW + timedelta(minutes=4)).isoformat())]
            args = argparse.Namespace(
                vault=vault, calendar="primary", gws_script=None, lead=5,
                dry_run=True, state=state_path, map_file=None,
                exclude_events="dentista", json=True)
            with mock.patch.object(mr, "fetch_events", lambda *a, **k: events), \
                 mock.patch.object(mr, "_local_now", lambda: NOW), \
                 mock.patch("sys.stdout") as out:
                self.assertEqual(mr.do_scan(args), 0)
            printed = "".join(c.args[0] for c in out.write.call_args_list)
            sent = json.loads(printed)["sent"]
            self.assertEqual([i["summary"] for i in sent], ["Sync"])


class TestMapAndResolve(unittest.TestCase):
    def _vault(self, td):
        vault = os.path.join(td, "vault")
        os.makedirs(os.path.join(vault, "Team"))
        os.makedirs(os.path.join(vault, "Other"))
        for rel in ("Team/Sync.md", "Other/Sync.md", "Roadmap.md"):
            with open(os.path.join(vault, rel), "w") as fh:
                fh.write("x")
        return vault

    def test_resolve_note_rel_name_and_ambiguity(self):
        with tempfile.TemporaryDirectory() as td:
            notes = mr.list_notes(self._vault(td))
            self.assertEqual(mr.resolve_note(notes, "Team/Sync.md"), "Team/Sync.md")
            self.assertEqual(mr.resolve_note(notes, "Roadmap"), "Roadmap.md")
            with self.assertRaises(mr.ReminderError):
                mr.resolve_note(notes, "Sync")          # ambiguous
            with self.assertRaises(mr.ReminderError):
                mr.resolve_note(notes, "Missing note")  # absent

    def test_map_set_list_rm_roundtrip(self):
        with tempfile.TemporaryDirectory() as td:
            vault = self._vault(td)
            map_file = os.path.join(td, "map.json")
            set_args = argparse.Namespace(action="set", title="Sprint Planning",
                                          note="Roadmap", spec_file=None,
                                          map_file=map_file, vault=vault,
                                          json=False)
            with mock.patch("sys.stdout"):
                self.assertEqual(mr.do_map(set_args), 0)
            overrides = mr.map_overrides(mr.load_map(map_file))
            self.assertEqual(overrides[mr.norm_key("Sprint Planning")],
                             "Roadmap.md")
            notes = mr.list_notes(vault)
            self.assertEqual(mr.match_note("Sprint Planning", notes, overrides),
                             "Roadmap.md")
            rm_args = argparse.Namespace(action="rm", title="sprint PLANNING",
                                         note=None, spec_file=None,
                                         map_file=map_file, vault=vault,
                                         json=False)
            with mock.patch("sys.stdout"):
                self.assertEqual(mr.do_map(rm_args), 0)
            self.assertEqual(mr.load_map(map_file), {})


class TestMapSpecFile(unittest.TestCase):
    def test_spec_file_carries_hostile_title_as_data(self):
        with tempfile.TemporaryDirectory() as td:
            vault = os.path.join(td, "vault")
            os.makedirs(vault)
            with open(os.path.join(vault, "Notes.md"), "w") as fh:
                fh.write("x")
            spec = os.path.join(td, "spec.json")
            title = "Sync $(rm -rf ~) `evil` \x1b"
            with open(spec, "w", encoding="utf-8") as fh:
                json.dump({"title": title, "note": "Notes"}, fh)
            map_file = os.path.join(td, "map.json")
            args = argparse.Namespace(action="set", title=None, note=None,
                                      spec_file=spec, map_file=map_file,
                                      vault=vault, json=False)
            with mock.patch("sys.stdout"):
                self.assertEqual(mr.do_map(args), 0)
            overrides = mr.map_overrides(mr.load_map(map_file))
            self.assertEqual(overrides[mr.norm_key(title)], "Notes.md")

    def test_spec_file_rejects_bad_json(self):
        with tempfile.NamedTemporaryFile("w", suffix=".json", delete=False) as fh:
            fh.write('["not", "a", "dict"]')
        try:
            args = argparse.Namespace(action="set", title=None, note=None,
                                      spec_file=fh.name, map_file=None,
                                      vault=None, json=False)
            with self.assertRaises(mr.ReminderError):
                mr.do_map(args)
        finally:
            os.unlink(fh.name)


class TestObsidianUri(unittest.TestCase):
    def test_encodes_vault_and_path(self):
        uri = mr.obsidian_uri("/tmp/My Vault", "Sub Dir/Nota título.md")
        self.assertTrue(uri.startswith("obsidian://open?vault=My%20Vault&file="))
        self.assertIn("Sub%20Dir/Nota%20t%C3%ADtulo", uri)
        self.assertNotIn(".md", uri)


class TestParseStart(unittest.TestCase):
    def test_all_day_is_none(self):
        self.assertIsNone(mr.parse_event_start("2026-07-22"))

    def test_z_suffix(self):
        dt = mr.parse_event_start("2026-07-22T14:00:00Z")
        self.assertEqual(dt.astimezone(timezone.utc).hour, 14)

    def test_garbage_is_none(self):
        self.assertIsNone(mr.parse_event_start("not-a-date"))
        self.assertIsNone(mr.parse_event_start(None))


class TestDueReminders(unittest.TestCase):
    def test_window_and_dedup(self):
        events = [
            ev("in5", "Soon", (NOW + timedelta(minutes=4)).isoformat()),
            ev("at-lead", "Edge", (NOW + timedelta(minutes=5)).isoformat()),
            ev("far", "Later", (NOW + timedelta(minutes=30)).isoformat()),
            ev("past", "Missed", (NOW - timedelta(minutes=10)).isoformat()),
            ev("grace", "JustStarted", (NOW - timedelta(seconds=30)).isoformat()),
            ev("seen", "Already", (NOW + timedelta(minutes=3)).isoformat()),
            ev("allday", "Offsite", "2026-07-22"),
        ]
        state = {mr.event_key(events[5]): NOW.isoformat()}
        due = mr.due_reminders(events, state, lead_min=5, now=NOW)
        ids = [e["id"] for e, _ in due]
        self.assertEqual(ids, ["grace", "in5", "at-lead"])  # sorted by start

    def test_empty(self):
        self.assertEqual(mr.due_reminders([], {}, lead_min=5, now=NOW), [])


class TestReminderPayload(unittest.TestCase):
    def test_payload_with_note_and_sanitization(self):
        notes = [("Team/Sync.md", "Sync", 1.0)]
        event = ev("x", "Sync\x1b[2Jevil", (NOW + timedelta(minutes=5)).isoformat(),
                   location="Zoom\x07")
        start = mr.parse_event_start(event["start"])
        title, body, uri, info = mr.reminder_payload(
            event, start, "/tmp/vault", notes, now=NOW)
        self.assertNotIn("\x1b", title + body)
        self.assertNotIn("\x07", body)
        self.assertEqual(info["minutes_until"], 5)
        self.assertEqual(info["note"], "Team/Sync.md")
        self.assertIn("obsidian://open?vault=vault&file=Team/Sync", uri)

    def test_payload_without_note(self):
        event = ev("y", "Dentista", (NOW + timedelta(seconds=20)).isoformat())
        start = mr.parse_event_start(event["start"])
        title, body, uri, info = mr.reminder_payload(event, start, "/tmp/v", [],
                                                     now=NOW)
        self.assertIsNone(uri)
        self.assertIn("no matching note", body)
        self.assertIn("now", title)


class TestState(unittest.TestCase):
    def test_roundtrip_and_prune(self):
        with tempfile.TemporaryDirectory() as td:
            path = os.path.join(td, "sub", "state.json")
            state = {"old|x": (NOW - timedelta(hours=72)).isoformat(),
                     "new|y": (NOW - timedelta(hours=1)).isoformat()}
            mr.save_state(path, state, now=NOW)
            loaded = mr.load_state(path)
            self.assertEqual(list(loaded), ["new|y"])

    def test_load_missing_or_corrupt(self):
        self.assertEqual(mr.load_state("/nonexistent/state.json"), {})
        with tempfile.NamedTemporaryFile("w", suffix=".json", delete=False) as fh:
            fh.write("{broken")
        try:
            self.assertEqual(mr.load_state(fh.name), {})
        finally:
            os.unlink(fh.name)


class TestListNotes(unittest.TestCase):
    def test_walk_skips_dotdirs_and_escaping_symlinks(self):
        with tempfile.TemporaryDirectory() as td:
            vault = os.path.join(td, "vault")
            os.makedirs(os.path.join(vault, "Sub"))
            os.makedirs(os.path.join(vault, ".obsidian"))
            outside = os.path.join(td, "outside.md")
            for p in (os.path.join(vault, "Top.md"),
                      os.path.join(vault, "Sub", "Nested.md"),
                      os.path.join(vault, ".obsidian", "Hidden.md"),
                      outside):
                with open(p, "w") as fh:
                    fh.write("x")
            os.symlink(outside, os.path.join(vault, "Escape.md"))
            rels = sorted(rel for rel, _, _ in mr.list_notes(vault))
            self.assertEqual(rels, ["Sub/Nested.md", "Top.md"])


class TestNotification(unittest.TestCase):
    def _run_capture(self, calls):
        def fake_run(argv, **kw):
            calls.append(argv)
            return mock.Mock(returncode=0, stderr="")
        return fake_run

    def test_terminal_notifier_gets_open_uri(self):
        calls = []
        with mock.patch.object(mr.shutil, "which",
                               lambda n: "/x/" + n if n == "terminal-notifier" else None), \
             mock.patch.object(mr.subprocess, "run", self._run_capture(calls)):
            backend = mr.send_notification("T", "B", "obsidian://open?vault=v&file=f")
        self.assertEqual(backend, "terminal-notifier")
        self.assertIn("-open", calls[0])
        self.assertIn("obsidian://open?vault=v&file=f", calls[0])

    def test_absolute_path_probe_when_which_fails(self):
        with mock.patch.object(mr.shutil, "which", lambda n: None), \
             mock.patch.object(mr, "_TN_PATHS", ("/fake/tn",)), \
             mock.patch.object(mr.os.path, "exists", lambda p: p == "/fake/tn"):
            self.assertEqual(mr.notifier_backend(), "terminal-notifier")
            self.assertEqual(mr._terminal_notifier(), "/fake/tn")

    def test_osascript_passes_text_as_argv(self):
        calls = []
        with mock.patch.object(mr.shutil, "which",
                               lambda n: "/x/osascript" if n == "osascript" else None), \
             mock.patch.object(mr, "_TN_PATHS", ()), \
             mock.patch.object(mr.subprocess, "run", self._run_capture(calls)):
            backend = mr.send_notification('Ti"tle', "Bo\x1bdy", "obsidian://x")
        self.assertEqual(backend, "osascript")
        argv = calls[0]
        # Untrusted text rides as trailing argv items, never inside -e source.
        self.assertEqual(argv[-2:], ["Bo dy", 'Ti"tle'])
        for src in argv[argv.index("-e"):-2:2]:
            self.assertNotIn("Ti", src)

    def test_no_backend_raises(self):
        with mock.patch.object(mr.shutil, "which", lambda n: None), \
             mock.patch.object(mr, "_TN_PATHS", ()), \
             mock.patch.object(mr.os.path, "exists", lambda p: False):
            with self.assertRaises(mr.ReminderError):
                mr.send_notification("T", "B")


class TestChildEnv(unittest.TestCase):
    def test_drops_gws_dirs_and_override(self):
        with tempfile.TemporaryDirectory() as td:
            gws_dir = os.path.join(td, "node-bin")
            clean_dir = os.path.join(td, "clean-bin")
            os.makedirs(gws_dir)
            os.makedirs(clean_dir)
            with open(os.path.join(gws_dir, "gws"), "w") as fh:
                fh.write("#!/bin/sh\n")
            path = os.pathsep.join([gws_dir, clean_dir])
            with mock.patch.dict(mr.os.environ,
                                 {"PATH": path, "HERMES_GWS_BIN": "/x/gws"}):
                env = mr._child_env()
            self.assertEqual(env["PATH"], clean_dir)
            self.assertNotIn("HERMES_GWS_BIN", env)

    def test_all_dirs_dropped_falls_back(self):
        with tempfile.TemporaryDirectory() as td:
            with open(os.path.join(td, "gws"), "w") as fh:
                fh.write("#!/bin/sh\n")
            with mock.patch.dict(mr.os.environ, {"PATH": td}):
                self.assertEqual(mr._child_env()["PATH"], "/usr/bin:/bin")


class TestEnvFileFallback(unittest.TestCase):
    def test_reads_quoted_value(self):
        with tempfile.NamedTemporaryFile("w", suffix=".env", delete=False) as fh:
            fh.write("# comment\nOTHER=1\nOBSIDIAN_VAULT='/tmp/My Vault'\n")
        try:
            self.assertEqual(
                mr._env_file_value("OBSIDIAN_VAULT", env_path=fh.name),
                "/tmp/My Vault")
            self.assertIsNone(mr._env_file_value("MISSING", env_path=fh.name))
        finally:
            os.unlink(fh.name)


class TestScanDryRun(unittest.TestCase):
    def test_dry_run_prints_and_writes_nothing(self):
        with tempfile.TemporaryDirectory() as td:
            vault = os.path.join(td, "vault")
            os.makedirs(vault)
            with open(os.path.join(vault, "Sync.md"), "w") as fh:
                fh.write("x")
            state_path = os.path.join(td, "state.json")
            events = [ev("a", "Sync", (NOW + timedelta(minutes=4)).isoformat())]
            args = argparse.Namespace(
                vault=vault, calendar="primary", gws_script=None, lead=5,
                dry_run=True, state=state_path, map_file=None,
                exclude_events=None, json=True)
            sent_notifications = []
            with mock.patch.object(mr, "fetch_events", lambda *a, **k: events), \
                 mock.patch.object(mr, "_local_now", lambda: NOW), \
                 mock.patch.object(mr, "send_notification",
                                   lambda *a, **k: sent_notifications.append(a)), \
                 mock.patch("sys.stdout") as out:
                rc = mr.do_scan(args)
            self.assertEqual(rc, 0)
            self.assertEqual(sent_notifications, [])
            self.assertFalse(os.path.exists(state_path))
            printed = "".join(c.args[0] for c in out.write.call_args_list)
            data = json.loads(printed)
            self.assertTrue(data["dry_run"])
            self.assertEqual(data["sent"][0]["note"], "Sync.md")

    def test_real_run_records_state(self):
        with tempfile.TemporaryDirectory() as td:
            vault = os.path.join(td, "vault")
            os.makedirs(vault)
            state_path = os.path.join(td, "state.json")
            events = [ev("a", "Sync", (NOW + timedelta(minutes=4)).isoformat())]
            args = argparse.Namespace(
                vault=vault, calendar="primary", gws_script=None, lead=5,
                dry_run=False, state=state_path, map_file=None,
                exclude_events=None, json=True)
            with mock.patch.object(mr, "fetch_events", lambda *a, **k: events), \
                 mock.patch.object(mr, "_local_now", lambda: NOW), \
                 mock.patch.object(mr, "send_notification",
                                   lambda *a, **k: "osascript"), \
                 mock.patch("sys.stdout"):
                self.assertEqual(mr.do_scan(args), 0)
                # Second scan: state dedupes, nothing sent.
                with mock.patch.object(mr, "send_notification",
                                       side_effect=AssertionError("resent")):
                    self.assertEqual(mr.do_scan(args), 0)
            self.assertIn(mr.event_key(events[0]), mr.load_state(state_path))


if __name__ == "__main__":
    unittest.main(verbosity=2)
planning-and-task-breakdownaddyosmani/agent-skillsBreaks work into ordered tasks. Use when you have a spec or clear requirements and need to break work into implementable tasks. Use when a task feels too large to start, when you need to estimate scope, or when parallel work is possible.Stars: 119kUpdated Claude CodeCodexVerifiedInstall
screenpipethedotmack/claude-memSearch screen and audio history recorded by Screenpipe and optionally save selected context into claude-mem. Use when the user asks to recall desktop activity, a meeting, or something seen in another app through Screenpipe.Stars: 118kUpdated Claude CodeCodexVerifiedInstall
contact-widgetnexu-io/open-designSelf-contained floating chat widget with welcome screen, social links, meeting button, and message input. Single HTML file, zero dependencies.Stars: 108kUpdated Claude CodeCodexVerifiedInstall
meeting-notesnexu-io/open-designMeeting notes page — title bar with attendees, agenda checklist, decisions block, action items table with owners + dates, and a "next meeting" footer. Use when the brief mentions "meeting notes", "minutes", "1:1 notes", "all-hands recap", or "会议纪要".Stars: 108kUpdated Claude CodeCodexVerifiedInstall