@contextstream/mcp-server 0.3.49 → 0.3.50

package/dist/index.js

@@ -7085,6 +7085,85 @@ W:${wsHint}
     if (params?.limit) urlParams.set("limit", String(params.limit));
     return request(this.config, `/integrations/knowledge?${urlParams.toString()}`, { method: "GET" });
   }
+  // ============================================
+  // Reminder Methods
+  // ============================================
+  /**
+   * List reminders for the user
+   */
+  async remindersList(params) {
+    const withDefaults = this.withDefaults(params || {});
+    const query = new URLSearchParams();
+    if (withDefaults.workspace_id) query.set("workspace_id", withDefaults.workspace_id);
+    if (withDefaults.project_id) query.set("project_id", withDefaults.project_id);
+    if (params?.status) query.set("status", params.status);
+    if (params?.priority) query.set("priority", params.priority);
+    if (params?.limit) query.set("limit", String(params.limit));
+    const suffix = query.toString() ? `?${query.toString()}` : "";
+    return request(this.config, `/reminders${suffix}`, { method: "GET" });
+  }
+  /**
+   * Get active reminders (pending, overdue, due soon)
+   */
+  async remindersActive(params) {
+    const withDefaults = this.withDefaults(params || {});
+    const query = new URLSearchParams();
+    if (withDefaults.workspace_id) query.set("workspace_id", withDefaults.workspace_id);
+    if (withDefaults.project_id) query.set("project_id", withDefaults.project_id);
+    if (params?.context) query.set("context", params.context);
+    if (params?.limit) query.set("limit", String(params.limit));
+    const suffix = query.toString() ? `?${query.toString()}` : "";
+    return request(this.config, `/reminders/active${suffix}`, { method: "GET" });
+  }
+  /**
+   * Create a new reminder
+   */
+  async remindersCreate(params) {
+    const withDefaults = this.withDefaults(params);
+    return request(this.config, "/reminders", {
+      body: {
+        workspace_id: withDefaults.workspace_id,
+        project_id: withDefaults.project_id,
+        title: params.title,
+        content: params.content,
+        remind_at: params.remind_at,
+        priority: params.priority || "normal",
+        keywords: params.keywords || [],
+        recurrence: params.recurrence,
+        memory_event_id: params.memory_event_id
+      }
+    });
+  }
+  /**
+   * Snooze a reminder
+   */
+  async remindersSnooze(params) {
+    uuidSchema.parse(params.reminder_id);
+    return request(this.config, `/reminders/${params.reminder_id}/snooze`, {
+      body: { until: params.until }
+    });
+  }
+  /**
+   * Mark a reminder as completed
+   */
+  async remindersComplete(params) {
+    uuidSchema.parse(params.reminder_id);
+    return request(this.config, `/reminders/${params.reminder_id}/complete`, { method: "POST" });
+  }
+  /**
+   * Dismiss a reminder
+   */
+  async remindersDismiss(params) {
+    uuidSchema.parse(params.reminder_id);
+    return request(this.config, `/reminders/${params.reminder_id}/dismiss`, { method: "POST" });
+  }
+  /**
+   * Delete a reminder
+   */
+  async remindersDelete(params) {
+    uuidSchema.parse(params.reminder_id);
+    return request(this.config, `/reminders/${params.reminder_id}`, { method: "DELETE" });
+  }
 };
 
 // src/tools.ts
@@ -7707,12 +7786,16 @@ var LIGHT_TOOLSET = /* @__PURE__ */ new Set([
   "projects_index",
   "projects_index_status",
   "projects_files",
-  // Memory basics (2)
+  // Memory basics (3)
   "memory_search",
   "memory_decisions",
+  "memory_get_event",
   // Graph basics (2)
   "graph_related",
   "graph_decisions",
+  // Reminders (2)
+  "reminders_list",
+  "reminders_active",
   // Utility (2)
   "auth_me",
   "mcp_server_version"
@@ -7751,11 +7834,14 @@ var STANDARD_TOOLSET = /* @__PURE__ */ new Set([
   "projects_index",
   "projects_index_status",
   "projects_files",
-  // Memory events (6)
+  // Memory events (9)
   "memory_search",
   "memory_decisions",
   "memory_create_event",
   "memory_list_events",
+  "memory_get_event",
+  "memory_update_event",
+  "memory_delete_event",
   "memory_timeline",
   "memory_summary",
   // Memory nodes (2)
@@ -7774,6 +7860,13 @@ var STANDARD_TOOLSET = /* @__PURE__ */ new Set([
   "search_semantic",
   "search_hybrid",
   "search_keyword",
+  // Reminders (6)
+  "reminders_list",
+  "reminders_active",
+  "reminders_create",
+  "reminders_snooze",
+  "reminders_complete",
+  "reminders_dismiss",
   // Utility (2)
   "auth_me",
   "mcp_server_version"
@@ -8837,8 +8930,8 @@ Automatically detects code files and skips ignored directories like node_modules
     "memory_get_event",
     {
       title: "Get memory event",
-      description: "Get a specific memory event by ID",
-      inputSchema: external_exports.object({ event_id: external_exports.string().uuid() })
+      description: "Get a specific memory event by ID with FULL content (not truncated). Use this when you need the complete content of a memory event, not just the preview returned by search/recall.",
+      inputSchema: external_exports.object({ event_id: external_exports.string().uuid().describe("The UUID of the memory event to retrieve") })
     },
     async (input) => {
       const result = await client.getMemoryEvent(input.event_id);
@@ -10608,6 +10701,188 @@ Use this to verify integrations are healthy and syncing properly.`,
       return { content: [{ type: "text", text: formatted }], structuredContent: toStructured(result) };
     }
   );
+  registerTool(
+    "reminders_list",
+    {
+      title: "List reminders",
+      description: `List all reminders for the current user.
+Returns: reminders with title, content, remind_at, priority, status, and keywords.
+Can filter by status (pending, completed, dismissed, snoozed) and priority (low, normal, high, urgent).
+
+Use this to see what reminders you have set.`,
+      inputSchema: external_exports.object({
+        workspace_id: external_exports.string().uuid().optional(),
+        project_id: external_exports.string().uuid().optional(),
+        status: external_exports.enum(["pending", "completed", "dismissed", "snoozed"]).optional().describe("Filter by status"),
+        priority: external_exports.enum(["low", "normal", "high", "urgent"]).optional().describe("Filter by priority"),
+        limit: external_exports.number().optional().describe("Maximum reminders to return (default: 20)")
+      })
+    },
+    async (input) => {
+      const result = await client.remindersList({
+        workspace_id: input.workspace_id,
+        project_id: input.project_id,
+        status: input.status,
+        priority: input.priority,
+        limit: input.limit
+      });
+      if (!result.reminders || result.reminders.length === 0) {
+        return { content: [{ type: "text", text: "No reminders found." }] };
+      }
+      return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+    }
+  );
+  registerTool(
+    "reminders_active",
+    {
+      title: "Get active reminders",
+      description: `Get active reminders that are pending, overdue, or due soon.
+Returns: reminders with urgency levels (overdue, due_soon, today, upcoming).
+Optionally provide context (e.g., current task description) to get contextually relevant reminders.
+
+Use this to see what reminders need attention now.`,
+      inputSchema: external_exports.object({
+        workspace_id: external_exports.string().uuid().optional(),
+        project_id: external_exports.string().uuid().optional(),
+        context: external_exports.string().optional().describe("Optional context to match relevant reminders (e.g., current task)"),
+        limit: external_exports.number().optional().describe("Maximum reminders to return (default: 10)")
+      })
+    },
+    async (input) => {
+      const result = await client.remindersActive({
+        workspace_id: input.workspace_id,
+        project_id: input.project_id,
+        context: input.context,
+        limit: input.limit
+      });
+      if (!result.reminders || result.reminders.length === 0) {
+        return { content: [{ type: "text", text: "No active reminders." }] };
+      }
+      const formatted = result.reminders.map((r) => {
+        const icon = r.urgency === "overdue" ? "\u{1F534}" : r.urgency === "due_soon" ? "\u{1F7E0}" : r.urgency === "today" ? "\u{1F7E1}" : "\u{1F535}";
+        const priority = r.priority !== "normal" ? ` [${r.priority}]` : "";
+        return `${icon} ${r.title}${priority}
+   Due: ${new Date(r.remind_at).toLocaleString()}
+   ${r.content_preview}`;
+      }).join("\n\n");
+      const header = result.overdue_count > 0 ? `\u26A0\uFE0F ${result.overdue_count} overdue reminder(s)
+
+` : "";
+      return { content: [{ type: "text", text: header + formatted }], structuredContent: toStructured(result) };
+    }
+  );
+  registerTool(
+    "reminders_create",
+    {
+      title: "Create a reminder",
+      description: `Create a new reminder for a specific date/time.
+Set reminders to be notified about tasks, follow-ups, or important dates.
+
+Priority levels: low, normal, high, urgent
+Recurrence: daily, weekly, monthly (optional)
+
+Example: Create a reminder to "Review PR #123" for tomorrow at 10am with high priority.`,
+      inputSchema: external_exports.object({
+        workspace_id: external_exports.string().uuid().optional(),
+        project_id: external_exports.string().uuid().optional(),
+        title: external_exports.string().describe("Reminder title (brief, descriptive)"),
+        content: external_exports.string().describe("Reminder details/description"),
+        remind_at: external_exports.string().describe('When to remind (ISO 8601 datetime, e.g., "2025-01-15T10:00:00Z")'),
+        priority: external_exports.enum(["low", "normal", "high", "urgent"]).optional().describe("Priority level (default: normal)"),
+        keywords: external_exports.array(external_exports.string()).optional().describe("Keywords for contextual surfacing"),
+        recurrence: external_exports.enum(["daily", "weekly", "monthly"]).optional().describe("Recurrence pattern")
+      })
+    },
+    async (input) => {
+      const result = await client.remindersCreate({
+        workspace_id: input.workspace_id,
+        project_id: input.project_id,
+        title: input.title,
+        content: input.content,
+        remind_at: input.remind_at,
+        priority: input.priority,
+        keywords: input.keywords,
+        recurrence: input.recurrence
+      });
+      const due = new Date(result.remind_at).toLocaleString();
+      return {
+        content: [{ type: "text", text: `\u2705 Reminder created: "${result.title}"
+Due: ${due}
+Priority: ${result.priority}
+ID: ${result.id}` }],
+        structuredContent: toStructured(result)
+      };
+    }
+  );
+  registerTool(
+    "reminders_snooze",
+    {
+      title: "Snooze a reminder",
+      description: `Snooze a reminder until a later time.
+Use this to postpone a reminder without dismissing it.
+
+Common snooze durations:
+- 1 hour: add 1 hour to current time
+- 4 hours: add 4 hours
+- Tomorrow: next day at 9am
+- Next week: 7 days from now`,
+      inputSchema: external_exports.object({
+        reminder_id: external_exports.string().uuid().describe("ID of the reminder to snooze"),
+        until: external_exports.string().describe("When to resurface the reminder (ISO 8601 datetime)")
+      })
+    },
+    async (input) => {
+      const result = await client.remindersSnooze({
+        reminder_id: input.reminder_id,
+        until: input.until
+      });
+      const snoozedUntil = new Date(result.snoozed_until).toLocaleString();
+      return {
+        content: [{ type: "text", text: `\u{1F634} Reminder snoozed until ${snoozedUntil}` }],
+        structuredContent: toStructured(result)
+      };
+    }
+  );
+  registerTool(
+    "reminders_complete",
+    {
+      title: "Complete a reminder",
+      description: `Mark a reminder as completed.
+Use this when the task or action associated with the reminder is done.`,
+      inputSchema: external_exports.object({
+        reminder_id: external_exports.string().uuid().describe("ID of the reminder to complete")
+      })
+    },
+    async (input) => {
+      const result = await client.remindersComplete({
+        reminder_id: input.reminder_id
+      });
+      return {
+        content: [{ type: "text", text: `\u2705 Reminder completed!` }],
+        structuredContent: toStructured(result)
+      };
+    }
+  );
+  registerTool(
+    "reminders_dismiss",
+    {
+      title: "Dismiss a reminder",
+      description: `Dismiss a reminder without completing it.
+Use this to remove a reminder that is no longer relevant.`,
+      inputSchema: external_exports.object({
+        reminder_id: external_exports.string().uuid().describe("ID of the reminder to dismiss")
+      })
+    },
+    async (input) => {
+      const result = await client.remindersDismiss({
+        reminder_id: input.reminder_id
+      });
+      return {
+        content: [{ type: "text", text: `\u{1F5D1}\uFE0F Reminder dismissed.` }],
+        structuredContent: toStructured(result)
+      };
+    }
+  );
 }
 
 // src/resources.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contextstream/mcp-server",
-  "version": "0.3.49",
+  "version": "0.3.50",
   "description": "MCP server exposing ContextStream public API - code context, memory, search, and AI tools for developers",
   "type": "module",
   "license": "MIT",