reminders

Instructions

Implementation Reference

• tools.ts:133-178 (schema)

  Defines the input schema and metadata for the 'reminders' tool, specifying supported operations: list, search, open, create, listById.

  const REMINDERS_TOOL: Tool = {
    name: "reminders",
    description: "Search, create, and open reminders in Apple Reminders app",
    inputSchema: {
      type: "object",
      properties: {
        operation: {
          type: "string",
          description: "Operation to perform: 'list', 'search', 'open', 'create', or 'listById'",
          enum: ["list", "search", "open", "create", "listById"]
        },
        searchText: {
          type: "string",
          description: "Text to search for in reminders (required for search and open operations)"
        },
        name: {
          type: "string",
          description: "Name of the reminder to create (required for create operation)"
        },
        listName: {
          type: "string",
          description: "Name of the list to create the reminder in (optional for create operation)"
        },
        listId: {
          type: "string",
          description: "ID of the list to get reminders from (required for listById operation)"
        },
        props: {
          type: "array",
          items: {
            type: "string"
          },
          description: "Properties to include in the reminders (optional for listById operation)"
        },
        notes: {
          type: "string",
          description: "Additional notes for the reminder (optional for create operation)"
        },
        dueDate: {
          type: "string",
          description: "Due date for the reminder in ISO format (optional for create operation)"
        }
      },
      required: ["operation"]
    }
  };

• tools.ts:308-308 (registration)

  Registers the REMINDERS_TOOL as part of the exported tools array.

  const tools = [CONTACTS_TOOL, NOTES_TOOL, MESSAGES_TOOL, MAIL_TOOL, REMINDERS_TOOL, WEB_SEARCH_TOOL, CALENDAR_TOOL, MAPS_TOOL];

• utils/reminders.ts:47-77 (helper)

  Helper function to retrieve reminders from a specific list by ID, corresponding to 'listById' operation.

  async function getRemindersFromListById(listId: string, props?: string[]): Promise<any[]> {
      return await run((args: { id: string, props?: string[] }) => {
          function main() {
              const reminders = Application('Reminders');
              const list = reminders.lists.byId(args.id).reminders;
              const props = args.props || [ 'name', 'body', 'id', 'completed', 'completionDate', 'creationDate', 
                              'dueDate', 'modificationDate', 'remindMeDate', 'priority' ];
              // We could traverse all reminders and for each one get the all the props.
              // This is more inefficient than calling '.name()' on the very reminder list. It requires
              // less function calls.
              const propFns: Record<string, any[]> = props.reduce((obj: Record<string, any[]>, prop: string) => {
                  obj[prop] = list[prop]();
                  return obj;
              }, {});
              const finalList = [];
  
              // Flatten the object {name: string[], id: string[]} to an array of form
              // [{name: string, id: string}, ..., {name: string, id: string}] which represents the list
              // of reminders
              for (let i = 0; i < (propFns.name?.length || 0); i++) {
                  const reminder = props.reduce((obj: Record<string, any>, prop: string) => {
                      obj[prop] = propFns[prop][i];
                      return obj;
                  }, {});
                  finalList.push(reminder)
              }
              return finalList;
          }
          return main();
      }, { id: listId, props });
  }

• utils/reminders.ts:130-162 (helper)

  Helper function to search reminders by text in name or body, for 'search' operation.

  async function searchReminders(searchText: string): Promise<Reminder[]> {
      const reminders = await run((searchText: string) => {
          const Reminders = Application('Reminders');
          const lists = Reminders.lists();
          let matchingReminders: Reminder[] = [];
          
          for (const list of lists) {
              // Search in reminder names and bodies
              const remindersInList = list.reminders.whose({
                  _or: [
                      {name: {_contains: searchText}},
                      {body: {_contains: searchText}}
                  ]
              })();
              
              if (remindersInList.length > 0) {
                  const mappedReminders = remindersInList.map((reminder: any) => ({
                      name: reminder.name(),
                      id: reminder.id(),
                      body: reminder.body() || "",
                      completed: reminder.completed(),
                      dueDate: reminder.dueDate() ? reminder.dueDate().toISOString() : null,
                      listName: list.name()
                  }));
                  matchingReminders = matchingReminders.concat(mappedReminders);
              }
          }
          
          return matchingReminders;
      }, searchText);
      
      return reminders as Reminder[];
  }

• utils/reminders.ts:172-214 (helper)

  Helper function to create a new reminder in a specified list, for 'create' operation.

  async function createReminder(name: string, listName: string = "Reminders", notes?: string, dueDate?: string): Promise<Reminder> {
      const result = await run((name: string, listName: string, notes: string | undefined, dueDate: string | undefined) => {
          const Reminders = Application('Reminders');
          
          // Find or create the list
          let list;
          const existingLists = Reminders.lists.whose({name: listName})();
          
          if (existingLists.length > 0) {
              list = existingLists[0];
          } else {
              // Create a new list if it doesn't exist
              list = Reminders.make({new: 'list', withProperties: {name: listName}});
          }
          
          // Create the reminder properties
          const reminderProps: any = {
              name: name
          };
          
          if (notes) {
              reminderProps.body = notes;
          }
          
          if (dueDate) {
              reminderProps.dueDate = new Date(dueDate);
          }
          
          // Create the reminder
          const newReminder = list.make({new: 'reminder', withProperties: reminderProps});
          
          return {
              name: newReminder.name(),
              id: newReminder.id(),
              body: newReminder.body() || "",
              completed: newReminder.completed(),
              dueDate: newReminder.dueDate() ? newReminder.dueDate().toISOString() : null,
              listName: list.name()
          };
      }, name, listName, notes, dueDate);
      
      return result as Reminder;
  }