@access-mcp/events 0.2.0 → 0.3.0

package/dist/server.js

@@ -3,7 +3,7 @@ import axios from "axios";
 export class EventsServer extends BaseAccessServer {
     _eventsHttpClient;
     constructor() {
-        super("access-mcp-events", "0.2.0", "https://support.access-ci.org");
+        super("access-mcp-events", "0.3.0", "https://support.access-ci.org");
     }
     get httpClient() {
         if (!this._eventsHttpClient) {
@@ -26,172 +26,42 @@ export class EventsServer extends BaseAccessServer {
     }
     getTools() {
         return [
-            {
-                name: "get_events",
-                description: "Get ACCESS-CI events with comprehensive filtering capabilities. Returns events in UTC timezone with enhanced metadata.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        // Relative date filtering
-                        beginning_date_relative: {
-                            type: "string",
-                            description: "Start date using relative values. Calculated in UTC by default, or use 'timezone' parameter for local calculations.",
-                            enum: [
-                                "today",
-                                "+1week",
-                                "+2week",
-                                "+1month",
-                                "+2month",
-                                "+1year",
-                                "-1week",
-                                "-1month",
-                                "-1year",
-                            ],
-                        },
-                        end_date_relative: {
-                            type: "string",
-                            description: "End date using relative values. Calculated in UTC by default, or use 'timezone' parameter for local calculations.",
-                            enum: [
-                                "today",
-                                "+1week",
-                                "+2week",
-                                "+1month",
-                                "+2month",
-                                "+1year",
-                                "-1week",
-                                "-1month",
-                                "-1year",
-                            ],
-                        },
-                        // Absolute date filtering
-                        beginning_date: {
-                            type: "string",
-                            description: "Start date in YYYY-MM-DD or YYYY-MM-DD HH:MM:SS format. Always interpreted as provided (no timezone conversion).",
-                        },
-                        end_date: {
-                            type: "string",
-                            description: "End date in YYYY-MM-DD or YYYY-MM-DD HH:MM:SS format. Always interpreted as provided (no timezone conversion).",
-                        },
-                        // Timezone parameter for relative date calculations
-                        timezone: {
-                            type: "string",
-                            description: "Timezone for relative date calculations (default: UTC). Common values: UTC, America/New_York (Eastern), America/Chicago (Central), America/Denver (Mountain), America/Los_Angeles (Pacific), Europe/London (British), Europe/Berlin (CET). Only affects relative dates, not absolute dates. Invalid timezones default to UTC.",
-                            default: "UTC",
-                        },
-                        // Faceted search filters
-                        event_type: {
-                            type: "string",
-                            description: "Filter by event type (workshop, webinar, etc.)",
-                        },
-                        event_affiliation: {
-                            type: "string",
-                            description: "Filter by organizational affiliation (Community, ACCESS, etc.)",
-                        },
-                        skill_level: {
-                            type: "string",
-                            description: "Filter by required skill level (beginner, intermediate, advanced)",
-                            enum: ["beginner", "intermediate", "advanced"],
-                        },
-                        event_tags: {
-                            type: "string",
-                            description: "Filter by event tags (python, big-data, machine-learning, etc.)",
-                        },
-                        limit: {
-                            type: "number",
-                            description: "Maximum number of events to return (default: 100)",
-                            minimum: 1,
-                            maximum: 1000,
-                        },
-                    },
-                    required: [],
-                },
-            },
-            {
-                name: "get_upcoming_events",
-                description: "Get upcoming ACCESS-CI events (from today onward in UTC). Convenient shortcut for get_events with beginning_date_relative=today.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        limit: {
-                            type: "number",
-                            description: "Maximum number of events to return (default: 50)",
-                            minimum: 1,
-                            maximum: 100,
-                        },
-                        event_type: {
-                            type: "string",
-                            description: "Filter by event type (workshop, webinar, Office Hours, Training, etc.)",
-                        },
-                        timezone: {
-                            type: "string",
-                            description: "Timezone for 'today' calculation (default: UTC). Use user's local timezone for better relevance.",
-                            default: "UTC",
-                        },
-                    },
-                    required: [],
-                },
-            },
             {
                 name: "search_events",
-                description: "Search events using API's native full-text search. Searches across titles, descriptions, speakers, tags, location, and event type. Much more powerful than tag filtering.",
+                description: "Search ACCESS-CI events (workshops, webinars, training). Returns {total, items}.",
                 inputSchema: {
                     type: "object",
                     properties: {
                         query: {
                             type: "string",
-                            description: "Search query (case-insensitive). Use spaces for multiple words (e.g., 'machine learning', 'office hours'). Searches across all event content including descriptions.",
+                            description: "Search titles, descriptions, speakers, tags"
                         },
-                        beginning_date_relative: {
+                        type: {
                             type: "string",
-                            description: "Start date using relative values (default: today). Use '-1month' or '-1year' to search past events, or omit for all-time search.",
-                            default: "today",
+                            description: "Filter: workshop, webinar, training"
                         },
-                        timezone: {
+                        tags: {
                             type: "string",
-                            description: "Timezone for relative date calculation (default: UTC)",
-                            default: "UTC",
+                            description: "Filter: python, gpu, hpc, ml"
                         },
-                        limit: {
-                            type: "number",
-                            description: "Maximum number of events to return (default: 25)",
-                            minimum: 1,
-                            maximum: 100,
-                        },
-                    },
-                    required: ["query"],
-                },
-            },
-            {
-                name: "get_events_by_tag",
-                description: "Get events filtered by specific tags. Useful for finding events on topics like 'python', 'ai', 'machine-learning', 'gpu', etc.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        tag: {
-                            type: "string",
-                            description: "Event tag to filter by. Common tags: python, ai, machine-learning, gpu, deep-learning, neural-networks, big-data, hpc, jetstream, neocortex",
-                        },
-                        time_range: {
+                        date: {
                             type: "string",
-                            description: "Time range for events (upcoming=today onward, this_week=next 7 days, this_month=next 30 days, all=no date filter)",
-                            enum: ["upcoming", "this_week", "this_month", "all"],
-                            default: "upcoming",
+                            description: "Filter by time period",
+                            enum: ["today", "upcoming", "past", "this_week", "this_month"]
                         },
-                        timezone: {
+                        skill: {
                             type: "string",
-                            description: "Timezone for time_range calculations (default: UTC)",
-                            default: "UTC",
+                            description: "Skill level filter",
+                            enum: ["beginner", "intermediate", "advanced"]
                         },
                         limit: {
                             type: "number",
-                            description: "Maximum number of events to return (default: 25)",
-                            minimum: 1,
-                            maximum: 100,
-                        },
-                    },
-                    required: ["tag"],
-                },
-            },
+                            description: "Max results (default: 50)",
+                            default: 50
+                        }
+                    }
+                }
+            }
         ];
     }
     getResources() {
@@ -226,119 +96,80 @@ export class EventsServer extends BaseAccessServer {
         const { name, arguments: args = {} } = request.params;
         try {
             switch (name) {
-                case "get_events":
-                    return await this.getEvents(args);
-                case "get_upcoming_events":
-                    return await this.getUpcomingEvents(args);
                 case "search_events":
                     return await this.searchEvents(args);
-                case "get_events_by_tag":
-                    return await this.getEventsByTag(args);
                 default:
-                    throw new Error(`Unknown tool: ${name}`);
+                    return this.errorResponse(`Unknown tool: ${name}`);
             }
         }
         catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error: ${handleApiError(error)}`,
-                    },
-                ],
-            };
+            return this.errorResponse(handleApiError(error));
         }
     }
     async handleResourceRead(request) {
         const { uri } = request.params;
         switch (uri) {
             case "accessci://events":
-                const allEvents = await this.getEvents({});
-                return {
-                    contents: [
-                        {
-                            uri,
-                            mimeType: "application/json",
-                            text: allEvents.content[0].text,
-                        },
-                    ],
-                };
+                const allEvents = await this.searchEvents({});
+                return this.createJsonResource(uri, JSON.parse(allEvents.content[0].text));
             case "accessci://events/upcoming":
-                const upcomingEvents = await this.getUpcomingEvents({});
-                return {
-                    contents: [
-                        {
-                            uri,
-                            mimeType: "application/json",
-                            text: upcomingEvents.content[0].text,
-                        },
-                    ],
-                };
+                const upcomingEvents = await this.searchEvents({ date: "upcoming" });
+                return this.createJsonResource(uri, JSON.parse(upcomingEvents.content[0].text));
             case "accessci://events/workshops":
-                const workshops = await this.getEvents({ event_type: "workshop" });
-                return {
-                    contents: [
-                        {
-                            uri,
-                            mimeType: "application/json",
-                            text: workshops.content[0].text,
-                        },
-                    ],
-                };
+                const workshops = await this.searchEvents({ type: "workshop" });
+                return this.createJsonResource(uri, JSON.parse(workshops.content[0].text));
             case "accessci://events/webinars":
-                const webinars = await this.getEvents({ event_type: "webinar" });
-                return {
-                    contents: [
-                        {
-                            uri,
-                            mimeType: "application/json",
-                            text: webinars.content[0].text,
-                        },
-                    ],
-                };
+                const webinars = await this.searchEvents({ type: "webinar" });
+                return this.createJsonResource(uri, JSON.parse(webinars.content[0].text));
             default:
                 throw new Error(`Unknown resource: ${uri}`);
         }
     }
     buildEventsUrl(params) {
-        const url = new URL("/api/2.1/events", this.baseURL);
-        // Add full-text search parameter (API native search)
-        if (params.search_api_fulltext) {
-            url.searchParams.set("search_api_fulltext", params.search_api_fulltext);
-        }
-        // Add date filtering parameters
-        if (params.beginning_date_relative) {
-            url.searchParams.set("beginning_date_relative", params.beginning_date_relative);
-        }
-        if (params.end_date_relative) {
-            url.searchParams.set("end_date_relative", params.end_date_relative);
-        }
-        if (params.beginning_date) {
-            url.searchParams.set("beginning_date", params.beginning_date);
-        }
-        if (params.end_date) {
-            url.searchParams.set("end_date", params.end_date);
-        }
-        // Add timezone parameter for relative date calculations
-        if (params.timezone) {
-            url.searchParams.set("timezone", params.timezone);
+        const url = new URL("/api/2.2/events", this.baseURL);
+        const limit = params.limit || 50;
+        let itemsPerPage = 50;
+        if (limit >= 100)
+            itemsPerPage = 100;
+        else if (limit >= 75)
+            itemsPerPage = 75;
+        else if (limit >= 50)
+            itemsPerPage = 50;
+        else if (limit >= 25)
+            itemsPerPage = 25;
+        else
+            itemsPerPage = 25;
+        url.searchParams.set("items_per_page", String(itemsPerPage));
+        if (params.query) {
+            url.searchParams.set("search_api_fulltext", params.query);
+        }
+        // Map universal 'date' to API params
+        const dateMap = {
+            today: { start: "today" },
+            upcoming: { start: "today" },
+            past: { start: "-1year", end: "today" },
+            this_week: { start: "today", end: "+1week" },
+            this_month: { start: "today", end: "+1month" }
+        };
+        if (params.date && dateMap[params.date]) {
+            const dateMapping = dateMap[params.date];
+            url.searchParams.set("beginning_date_relative", dateMapping.start);
+            if (dateMapping.end) {
+                url.searchParams.set("end_date_relative", dateMapping.end);
+            }
         }
-        // Add faceted search filters
+        // Faceted filters
         let filterIndex = 0;
-        if (params.event_type) {
-            url.searchParams.set(`f[${filterIndex}]`, `custom_event_type:${params.event_type}`);
+        if (params.type) {
+            url.searchParams.set(`f[${filterIndex}]`, `custom_event_type:${params.type}`);
             filterIndex++;
         }
-        if (params.event_affiliation) {
-            url.searchParams.set(`f[${filterIndex}]`, `custom_event_affiliation:${params.event_affiliation}`);
+        if (params.tags) {
+            url.searchParams.set(`f[${filterIndex}]`, `custom_event_tags:${params.tags}`);
             filterIndex++;
         }
-        if (params.skill_level) {
-            url.searchParams.set(`f[${filterIndex}]`, `skill_level:${params.skill_level}`);
-            filterIndex++;
-        }
-        if (params.event_tags) {
-            url.searchParams.set(`f[${filterIndex}]`, `custom_event_tags:${params.event_tags}`);
+        if (params.skill) {
+            url.searchParams.set(`f[${filterIndex}]`, `skill_level:${params.skill}`);
             filterIndex++;
         }
         return url.toString();
@@ -347,157 +178,40 @@ export class EventsServer extends BaseAccessServer {
         const url = this.buildEventsUrl(params);
         const response = await this.httpClient.get(url);
         if (response.status !== 200) {
-            throw new Error(`Events API returned ${response.status}: ${response.statusText}`);
+            throw new Error(`API error ${response.status}`);
         }
         let events = response.data || [];
-        // Apply limit if specified
         if (params.limit && events.length > params.limit) {
             events = events.slice(0, params.limit);
         }
-        // Enhance events with additional metadata
         const enhancedEvents = events.map((event) => ({
             ...event,
-            // Parse dates for better handling
-            start_date: new Date(event.date),
-            end_date: event.date_1 ? new Date(event.date_1) : null,
-            // Split tags into array
-            tags: event.custom_event_tags
-                ? event.custom_event_tags.split(",").map((tag) => tag.trim())
-                : [],
-            // Calculate duration if both dates present
-            duration_hours: event.date_1
-                ? Math.round((new Date(event.date_1).getTime() -
-                    new Date(event.date).getTime()) /
-                    (1000 * 60 * 60))
+            tags: Array.isArray(event.tags) ? event.tags : [],
+            duration_hours: event.end_date
+                ? Math.round((new Date(event.end_date).getTime() - new Date(event.start_date).getTime()) / 3600000)
                 : null,
-            // Relative timing
-            starts_in_hours: Math.max(0, Math.round((new Date(event.date).getTime() - Date.now()) / (1000 * 60 * 60))),
+            starts_in_hours: Math.max(0, Math.round((new Date(event.start_date).getTime() - Date.now()) / 3600000))
         }));
-        const summary = {
-            total_events: enhancedEvents.length,
-            upcoming_events: enhancedEvents.filter((e) => e.starts_in_hours >= 0)
-                .length,
-            events_this_week: enhancedEvents.filter((e) => e.starts_in_hours <= 168 && e.starts_in_hours >= 0).length,
-            api_info: {
-                endpoint_version: "2.1",
-                timezone_handling: "All timestamps in UTC (Z suffix). Relative dates calculated using timezone parameter (default: UTC).",
-                timezone_used: params.timezone || "UTC",
-            },
-            event_types: [
-                ...new Set(enhancedEvents.map((e) => e.event_type).filter(Boolean)),
-            ],
-            affiliations: [
-                ...new Set(enhancedEvents.map((e) => e.event_affiliation).filter(Boolean)),
-            ],
-            skill_levels: [
-                ...new Set(enhancedEvents.map((e) => e.skill_level).filter(Boolean)),
-            ],
-            popular_tags: this.getPopularTags(enhancedEvents),
-            events: enhancedEvents,
-        };
         return {
-            content: [
-                {
+            content: [{
                     type: "text",
-                    text: JSON.stringify(summary, null, 2),
-                },
-            ],
-        };
-    }
-    async getUpcomingEvents(params) {
-        const upcomingParams = {
-            ...params,
-            beginning_date_relative: "today",
-            limit: params.limit || 50,
-            // Pass through timezone if provided
-            ...(params.timezone && { timezone: params.timezone }),
+                    text: JSON.stringify({
+                        total: enhancedEvents.length,
+                        items: enhancedEvents
+                    })
+                }]
         };
-        return this.getEvents(upcomingParams);
     }
     async searchEvents(params) {
-        // Use API's native full-text search instead of client-side filtering
-        const searchParams = {
-            search_api_fulltext: params.query,
-            beginning_date_relative: params.beginning_date_relative || "today",
-            limit: params.limit || 25,
-            // Pass through timezone if provided
-            ...(params.timezone && { timezone: params.timezone }),
-        };
-        // Use the API's native search capabilities
-        const eventsResponse = await this.getEvents(searchParams);
-        const eventsData = JSON.parse(eventsResponse.content[0].text);
-        // API returns already filtered results, no need for client-side filtering
-        const summary = {
-            search_query: params.query,
-            total_matches: eventsData.total_events,
-            search_method: "API native full-text search",
-            search_scope: "titles, descriptions, speakers, tags, location, event type",
-            events: eventsData.events,
-        };
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(summary, null, 2),
-                },
-            ],
-        };
-    }
-    async getEventsByTag(params) {
-        const { tag, time_range = "upcoming", limit = 25, timezone } = params;
-        let dateParams = {};
-        switch (time_range) {
-            case "upcoming":
-                dateParams.beginning_date_relative = "today";
-                break;
-            case "this_week":
-                dateParams.beginning_date_relative = "today";
-                dateParams.end_date_relative = "+1week";
-                break;
-            case "this_month":
-                dateParams.beginning_date_relative = "today";
-                dateParams.end_date_relative = "+1month";
-                break;
-            case "all":
-                // No date restrictions
-                break;
+        // Validate enum parameters
+        const validDateValues = ["today", "upcoming", "past", "this_week", "this_month"];
+        const validSkillValues = ["beginner", "intermediate", "advanced"];
+        if (params.date && !validDateValues.includes(params.date)) {
+            return this.errorResponse(`Invalid date value: '${params.date}'`, `Valid values are: ${validDateValues.join(", ")}`);
         }
-        const taggedParams = {
-            ...dateParams,
-            event_tags: tag,
-            limit,
-            // Pass through timezone if provided
-            ...(timezone && { timezone }),
-        };
-        const eventsResponse = await this.getEvents(taggedParams);
-        const eventsData = JSON.parse(eventsResponse.content[0].text);
-        const summary = {
-            tag: tag,
-            time_range: time_range,
-            total_events: eventsData.events.length,
-            events: eventsData.events,
-        };
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(summary, null, 2),
-                },
-            ],
-        };
-    }
-    getPopularTags(events) {
-        const tagCounts = {};
-        events.forEach((event) => {
-            if (event.tags) {
-                event.tags.forEach((tag) => {
-                    tagCounts[tag] = (tagCounts[tag] || 0) + 1;
-                });
-            }
-        });
-        return Object.entries(tagCounts)
-            .sort(([, a], [, b]) => b - a)
-            .slice(0, 10)
-            .map(([tag]) => tag);
+        if (params.skill && !validSkillValues.includes(params.skill)) {
+            return this.errorResponse(`Invalid skill value: '${params.skill}'`, `Valid values are: ${validSkillValues.join(", ")}`);
+        }
+        return await this.getEvents(params);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@access-mcp/events",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "ACCESS-CI Events MCP Server - Get information about workshops, webinars, and training events",
   "type": "module",
   "main": "dist/index.js",
@@ -19,7 +19,7 @@
     "test:coverage": "vitest run --coverage --exclude '**/**.integration.test.ts'"
   },
   "dependencies": {
-    "@access-mcp/shared": "file:../shared",
+    "@access-mcp/shared": "^0.3.3",
     "@modelcontextprotocol/sdk": "^0.5.0",
     "axios": "^1.7.0"
   },