@access-mcp/announcements 0.1.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@access-mcp/announcements",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "MCP server for ACCESS Support Announcements API",
   "type": "module",
   "main": "dist/index.js",
@@ -26,7 +26,7 @@
   "author": "ACCESS-CI",
   "license": "MIT",
   "dependencies": {
-    "@access-mcp/shared": "file:../shared",
+    "@access-mcp/shared": "^0.5.0",
     "@modelcontextprotocol/sdk": "^0.5.0",
     "axios": "^1.7.0"
   },
@@ -35,4 +35,4 @@
     "typescript": "^5.0.0",
     "vitest": "^1.0.0"
   }
-}
+}

package/src/index.ts

@@ -3,25 +3,9 @@
 import { AnnouncementsServer } from "./server.js";
 
 async function main() {
-  // Check if we should run as HTTP server (for deployment)
-  const port = process.env.PORT;
-
   const server = new AnnouncementsServer();
-  
-  if (port) {
-    // Running in HTTP mode (deployment)
-    await server.start({ httpPort: parseInt(port) });
-    // Keep the process running in HTTP mode
-    process.on('SIGINT', () => {
-      console.log('Shutting down server...');
-      process.exit(0);
-    });
-    // Keep the event loop alive
-    setInterval(() => {}, 1000 * 60 * 60); // Heartbeat every hour
-  } else {
-    // Running in MCP mode (stdio)
-    await server.start();
-  }
+  const port = process.env.PORT ? parseInt(process.env.PORT, 10) : undefined;
+  await server.start(port ? { httpPort: port } : undefined);
 }
 
 main().catch((error) => {

package/src/server.integration.test.ts

@@ -1,6 +1,18 @@
-import { describe, it, expect } from "vitest";
+import { describe, it, expect, beforeEach } from "vitest";
 import { AnnouncementsServer } from "./server.js";
 
+interface TextContent {
+  type: "text";
+  text: string;
+}
+
+interface AnnouncementItem {
+  title: string;
+  body: string;
+  published_date: string;
+  tags: string[];
+}
+
 /**
  * Integration tests for AnnouncementsServer
  * These tests make actual API calls to the ACCESS Support API
@@ -15,33 +27,31 @@ describe("AnnouncementsServer Integration Tests", () => {
   describe("get_announcements", () => {
     it("should fetch real announcements from API", async () => {
       const result = await server["handleToolCall"]({
+        method: "tools/call",
         params: {
-          name: "get_announcements",
+          name: "search_announcements",
           arguments: {
             limit: 5,
           },
         },
-      } as any);
+      });
 
       expect(result.isError).toBeFalsy();
-      const responseData = JSON.parse(result.content[0].text);
+      const responseData = JSON.parse((result.content[0] as TextContent).text);
       
       // Check structure
-      expect(responseData).toHaveProperty("total_announcements");
-      expect(responseData).toHaveProperty("announcements");
-      expect(responseData).toHaveProperty("popular_tags");
-      expect(responseData).toHaveProperty("filters_applied");
-      
-      // Announcements should be an array
-      expect(Array.isArray(responseData.announcements)).toBe(true);
+      expect(responseData).toHaveProperty("total");
+      expect(responseData).toHaveProperty("items");
+
+      // Items should be an array
+      expect(Array.isArray(responseData.items)).toBe(true);
       
       // If there are announcements, check their structure
-      if (responseData.announcements.length > 0) {
-        const firstAnnouncement = responseData.announcements[0];
+      if (responseData.items.length > 0) {
+        const firstAnnouncement = responseData.items[0];
         expect(firstAnnouncement).toHaveProperty("title");
         expect(firstAnnouncement).toHaveProperty("body");
-        expect(firstAnnouncement).toHaveProperty("date");
-        expect(firstAnnouncement).toHaveProperty("formatted_date");
+        expect(firstAnnouncement).toHaveProperty("published_date");
         expect(firstAnnouncement).toHaveProperty("tags");
         expect(Array.isArray(firstAnnouncement.tags)).toBe(true);
       }
@@ -49,25 +59,26 @@ describe("AnnouncementsServer Integration Tests", () => {
 
     it("should filter by tags", async () => {
       const result = await server["handleToolCall"]({
+        method: "tools/call",
         params: {
-          name: "get_announcements_by_tags",
+          name: "search_announcements",
           arguments: {
             tags: "maintenance",
             limit: 3,
           },
         },
-      } as any);
+      });
 
       expect(result.isError).toBeFalsy();
-      const responseData = JSON.parse(result.content[0].text);
-      
-      expect(responseData).toHaveProperty("announcements");
-      expect(Array.isArray(responseData.announcements)).toBe(true);
-      
+      const responseData = JSON.parse((result.content[0] as TextContent).text);
+
+      expect(responseData).toHaveProperty("items");
+      expect(Array.isArray(responseData.items)).toBe(true);
+
       // If maintenance announcements exist, they should contain the tag
-      if (responseData.announcements.length > 0) {
-        const hasMaintenanceTag = responseData.announcements.some((ann: any) => 
-          ann.tags && ann.tags.some((tag: string) => 
+      if (responseData.items.length > 0) {
+        const hasMaintenanceTag = responseData.items.some((ann: AnnouncementItem) =>
+          ann.tags && ann.tags.some((tag: string) =>
             tag.toLowerCase().includes("maintenance")
           )
         );
@@ -78,29 +89,28 @@ describe("AnnouncementsServer Integration Tests", () => {
 
     it("should handle date range filters", async () => {
       const result = await server["handleToolCall"]({
+        method: "tools/call",
         params: {
-          name: "get_announcements",
+          name: "search_announcements",
           arguments: {
-            relative_start_date: "-1month",
-            relative_end_date: "today",
+            date: "this_month",
             limit: 10,
           },
         },
-      } as any);
+      });
 
       expect(result.isError).toBeFalsy();
-      const responseData = JSON.parse(result.content[0].text);
-      
-      expect(responseData).toHaveProperty("announcements");
-      expect(responseData.filters_applied).toHaveProperty("date_range");
-      
+      const responseData = JSON.parse((result.content[0] as TextContent).text);
+
+      expect(responseData).toHaveProperty("items");
+
       // All announcements should be within the last month
-      if (responseData.announcements.length > 0) {
+      if (responseData.items.length > 0) {
         const oneMonthAgo = new Date();
         oneMonthAgo.setMonth(oneMonthAgo.getMonth() - 1);
-        
-        responseData.announcements.forEach((ann: any) => {
-          const annDate = new Date(ann.date);
+
+        responseData.items.forEach((ann: AnnouncementItem) => {
+          const annDate = new Date(ann.published_date);
           expect(annDate.getTime()).toBeGreaterThanOrEqual(oneMonthAgo.getTime());
         });
       }
@@ -110,27 +120,27 @@ describe("AnnouncementsServer Integration Tests", () => {
   describe("get_recent_announcements", () => {
     it("should fetch announcements from the past week", async () => {
       const result = await server["handleToolCall"]({
+        method: "tools/call",
         params: {
-          name: "get_recent_announcements",
+          name: "search_announcements",
           arguments: {
-            period: "1 week",
+            date: "this_week",
           },
         },
-      } as any);
+      });
 
       expect(result.isError).toBeFalsy();
-      const responseData = JSON.parse(result.content[0].text);
-      
-      expect(responseData).toHaveProperty("announcements");
-      expect(responseData.filters_applied.date_range).toContain("week");
-      
+      const responseData = JSON.parse((result.content[0] as TextContent).text);
+
+      expect(responseData).toHaveProperty("items");
+
       // Check that announcements are from the past week if any exist
-      if (responseData.announcements.length > 0) {
+      if (responseData.items.length > 0) {
         const oneWeekAgo = new Date();
         oneWeekAgo.setDate(oneWeekAgo.getDate() - 7);
-        
-        responseData.announcements.forEach((ann: any) => {
-          const annDate = new Date(ann.date);
+
+        responseData.items.forEach((ann: AnnouncementItem) => {
+          const annDate = new Date(ann.published_date);
           expect(annDate.getTime()).toBeGreaterThanOrEqual(oneWeekAgo.getTime());
         });
       }
@@ -138,83 +148,105 @@ describe("AnnouncementsServer Integration Tests", () => {
 
     it("should handle today filter", async () => {
       const result = await server["handleToolCall"]({
+        method: "tools/call",
         params: {
-          name: "get_recent_announcements",
+          name: "search_announcements",
           arguments: {
-            period: "0 days",
+            date: "today",
           },
         },
-      } as any);
+      });
 
       expect(result.isError).toBeFalsy();
-      const responseData = JSON.parse(result.content[0].text);
-      
-      expect(responseData).toHaveProperty("announcements");
-      expect(responseData.filters_applied.date_range).toContain("0 days");
-      
+      const responseData = JSON.parse((result.content[0] as TextContent).text);
+
+      expect(responseData).toHaveProperty("items");
+
       // Today's announcements might be empty, that's okay
-      expect(Array.isArray(responseData.announcements)).toBe(true);
+      expect(Array.isArray(responseData.items)).toBe(true);
     }, 10000);
   });
 
-  describe("get_announcements_by_affinity_group", () => {
-    it("should handle affinity group filtering", async () => {
-      // We don't know specific affinity group IDs, so test with a made-up one
+  describe("get_announcements with limit", () => {
+    it("should respect limit parameter", async () => {
       const result = await server["handleToolCall"]({
+        method: "tools/call",
         params: {
-          name: "get_announcements_by_affinity_group",
+          name: "search_announcements",
           arguments: {
-            ag: "test-group-123",
             limit: 5,
           },
         },
-      } as any);
+      });
 
       expect(result.isError).toBeFalsy();
-      const responseData = JSON.parse(result.content[0].text);
-      
-      // Should return a valid response even if no announcements match
-      expect(responseData).toHaveProperty("announcements");
-      expect(Array.isArray(responseData.announcements)).toBe(true);
-      expect(responseData.filters_applied).toHaveProperty("affinity_group");
-      expect(responseData.filters_applied.affinity_group).toBe("test-group-123");
+      const responseData = JSON.parse((result.content[0] as TextContent).text);
+
+      // Should return a valid response
+      expect(responseData).toHaveProperty("items");
+      expect(Array.isArray(responseData.items)).toBe(true);
+      if (responseData.items.length > 0) {
+        expect(responseData.items.length).toBeLessThanOrEqual(5);
+      }
     }, 10000);
   });
 
-  describe("API Error Handling", () => {
-    it("should handle invalid parameters gracefully", async () => {
+  describe("search with query parameter", () => {
+    it("should perform full-text search", async () => {
       const result = await server["handleToolCall"]({
+        method: "tools/call",
         params: {
-          name: "get_announcements",
+          name: "search_announcements",
           arguments: {
-            beginning_date: "invalid-date",
+            query: "ACCESS",
+            limit: 5,
           },
         },
-      } as any);
+      });
 
-      // The API might accept this or reject it
-      // Just verify we get a response
+      expect(result.isError).toBeFalsy();
+      const responseData = JSON.parse((result.content[0] as TextContent).text);
+
+      expect(responseData).toHaveProperty("items");
+      expect(Array.isArray(responseData.items)).toBe(true);
+    }, 10000);
+  });
+
+  describe("API Error Handling", () => {
+    it("should handle search with no parameters", async () => {
+      const result = await server["handleToolCall"]({
+        method: "tools/call",
+        params: {
+          name: "search_announcements",
+          arguments: {},
+        },
+      });
+
+      // Should return default results
       expect(result).toBeDefined();
       expect(result.content).toBeDefined();
+      const responseData = JSON.parse((result.content[0] as TextContent).text);
+      expect(responseData).toHaveProperty("items");
     }, 10000);
 
     it("should handle empty results", async () => {
       const result = await server["handleToolCall"]({
+        method: "tools/call",
         params: {
-          name: "get_announcements",
+          name: "search_announcements",
           arguments: {
             tags: "nonexistent-tag-xyz-123-456",
-            exact_match: true,
           },
         },
-      } as any);
+      });
 
       expect(result.isError).toBeFalsy();
-      const responseData = JSON.parse(result.content[0].text);
-      
-      expect(responseData.total_announcements).toBe(0);
-      expect(responseData.announcements).toEqual([]);
-      expect(responseData.message).toContain("No announcements found");
+      const responseData = JSON.parse((result.content[0] as TextContent).text);
+
+      // May have 0 or few results
+      expect(responseData).toHaveProperty("total");
+      expect(responseData).toHaveProperty("items");
+      expect(Array.isArray(responseData.items)).toBe(true);
     }, 10000);
   });
 });