totem-llm 0.1.0

package/server/utils/agents/aibitat/plugins/google-calendar/events/gcal-get-events.js

@@ -0,0 +1,159 @@
+const googleCalendarLib = require("../lib.js");
+
+module.exports.GCalGetEvents = {
+  name: "gcal-get-events",
+  plugin: function () {
+    return {
+      name: "gcal-get-events",
+      setup(aibitat) {
+        aibitat.function({
+          super: aibitat,
+          name: this.name,
+          description:
+            "Get calendar events within a date range, optionally filtered by search query. " +
+            "Returns event titles, times, and IDs. Use this for custom date ranges.",
+          examples: [
+            {
+              prompt: "Find all meetings next week",
+              call: JSON.stringify({
+                startDate: "2025-01-20T00:00:00",
+                endDate: "2025-01-27T23:59:59",
+                query: "meeting",
+                limit: 25,
+              }),
+            },
+            {
+              prompt: "Show events from January 1st to January 31st",
+              call: JSON.stringify({
+                startDate: "2025-01-01T00:00:00",
+                endDate: "2025-01-31T23:59:59",
+                limit: 50,
+              }),
+            },
+          ],
+          parameters: {
+            $schema: "http://json-schema.org/draft-07/schema#",
+            type: "object",
+            properties: {
+              startDate: {
+                type: "string",
+                description: "Start of date range in ISO datetime format.",
+              },
+              endDate: {
+                type: "string",
+                description: "End of date range in ISO datetime format.",
+              },
+              query: {
+                type: "string",
+                description: "Optional text to search for in events.",
+              },
+              calendarId: {
+                type: "string",
+                description:
+                  "Optional calendar ID. If omitted, uses the primary calendar.",
+              },
+              limit: {
+                type: "number",
+                description: "Max results to return (default 25, max 100).",
+                default: 25,
+              },
+            },
+            required: ["startDate", "endDate"],
+            additionalProperties: false,
+          },
+          handler: async function ({
+            startDate,
+            endDate,
+            query,
+            calendarId,
+            limit = 25,
+          }) {
+            try {
+              this.super.handlerProps.log(`Using the gcal-get-events tool.`);
+              this.super.introspect(
+                `${this.caller}: Fetching events from ${startDate} to ${endDate}${query ? ` matching "${query}"` : ""}...`
+              );
+
+              const result = await googleCalendarLib.getEvents(
+                startDate,
+                endDate,
+                calendarId,
+                query,
+                limit
+              );
+
+              if (!result.success) {
+                this.super.introspect(
+                  `${this.caller}: Failed to get events - ${result.error}`
+                );
+                return `Error getting events: ${result.error}`;
+              }
+
+              const { totalEvents, returnedEvents, events } = result.data;
+              this.super.introspect(
+                `${this.caller}: Found ${totalEvents} event(s), returning ${returnedEvents}`
+              );
+
+              if (totalEvents === 0) {
+                return `No events found between ${startDate} and ${endDate}${query ? ` matching "${query}"` : ""}.`;
+              }
+
+              const summaries = [];
+              const citations = [];
+              events.forEach((event, i) => {
+                let timeStr;
+                if (event.isAllDayEvent) {
+                  timeStr = `All day (${new Date(event.startDate).toLocaleDateString()})`;
+                } else {
+                  const startTime = new Date(event.startTime);
+                  const endTime = new Date(event.endTime);
+                  const dateStr = startTime.toLocaleDateString();
+                  const startTimeStr = startTime.toLocaleTimeString([], {
+                    hour: "2-digit",
+                    minute: "2-digit",
+                  });
+                  const endTimeStr = endTime.toLocaleTimeString([], {
+                    hour: "2-digit",
+                    minute: "2-digit",
+                  });
+                  timeStr = `${dateStr} ${startTimeStr} - ${endTimeStr}`;
+                }
+                const eventDetails =
+                  `${i + 1}. "${event.title}"\n` +
+                  `   ${timeStr}\n` +
+                  `   ID: ${event.eventId}` +
+                  (event.location ? `\n   Location: ${event.location}` : "");
+
+                summaries.push(eventDetails);
+                citations.push({
+                  id: `google-calendar-${event.eventId}`,
+                  title: event.title,
+                  text: eventDetails,
+                  chunkSource: `google-calendar://${event.eventId}`,
+                  score: null,
+                });
+              });
+
+              const summary = summaries.join("\n\n");
+              citations.forEach((c) => this.super.addCitation?.(c));
+
+              let response = `Found ${totalEvents} event(s)`;
+              if (returnedEvents < totalEvents) {
+                response += ` (showing ${returnedEvents})`;
+              }
+              response += `:\n\n${summary}`;
+
+              return response;
+            } catch (e) {
+              this.super.handlerProps.log(
+                `gcal-get-events error: ${e.message}`
+              );
+              this.super.introspect(`Error: ${e.message}`);
+              return `Error getting events: ${e.message}`;
+            }
+          },
+        });
+      },
+    };
+  },
+};

package/server/utils/agents/aibitat/plugins/google-calendar/events/gcal-get-upcoming-events.js

@@ -0,0 +1,249 @@
+const googleCalendarLib = require("../lib.js");
+
+/**
+ * Helper to compute date ranges for common time periods.
+ * @param {string} period - "today", "week", or "month"
+ * @returns {{startDate: string, endDate: string, label: string}}
+ */
+function getDateRangeForPeriod(period) {
+  const now = new Date();
+  const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+  let startDate, endDate, label;
+
+  switch (period.toLowerCase()) {
+    case "today":
+      startDate = new Date(today);
+      endDate = new Date(today);
+      endDate.setHours(23, 59, 59, 999);
+      label = "today";
+      break;
+
+    case "tomorrow":
+      startDate = new Date(today);
+      startDate.setDate(startDate.getDate() + 1);
+      endDate = new Date(startDate);
+      endDate.setHours(23, 59, 59, 999);
+      label = "tomorrow";
+      break;
+
+    case "week":
+    case "this week":
+      startDate = new Date(today);
+      endDate = new Date(today);
+      endDate.setDate(endDate.getDate() + 7);
+      endDate.setHours(23, 59, 59, 999);
+      label = "the next 7 days";
+      break;
+
+    case "next week":
+      startDate = new Date(today);
+      startDate.setDate(startDate.getDate() + 7);
+      endDate = new Date(startDate);
+      endDate.setDate(endDate.getDate() + 7);
+      endDate.setHours(23, 59, 59, 999);
+      label = "next week";
+      break;
+
+    case "month":
+    case "this month":
+      startDate = new Date(today);
+      endDate = new Date(today);
+      endDate.setDate(endDate.getDate() + 30);
+      endDate.setHours(23, 59, 59, 999);
+      label = "the next 30 days";
+      break;
+
+    case "next month":
+      startDate = new Date(today);
+      startDate.setDate(startDate.getDate() + 30);
+      endDate = new Date(startDate);
+      endDate.setDate(endDate.getDate() + 30);
+      endDate.setHours(23, 59, 59, 999);
+      label = "next month";
+      break;
+
+    default:
+      throw new Error(
+        `Invalid period: "${period}". Use "today", "tomorrow", "week", "this week", "next week", "month", "this month", or "next month".`
+      );
+  }
+
+  return {
+    startDate: startDate.toISOString(),
+    endDate: endDate.toISOString(),
+    label,
+  };
+}
+
+module.exports.GCalGetUpcomingEvents = {
+  name: "gcal-get-upcoming-events",
+  plugin: function () {
+    return {
+      name: "gcal-get-upcoming-events",
+      setup(aibitat) {
+        aibitat.function({
+          super: aibitat,
+          name: this.name,
+          description:
+            "Get upcoming calendar events using simple time period keywords. " +
+            "This is the preferred tool for common queries like 'what's on my calendar today?' " +
+            "Supports periods: 'today', 'tomorrow', 'week' (next 7 days), 'month' (next 30 days), " +
+            "'next week', and 'next month'. " +
+            "Automatically calculates the correct date range so you don't need to know the current date.",
+          examples: [
+            {
+              prompt: "What's on my calendar today?",
+              call: JSON.stringify({ period: "today" }),
+            },
+            {
+              prompt: "What meetings do I have this week?",
+              call: JSON.stringify({ period: "week", query: "meeting" }),
+            },
+            {
+              prompt: "Show me my schedule for the month",
+              call: JSON.stringify({ period: "month", limit: 50 }),
+            },
+            {
+              prompt: "What do I have tomorrow?",
+              call: JSON.stringify({ period: "tomorrow" }),
+            },
+            {
+              prompt: "Find all project events next week",
+              call: JSON.stringify({ period: "next week", query: "project" }),
+            },
+          ],
+          parameters: {
+            $schema: "http://json-schema.org/draft-07/schema#",
+            type: "object",
+            properties: {
+              period: {
+                type: "string",
+                description:
+                  "Time period to query. Options: 'today', 'tomorrow', 'week' (next 7 days), 'this week', 'next week', 'month' (next 30 days), 'this month', 'next month'.",
+                enum: [
+                  "today",
+                  "tomorrow",
+                  "week",
+                  "this week",
+                  "next week",
+                  "month",
+                  "this month",
+                  "next month",
+                ],
+              },
+              query: {
+                type: "string",
+                description: "Optional text to search for in events.",
+              },
+              calendarId: {
+                type: "string",
+                description:
+                  "Optional calendar ID. If omitted, uses the primary calendar.",
+              },
+              limit: {
+                type: "number",
+                description: "Max results to return (default 25, max 100).",
+                default: 25,
+              },
+            },
+            required: ["period"],
+            additionalProperties: false,
+          },
+          handler: async function ({ period, query, calendarId, limit = 25 }) {
+            try {
+              this.super.handlerProps.log(
+                `Using the gcal-get-upcoming-events tool.`
+              );
+
+              const { startDate, endDate, label } =
+                getDateRangeForPeriod(period);
+
+              this.super.introspect(
+                `${this.caller}: Fetching events for ${label}${query ? ` matching "${query}"` : ""}...`
+              );
+
+              const result = await googleCalendarLib.getEvents(
+                startDate,
+                endDate,
+                calendarId,
+                query,
+                limit
+              );
+
+              if (!result.success) {
+                this.super.introspect(
+                  `${this.caller}: Failed to get events - ${result.error}`
+                );
+                return `Error getting events: ${result.error}`;
+              }
+
+              const { totalEvents, returnedEvents, events } = result.data;
+              this.super.introspect(
+                `${this.caller}: Found ${totalEvents} event(s) for ${label}`
+              );
+
+              if (totalEvents === 0) {
+                return `No events scheduled for ${label}${query ? ` matching "${query}"` : ""}.`;
+              }
+
+              const summaries = [];
+              const citations = [];
+              events.forEach((event, i) => {
+                let timeStr;
+                if (event.isAllDayEvent) {
+                  timeStr = `All day (${new Date(event.startDate).toLocaleDateString()})`;
+                } else {
+                  const startTime = new Date(event.startTime);
+                  const endTime = new Date(event.endTime);
+                  const dateStr = startTime.toLocaleDateString();
+                  const startTimeStr = startTime.toLocaleTimeString([], {
+                    hour: "2-digit",
+                    minute: "2-digit",
+                  });
+                  const endTimeStr = endTime.toLocaleTimeString([], {
+                    hour: "2-digit",
+                    minute: "2-digit",
+                  });
+                  timeStr = `${dateStr} ${startTimeStr} - ${endTimeStr}`;
+                }
+                const eventDetails =
+                  `${i + 1}. "${event.title}"\n` +
+                  `   ${timeStr}\n` +
+                  `   ID: ${event.eventId}` +
+                  (event.location ? `\n   Location: ${event.location}` : "");
+
+                summaries.push(eventDetails);
+                citations.push({
+                  id: `google-calendar-${event.eventId}`,
+                  title: event.title,
+                  text: eventDetails,
+                  chunkSource: `google-calendar://${event.eventId}`,
+                  score: null,
+                });
+              });
+
+              const summary = summaries.join("\n\n");
+              citations.forEach((c) => this.super.addCitation?.(c));
+
+              let response = `Events for ${label}`;
+              if (returnedEvents < totalEvents) {
+                response += ` (${returnedEvents} of ${totalEvents})`;
+              } else {
+                response += ` (${totalEvents} total)`;
+              }
+              response += `:\n\n${summary}`;
+
+              return response;
+            } catch (e) {
+              this.super.handlerProps.log(
+                `gcal-get-upcoming-events error: ${e.message}`
+              );
+              this.super.introspect(`Error: ${e.message}`);
+              return `Error getting events: ${e.message}`;
+            }
+          },
+        });
+      },
+    };
+  },
+};

package/server/utils/agents/aibitat/plugins/google-calendar/events/gcal-quick-add.js

@@ -0,0 +1,114 @@
+const googleCalendarLib = require("../lib.js");
+
+module.exports.GCalQuickAdd = {
+  name: "gcal-quick-add",
+  plugin: function () {
+    return {
+      name: "gcal-quick-add",
+      setup(aibitat) {
+        aibitat.function({
+          super: aibitat,
+          name: this.name,
+          description:
+            "Create a calendar event from a natural language description. " +
+            "Google Calendar will parse the description to extract the event title, date, and time. " +
+            "Examples: 'Meeting with John tomorrow at 3pm', 'Dentist appointment on Friday at 10am'.",
+          examples: [
+            {
+              prompt: "Add a meeting with John tomorrow at 3pm",
+              call: JSON.stringify({
+                description: "Meeting with John tomorrow at 3pm",
+              }),
+            },
+            {
+              prompt: "Schedule lunch with Sarah next Tuesday at noon",
+              call: JSON.stringify({
+                description: "Lunch with Sarah next Tuesday at noon",
+              }),
+            },
+          ],
+          parameters: {
+            $schema: "http://json-schema.org/draft-07/schema#",
+            type: "object",
+            properties: {
+              description: {
+                type: "string",
+                description:
+                  "Natural language description of the event including title, date, and time.",
+              },
+              calendarId: {
+                type: "string",
+                description:
+                  "Optional calendar ID. If omitted, uses the primary calendar.",
+              },
+            },
+            required: ["description"],
+            additionalProperties: false,
+          },
+          handler: async function ({ description, calendarId }) {
+            try {
+              this.super.handlerProps.log(`Using the gcal-quick-add tool.`);
+
+              if (this.super.requestToolApproval) {
+                const approval = await this.super.requestToolApproval({
+                  skillName: this.name,
+                  payload: {
+                    description,
+                    calendarId,
+                  },
+                  description: `Create calendar event from: "${description}"`,
+                });
+                if (!approval.approved) {
+                  this.super.introspect(
+                    `${this.caller}: User rejected the ${this.name} request.`
+                  );
+                  return approval.message;
+                }
+              }
+
+              this.super.introspect(
+                `${this.caller}: Creating event from "${description}"...`
+              );
+
+              const result = await googleCalendarLib.quickAdd(
+                description,
+                calendarId
+              );
+
+              if (!result.success) {
+                this.super.introspect(
+                  `${this.caller}: Failed to create event - ${result.error}`
+                );
+                return `Error creating event: ${result.error}`;
+              }
+
+              const event = result.data.event;
+              this.super.introspect(
+                `${this.caller}: Created event "${event.title}"`
+              );
+
+              let timeInfo;
+              if (event.isAllDayEvent) {
+                timeInfo = `All-day event on ${new Date(event.startDate).toLocaleDateString()}`;
+              } else {
+                timeInfo = `${new Date(event.startTime).toLocaleString()} - ${new Date(event.endTime).toLocaleString()}`;
+              }
+
+              return (
+                `Event created successfully!\n\n` +
+                `Title: ${event.title}\n` +
+                `${timeInfo}\n` +
+                `Event ID: ${event.eventId}\n` +
+                `Calendar ID: ${event.calendarId}`
+              );
+            } catch (e) {
+              this.super.handlerProps.log(`gcal-quick-add error: ${e.message}`);
+              this.super.introspect(`Error: ${e.message}`);
+              return `Error creating event: ${e.message}`;
+            }
+          },
+        });
+      },
+    };
+  },
+};

package/server/utils/agents/aibitat/plugins/google-calendar/events/gcal-set-my-status.js

@@ -0,0 +1,125 @@
+const googleCalendarLib = require("../lib.js");
+
+module.exports.GCalSetMyStatus = {
+  name: "gcal-set-my-status",
+  plugin: function () {
+    return {
+      name: "gcal-set-my-status",
+      setup(aibitat) {
+        aibitat.function({
+          super: aibitat,
+          name: this.name,
+          description:
+            "Set your RSVP status for a calendar event. " +
+            "Use this to accept, decline, or tentatively accept meeting invitations.",
+          examples: [
+            {
+              prompt: "Accept the meeting invitation for event abc123",
+              call: JSON.stringify({ eventId: "abc123", status: "YES" }),
+            },
+            {
+              prompt: "Decline event xyz789",
+              call: JSON.stringify({ eventId: "xyz789", status: "NO" }),
+            },
+            {
+              prompt: "Mark myself as maybe for event def456",
+              call: JSON.stringify({ eventId: "def456", status: "MAYBE" }),
+            },
+          ],
+          parameters: {
+            $schema: "http://json-schema.org/draft-07/schema#",
+            type: "object",
+            properties: {
+              eventId: {
+                type: "string",
+                description: "The ID of the event to RSVP to.",
+              },
+              status: {
+                type: "string",
+                enum: ["YES", "NO", "MAYBE", "INVITED"],
+                description:
+                  "Your RSVP status: YES (accept), NO (decline), MAYBE (tentative), or INVITED (reset to invited).",
+              },
+              calendarId: {
+                type: "string",
+                description:
+                  "Optional calendar ID. If omitted, uses the primary calendar.",
+              },
+            },
+            required: ["eventId", "status"],
+            additionalProperties: false,
+          },
+          handler: async function ({ eventId, status, calendarId }) {
+            try {
+              this.super.handlerProps.log(`Using the gcal-set-my-status tool.`);
+
+              const statusActions = {
+                YES: "accept",
+                NO: "decline",
+                MAYBE: "tentatively accept",
+                INVITED: "reset to invited",
+              };
+
+              if (this.super.requestToolApproval) {
+                const approval = await this.super.requestToolApproval({
+                  skillName: this.name,
+                  payload: {
+                    eventId,
+                    status,
+                  },
+                  description: `Set RSVP status to ${status} (${statusActions[status] || status}) for event ${eventId}`,
+                });
+                if (!approval.approved) {
+                  this.super.introspect(
+                    `${this.caller}: User rejected the ${this.name} request.`
+                  );
+                  return approval.message;
+                }
+              }
+
+              this.super.introspect(
+                `${this.caller}: Setting RSVP status to ${status} for event ${eventId}...`
+              );
+
+              const result = await googleCalendarLib.setMyStatus(
+                eventId,
+                status,
+                calendarId
+              );
+
+              if (!result.success) {
+                this.super.introspect(
+                  `${this.caller}: Failed to set status - ${result.error}`
+                );
+                return `Error setting RSVP status: ${result.error}`;
+              }
+
+              this.super.introspect(
+                `${this.caller}: RSVP status set to ${result.data.newStatus}`
+              );
+
+              const statusMessages = {
+                YES: "accepted",
+                NO: "declined",
+                MAYBE: "marked as tentative",
+                INVITED: "reset to invited",
+              };
+
+              return (
+                `RSVP status updated!\n\n` +
+                `Event ID: ${result.data.eventId}\n` +
+                `Status: ${result.data.newStatus} (${statusMessages[result.data.newStatus] || result.data.newStatus})`
+              );
+            } catch (e) {
+              this.super.handlerProps.log(
+                `gcal-set-my-status error: ${e.message}`
+              );
+              this.super.introspect(`Error: ${e.message}`);
+              return `Error setting RSVP status: ${e.message}`;
+            }
+          },
+        });
+      },
+    };
+  },
+};