iris-chatbot 0.2.4

package/template/src/lib/tooling/tools/schedule.ts

@@ -0,0 +1,579 @@
+import { ensureMacOS } from "../safety";
+import { runCommandSafe } from "../runtime";
+import type { ToolDefinition, ToolExecutionContext } from "../types";
+
+type CalendarCreateInput = {
+  title?: string;
+  start?: string;
+  end?: string;
+  location?: string;
+  notes?: string;
+};
+
+type CalendarListInput = {
+  from?: string;
+  to?: string;
+  limit?: number;
+};
+
+type ReminderCreateInput = {
+  title?: string;
+  list?: string;
+  due?: string;
+  notes?: string;
+};
+
+type ReminderListInput = {
+  list?: string;
+  status?: "open" | "completed" | "all";
+};
+
+type DateTimeParts = {
+  year: number;
+  month: number;
+  day: number;
+  hour: number;
+  minute: number;
+};
+
+const APPLESCRIPT_TIMEOUT_MS = 30_000;
+const WEEKDAY_TO_INDEX: Record<string, number> = {
+  sunday: 0,
+  monday: 1,
+  tuesday: 2,
+  wednesday: 3,
+  thursday: 4,
+  friday: 5,
+  saturday: 6,
+};
+
+function asObject(input: unknown): Record<string, unknown> {
+  if (!input || typeof input !== "object") {
+    throw new Error("Tool input must be an object.");
+  }
+  return input as Record<string, unknown>;
+}
+
+function asString(input: unknown, field: string): string {
+  if (typeof input !== "string" || !input.trim()) {
+    throw new Error(`Missing required string field: ${field}`);
+  }
+  return input.trim();
+}
+
+function toDueParts(date: Date): DateTimeParts {
+  return {
+    year: date.getFullYear(),
+    month: date.getMonth() + 1,
+    day: date.getDate(),
+    hour: date.getHours(),
+    minute: date.getMinutes(),
+  };
+}
+
+function parseTimeOfDay(input: string): { hour: number; minute: number } | null {
+  const twelveHourMatch = input.match(/\b(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)\b/i);
+  if (twelveHourMatch) {
+    const hoursRaw = Number(twelveHourMatch[1]);
+    const minute = Number(twelveHourMatch[2] ?? "0");
+    if (!Number.isFinite(hoursRaw) || !Number.isFinite(minute) || minute < 0 || minute > 59) {
+      return null;
+    }
+    let hour = hoursRaw % 12;
+    if (twelveHourMatch[3].toLowerCase() === "pm") {
+      hour += 12;
+    }
+    return { hour, minute };
+  }
+
+  const twentyFourHourMatch = input.match(/\b(?:at\s+)?([01]?\d|2[0-3]):([0-5]\d)\b/);
+  if (twentyFourHourMatch) {
+    return {
+      hour: Number(twentyFourHourMatch[1]),
+      minute: Number(twentyFourHourMatch[2]),
+    };
+  }
+
+  return null;
+}
+
+function resolveRelativeDate(input: string, now: Date): Date | null {
+  const lower = input.toLowerCase().replace(/\bthis\s+upcoming\s+/g, "upcoming ");
+  const base = new Date(now);
+
+  if (/\btomorrow\b/.test(lower)) {
+    base.setDate(base.getDate() + 1);
+    return base;
+  }
+  if (/\btoday\b/.test(lower)) {
+    return base;
+  }
+
+  const weekdayMatch = lower.match(
+    /\b(?:(this|next|upcoming)\s+)?(sunday|monday|tuesday|wednesday|thursday|friday|saturday)\b/,
+  );
+  if (!weekdayMatch?.[2]) {
+    return null;
+  }
+
+  const modifier = weekdayMatch[1];
+  const targetDay = WEEKDAY_TO_INDEX[weekdayMatch[2]];
+  if (!Number.isFinite(targetDay)) {
+    return null;
+  }
+
+  let delta = (targetDay - base.getDay() + 7) % 7;
+  if (modifier === "next") {
+    if (delta === 0) {
+      delta = 7;
+    }
+  } else if (modifier !== "this" && delta === 0) {
+    delta = 7;
+  }
+
+  base.setDate(base.getDate() + delta);
+  return base;
+}
+
+function parseDateTimeParts(
+  input: string,
+  options?: { defaultHour?: number; defaultMinute?: number },
+): DateTimeParts | null {
+  const defaultHour = options?.defaultHour ?? 9;
+  const defaultMinute = options?.defaultMinute ?? 0;
+  const normalized = input.trim();
+  if (!normalized) {
+    return null;
+  }
+
+  const isoMatch = input.match(
+    /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::\d{2})?$/,
+  );
+  if (isoMatch) {
+    return {
+      year: Number(isoMatch[1]),
+      month: Number(isoMatch[2]),
+      day: Number(isoMatch[3]),
+      hour: Number(isoMatch[4]),
+      minute: Number(isoMatch[5]),
+    };
+  }
+
+  const dateOnlyMatch = normalized.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (dateOnlyMatch) {
+    return {
+      year: Number(dateOnlyMatch[1]),
+      month: Number(dateOnlyMatch[2]),
+      day: Number(dateOnlyMatch[3]),
+      hour: defaultHour,
+      minute: defaultMinute,
+    };
+  }
+
+  const isoOrSpaceMatch = normalized.match(
+    /^(\d{4})-(\d{2})-(\d{2})[ T](\d{2}):(\d{2})(?::\d{2})?(?:Z)?$/,
+  );
+  if (isoOrSpaceMatch) {
+    return {
+      year: Number(isoOrSpaceMatch[1]),
+      month: Number(isoOrSpaceMatch[2]),
+      day: Number(isoOrSpaceMatch[3]),
+      hour: Number(isoOrSpaceMatch[4]),
+      minute: Number(isoOrSpaceMatch[5]),
+    };
+  }
+
+  const parsed = new Date(normalized);
+  if (!Number.isNaN(parsed.getTime())) {
+    return toDueParts(parsed);
+  }
+
+  const now = new Date();
+  const timeOfDay = parseTimeOfDay(normalized);
+  const relativeDate = resolveRelativeDate(normalized, now);
+
+  if (timeOfDay && relativeDate) {
+    relativeDate.setHours(timeOfDay.hour, timeOfDay.minute, 0, 0);
+    return toDueParts(relativeDate);
+  }
+
+  if (timeOfDay) {
+    const candidate = new Date(now);
+    candidate.setHours(timeOfDay.hour, timeOfDay.minute, 0, 0);
+    if (candidate.getTime() < now.getTime() - 60_000) {
+      candidate.setDate(candidate.getDate() + 1);
+    }
+    return toDueParts(candidate);
+  }
+
+  if (relativeDate) {
+    relativeDate.setHours(defaultHour, defaultMinute, 0, 0);
+    return toDueParts(relativeDate);
+  }
+
+  return null;
+}
+
+function addMinutes(parts: DateTimeParts, minutesToAdd: number): DateTimeParts {
+  const value = new Date(
+    parts.year,
+    parts.month - 1,
+    parts.day,
+    parts.hour,
+    parts.minute,
+    0,
+    0,
+  );
+  value.setMinutes(value.getMinutes() + minutesToAdd);
+  return toDueParts(value);
+}
+
+async function runAppleScript(script: string, args: string[] = [], signal?: AbortSignal) {
+  const { stdout } = await runCommandSafe({
+    command: "osascript",
+    args: ["-e", script, ...args],
+    signal,
+    timeoutMs: APPLESCRIPT_TIMEOUT_MS,
+  });
+  return stdout;
+}
+
+async function runCalendarCreateEvent(input: unknown, context: ToolExecutionContext) {
+  ensureMacOS("Calendar automation");
+  const payload = asObject(input) as CalendarCreateInput;
+  const title = asString(payload.title, "title");
+  const start = asString(payload.start, "start");
+  const endInput = typeof payload.end === "string" && payload.end.trim() ? payload.end.trim() : "";
+  const end = endInput || start;
+  const location = typeof payload.location === "string" ? payload.location.trim() : "";
+  const notes = typeof payload.notes === "string" ? payload.notes.trim() : "";
+  const startParts = parseDateTimeParts(start, { defaultHour: 9, defaultMinute: 0 });
+  if (!startParts) {
+    throw new Error(`Invalid start date/time: ${start}`);
+  }
+  const endParts = endInput
+    ? parseDateTimeParts(endInput, {
+        defaultHour: startParts.hour,
+        defaultMinute: startParts.minute,
+      })
+    : addMinutes(startParts, 60);
+  if (!endParts) {
+    throw new Error(`Invalid end date/time: ${endInput}`);
+  }
+
+  if (context.localTools.dryRun) {
+    return {
+      dryRun: true,
+      action: "calendar_create_event",
+      title,
+      start,
+      end,
+      startParts,
+      endParts,
+      location,
+      notes,
+    };
+  }
+
+  const script =
+    'on run argv\n' +
+    'set eventTitle to item 1 of argv\n' +
+    'set startYear to (item 2 of argv) as integer\n' +
+    'set startMonth to (item 3 of argv) as integer\n' +
+    'set startDay to (item 4 of argv) as integer\n' +
+    'set startHour to (item 5 of argv) as integer\n' +
+    'set startMinute to (item 6 of argv) as integer\n' +
+    'set endYear to (item 7 of argv) as integer\n' +
+    'set endMonth to (item 8 of argv) as integer\n' +
+    'set endDay to (item 9 of argv) as integer\n' +
+    'set endHour to (item 10 of argv) as integer\n' +
+    'set endMinute to (item 11 of argv) as integer\n' +
+    'set eventLocation to item 12 of argv\n' +
+    'set eventNotes to item 13 of argv\n' +
+    'tell application "Calendar"\n' +
+    'set targetCalendar to missing value\n' +
+    'try\n' +
+    'set targetCalendar to calendar "Home"\n' +
+    'end try\n' +
+    'if targetCalendar is missing value then\n' +
+    'try\n' +
+    'set targetCalendar to first calendar\n' +
+    'end try\n' +
+    'end if\n' +
+    'if targetCalendar is missing value then error "No calendar is available."\n' +
+    'set startDate to current date\n' +
+    'set year of startDate to startYear\n' +
+    'set month of startDate to startMonth\n' +
+    'set day of startDate to startDay\n' +
+    'set time of startDate to ((startHour * hours) + (startMinute * minutes))\n' +
+    'set endDate to current date\n' +
+    'set year of endDate to endYear\n' +
+    'set month of endDate to endMonth\n' +
+    'set day of endDate to endDay\n' +
+    'set time of endDate to ((endHour * hours) + (endMinute * minutes))\n' +
+    'tell targetCalendar\n' +
+    'set createdEvent to make new event with properties {summary:eventTitle, start date:startDate, end date:endDate, location:eventLocation, description:eventNotes}\n' +
+    "end tell\n" +
+    'set calendarName to (name of targetCalendar as text)\n' +
+    "end tell\n" +
+    'return "created" & tab & calendarName\n' +
+    "end run";
+  const output = await runAppleScript(
+    script,
+    [
+      title,
+      String(startParts.year),
+      String(startParts.month),
+      String(startParts.day),
+      String(startParts.hour),
+      String(startParts.minute),
+      String(endParts.year),
+      String(endParts.month),
+      String(endParts.day),
+      String(endParts.hour),
+      String(endParts.minute),
+      location,
+      notes,
+    ],
+    context.signal,
+  );
+  const [, calendarName] = output.split("\t");
+  return {
+    created: true,
+    title,
+    start,
+    end,
+    startResolved: `${startParts.year}-${String(startParts.month).padStart(2, "0")}-${String(
+      startParts.day,
+    ).padStart(2, "0")}T${String(startParts.hour).padStart(2, "0")}:${String(
+      startParts.minute,
+    ).padStart(2, "0")}:00`,
+    endResolved: `${endParts.year}-${String(endParts.month).padStart(2, "0")}-${String(
+      endParts.day,
+    ).padStart(2, "0")}T${String(endParts.hour).padStart(2, "0")}:${String(
+      endParts.minute,
+    ).padStart(2, "0")}:00`,
+    calendar: calendarName?.trim() || null,
+    location,
+  };
+}
+
+async function runCalendarListEvents(input: unknown, context: ToolExecutionContext) {
+  ensureMacOS("Calendar automation");
+  const payload = asObject(input) as CalendarListInput;
+  const from = typeof payload.from === "string" && payload.from.trim() ? payload.from.trim() : "today";
+  const to = typeof payload.to === "string" && payload.to.trim() ? payload.to.trim() : "tomorrow";
+  const limit =
+    typeof payload.limit === "number" && Number.isFinite(payload.limit)
+      ? Math.max(1, Math.min(50, Math.floor(payload.limit)))
+      : 10;
+
+  const script =
+    'on run argv\n' +
+    'set fromText to item 1 of argv\n' +
+    'set toText to item 2 of argv\n' +
+    'set maxCount to (item 3 of argv) as integer\n' +
+    "set outText to \"\"\n" +
+    "set countItems to 0\n" +
+    'tell application "Calendar"\n' +
+    "set fromDate to date fromText\n" +
+    "set toDate to date toText\n" +
+    "repeat with cal in calendars\n" +
+    "repeat with e in (every event of cal whose start date is greater than or equal to fromDate and start date is less than or equal to toDate)\n" +
+    'set outText to outText & (summary of e as text) & tab & ((start date of e) as text) & tab & (name of cal as text) & linefeed\n' +
+    "set countItems to countItems + 1\n" +
+    "if countItems is greater than or equal to maxCount then return outText\n" +
+    "end repeat\n" +
+    "end repeat\n" +
+    "end tell\n" +
+    "return outText\n" +
+    "end run";
+  const output = await runAppleScript(script, [from, to, String(limit)], context.signal);
+  const entries = output
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      const [title, startAt, calendar] = line.split("\t");
+      return { title, startAt, calendar };
+    });
+
+  return { from, to, count: entries.length, entries };
+}
+
+async function runReminderCreate(input: unknown, context: ToolExecutionContext) {
+  ensureMacOS("Reminders automation");
+  const payload = asObject(input) as ReminderCreateInput;
+  const title = asString(payload.title, "title");
+  const list = typeof payload.list === "string" && payload.list.trim() ? payload.list.trim() : "Reminders";
+  const due = typeof payload.due === "string" ? payload.due.trim() : "";
+  const notes = typeof payload.notes === "string" ? payload.notes.trim() : "";
+  const dueParts = due ? parseDateTimeParts(due, { defaultHour: 9, defaultMinute: 0 }) : null;
+
+  if (context.localTools.dryRun) {
+    return {
+      dryRun: true,
+      action: "reminder_create",
+      title,
+      list,
+      due,
+      dueParts,
+      notes,
+    };
+  }
+
+  const script =
+    'on run argv\n' +
+    'set itemTitle to item 1 of argv\n' +
+    'set listName to item 2 of argv\n' +
+    'set dueFlag to item 3 of argv\n' +
+    'set dueYear to (item 4 of argv) as integer\n' +
+    'set dueMonth to (item 5 of argv) as integer\n' +
+    'set dueDay to (item 6 of argv) as integer\n' +
+    'set dueHour to (item 7 of argv) as integer\n' +
+    'set dueMinute to (item 8 of argv) as integer\n' +
+    'set dueText to item 9 of argv\n' +
+    'set noteText to item 10 of argv\n' +
+    'tell application "Reminders"\n' +
+    'set targetList to list listName\n' +
+    'set newReminder to make new reminder at end of reminders of targetList with properties {name:itemTitle, body:noteText}\n' +
+    'if dueFlag is "1" then\n' +
+    'set dueDateValue to current date\n' +
+    'set year of dueDateValue to dueYear\n' +
+    'set month of dueDateValue to dueMonth\n' +
+    'set day of dueDateValue to dueDay\n' +
+    'set time of dueDateValue to ((dueHour * hours) + (dueMinute * minutes))\n' +
+    'set due date of newReminder to dueDateValue\n' +
+    'else if dueText is not "" then\n' +
+    'set due date of newReminder to date dueText\n' +
+    'end if\n' +
+    'set dueOut to ""\n' +
+    'try\n' +
+    'set dueOut to (due date of newReminder as text)\n' +
+    'end try\n' +
+    "end tell\n" +
+    'return "created" & tab & dueOut\n' +
+    "end run";
+  const scriptArgs = [
+    title,
+    list,
+    dueParts ? "1" : "0",
+    String(dueParts?.year ?? 0),
+    String(dueParts?.month ?? 0),
+    String(dueParts?.day ?? 0),
+    String(dueParts?.hour ?? 0),
+    String(dueParts?.minute ?? 0),
+    due,
+    notes,
+  ];
+  const output = await runAppleScript(script, scriptArgs, context.signal);
+  const [, dueResolved] = output.split("\t");
+  return {
+    created: true,
+    title,
+    list,
+    due: due || null,
+    dueResolved: dueResolved?.trim() || null,
+  };
+}
+
+async function runReminderList(input: unknown, context: ToolExecutionContext) {
+  ensureMacOS("Reminders automation");
+  const payload = asObject(input) as ReminderListInput;
+  const list = typeof payload.list === "string" && payload.list.trim() ? payload.list.trim() : "Reminders";
+  const status = payload.status ?? "open";
+
+  const script =
+    'on run argv\n' +
+    'set listName to item 1 of argv\n' +
+    'set stateFilter to item 2 of argv\n' +
+    'set outText to ""\n' +
+    'tell application "Reminders"\n' +
+    'set targetList to list listName\n' +
+    'repeat with r in reminders of targetList\n' +
+    'set isDone to completed of r\n' +
+    'if stateFilter is "all" or (stateFilter is "open" and isDone is false) or (stateFilter is "completed" and isDone is true) then\n' +
+    'set outText to outText & (name of r as text) & tab & (isDone as text) & linefeed\n' +
+    'end if\n' +
+    'end repeat\n' +
+    'end tell\n' +
+    'return outText\n' +
+    'end run';
+  const output = await runAppleScript(script, [list, status], context.signal);
+  const entries = output
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      const [title, completed] = line.split("\t");
+      return { title, completed: completed === "true" };
+    });
+  return { list, status, count: entries.length, entries };
+}
+
+export const scheduleTools: ToolDefinition[] = [
+  {
+    name: "calendar_create_event",
+    description: "Create a Calendar event.",
+    inputSchema: {
+      type: "object",
+      required: ["title", "start"],
+      properties: {
+        title: { type: "string" },
+        start: { type: "string" },
+        end: { type: "string" },
+        location: { type: "string" },
+        notes: { type: "string" },
+      },
+      additionalProperties: false,
+    },
+    risk: "write",
+    execute: runCalendarCreateEvent,
+  },
+  {
+    name: "calendar_list_events",
+    description: "List calendar events in a time range.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        from: { type: "string" },
+        to: { type: "string" },
+        limit: { type: "number" },
+      },
+      additionalProperties: false,
+    },
+    risk: "read",
+    execute: runCalendarListEvents,
+  },
+  {
+    name: "reminder_create",
+    description: "Create a reminder item.",
+    inputSchema: {
+      type: "object",
+      required: ["title"],
+      properties: {
+        title: { type: "string" },
+        list: { type: "string" },
+        due: { type: "string" },
+        notes: { type: "string" },
+      },
+      additionalProperties: false,
+    },
+    risk: "write",
+    execute: runReminderCreate,
+  },
+  {
+    name: "reminder_list",
+    description: "List reminders by status.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        list: { type: "string" },
+        status: { type: "string", enum: ["open", "completed", "all"] },
+      },
+      additionalProperties: false,
+    },
+    risk: "read",
+    execute: runReminderList,
+  },
+];