@rnsk/toolkits 0.0.1 → 0.0.3

package/dist/toolkits/google-calendar/tools/list-events.js

@@ -0,0 +1,46 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+export const listEvents = tool({
+    description: 'List upcoming events from the user\'s primary Google Calendar.',
+    inputSchema: z.object({
+        googleCalendarToken: z.string().describe('The Google Calendar access token'),
+        maxResults: z.number().optional().default(10).describe('Maximum number of events to return'),
+        timeMin: z.string().optional().describe('Lower bound (exclusive) for an event\'s end time to filter by (RFC3339 timestamp). Default is now.'),
+    }),
+    execute: async ({ googleCalendarToken, maxResults, timeMin }) => {
+        try {
+            const url = new URL('https://www.googleapis.com/calendar/v3/calendars/primary/events');
+            url.searchParams.append('maxResults', maxResults.toString());
+            url.searchParams.append('singleEvents', 'true');
+            url.searchParams.append('orderBy', 'startTime');
+            if (timeMin) {
+                url.searchParams.append('timeMin', timeMin);
+            }
+            else {
+                url.searchParams.append('timeMin', new Date().toISOString());
+            }
+            const response = await fetch(url.toString(), {
+                headers: {
+                    Authorization: `Bearer ${googleCalendarToken}`,
+                },
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to list events', details: error };
+            }
+            const data = await response.json();
+            return {
+                events: data.items || [],
+                summary: data.summary,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error listing events',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-events.js.map

package/dist/toolkits/google-calendar/tools/search-events.d.ts

@@ -0,0 +1,27 @@
+export declare const searchEvents: import("ai").Tool<{
+    maxResults: number;
+    googleCalendarToken: string;
+    calendarId: string;
+    q?: string | undefined;
+    timeMin?: string | undefined;
+    timeMax?: string | undefined;
+}, {
+    error: string;
+    details: any;
+    events?: undefined;
+    summary?: undefined;
+    message?: undefined;
+} | {
+    events: any;
+    summary: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    events?: undefined;
+    summary?: undefined;
+}>;
+//# sourceMappingURL=search-events.d.ts.map

package/dist/toolkits/google-calendar/tools/search-events.js

@@ -0,0 +1,49 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+export const searchEvents = tool({
+    description: 'Search for events in Google Calendar matching a free text query and/or date range.',
+    inputSchema: z.object({
+        googleCalendarToken: z.string().describe('The Google Calendar access token'),
+        q: z.string().optional().describe('Free text search terms to find events (e.g. "team sync", "meeting with Alice")'),
+        calendarId: z.string().optional().default('primary').describe('Calendar identifier. Default is "primary".'),
+        timeMin: z.string().optional().describe('Lower bound (exclusive) for event end times (RFC3339 timestamp)'),
+        timeMax: z.string().optional().describe('Upper bound (exclusive) for event start times (RFC3339 timestamp)'),
+        maxResults: z.number().optional().default(10).describe('Maximum number of events to return'),
+    }),
+    execute: async ({ googleCalendarToken, q, calendarId = 'primary', timeMin, timeMax, maxResults }) => {
+        try {
+            const url = new URL(`https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(calendarId)}/events`);
+            url.searchParams.append('maxResults', maxResults.toString());
+            url.searchParams.append('singleEvents', 'true');
+            url.searchParams.append('orderBy', 'startTime');
+            if (q)
+                url.searchParams.append('q', q);
+            if (timeMin)
+                url.searchParams.append('timeMin', timeMin);
+            if (timeMax)
+                url.searchParams.append('timeMax', timeMax);
+            const response = await fetch(url.toString(), {
+                headers: {
+                    Authorization: `Bearer ${googleCalendarToken}`,
+                },
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to search events', details: error };
+            }
+            const data = await response.json();
+            return {
+                events: data.items || [],
+                summary: data.summary,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error searching events',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=search-events.js.map

package/dist/toolkits/google-calendar/tools/update-event.d.ts

@@ -0,0 +1,29 @@
+export declare const updateEvent: import("ai").Tool<{
+    googleCalendarToken: string;
+    eventId: string;
+    calendarId: string;
+    description?: string | undefined;
+    location?: string | undefined;
+    summary?: string | undefined;
+    start?: string | undefined;
+    end?: string | undefined;
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    event?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    event: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    event?: undefined;
+}>;
+//# sourceMappingURL=update-event.d.ts.map

package/dist/toolkits/google-calendar/tools/update-event.js

@@ -0,0 +1,56 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+export const updateEvent = tool({
+    description: 'Update or reschedule an existing event in Google Calendar (e.g., change summary, start/end time, description, or location).',
+    inputSchema: z.object({
+        googleCalendarToken: z.string().describe('The Google Calendar access token'),
+        eventId: z.string().describe('The unique ID of the event to update'),
+        calendarId: z.string().optional().default('primary').describe('Calendar identifier. Default is "primary".'),
+        summary: z.string().optional().describe('New summary/title of the event'),
+        description: z.string().optional().describe('New description of the event'),
+        start: z.string().optional().describe('New start time (RFC3339 timestamp, e.g., 2026-09-10T10:00:00Z)'),
+        end: z.string().optional().describe('New end time (RFC3339 timestamp, e.g., 2026-09-10T11:00:00Z)'),
+        location: z.string().optional().describe('New location of the event'),
+    }),
+    execute: async ({ googleCalendarToken, eventId, calendarId = 'primary', summary, description, start, end, location }) => {
+        try {
+            const url = `https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(calendarId)}/events/${encodeURIComponent(eventId)}`;
+            const updatePayload = {};
+            if (summary !== undefined)
+                updatePayload.summary = summary;
+            if (description !== undefined)
+                updatePayload.description = description;
+            if (location !== undefined)
+                updatePayload.location = location;
+            if (start !== undefined)
+                updatePayload.start = { dateTime: start };
+            if (end !== undefined)
+                updatePayload.end = { dateTime: end };
+            const response = await fetch(url, {
+                method: 'PATCH',
+                headers: {
+                    Authorization: `Bearer ${googleCalendarToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(updatePayload),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to update event', details: error };
+            }
+            const data = await response.json();
+            return {
+                success: true,
+                event: data,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error updating event',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=update-event.js.map

package/dist/toolkits/google-sheets/icon.d.ts

@@ -0,0 +1,5 @@
+export declare const GSHEETS_ICON: {
+    kind: "svg";
+    dataUri: string;
+};
+//# sourceMappingURL=icon.d.ts.map