@contextstream/mcp-server 0.3.48 → 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
@@ -7678,16 +7757,51 @@ function getCoreToolsHint() {
 var LESSON_DEDUP_WINDOW_MS = 2 * 60 * 1e3;
 var recentLessonCaptures = /* @__PURE__ */ new Map();
 var LIGHT_TOOLSET = /* @__PURE__ */ new Set([
+  // Core session tools (13)
   "session_init",
+  "session_tools",
   "context_smart",
+  "session_summary",
   "session_capture",
+  "session_capture_lesson",
+  "session_get_lessons",
   "session_recall",
   "session_remember",
+  "session_get_user_context",
+  "session_smart_search",
+  "session_compress",
+  "session_delta",
+  // Setup and configuration (3)
+  "generate_editor_rules",
+  "workspace_associate",
+  "workspace_bootstrap",
+  // Project management (5)
+  "projects_create",
+  "projects_list",
+  "projects_get",
+  "projects_overview",
+  "projects_statistics",
+  // Project indexing (4)
+  "projects_ingest_local",
+  "projects_index",
+  "projects_index_status",
+  "projects_files",
+  // 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"
 ]);
 var STANDARD_TOOLSET = /* @__PURE__ */ new Set([
-  // Core session tools
+  // Core session tools (13)
   "session_init",
   "session_tools",
   "context_smart",
@@ -7701,18 +7815,59 @@ var STANDARD_TOOLSET = /* @__PURE__ */ new Set([
   "session_smart_search",
   "session_compress",
   "session_delta",
-  // Setup and configuration
+  // Setup and configuration (3)
   "generate_editor_rules",
   "workspace_associate",
   "workspace_bootstrap",
+  // Workspace management (2)
+  "workspaces_list",
+  "workspaces_get",
+  // Project management (6)
   "projects_create",
   "projects_list",
-  // Project indexing - essential for code context
+  "projects_get",
+  "projects_overview",
+  "projects_statistics",
+  "projects_update",
+  // Project indexing (4)
   "projects_ingest_local",
   "projects_index",
   "projects_index_status",
   "projects_files",
-  // Utility
+  // 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)
+  "memory_create_node",
+  "memory_list_nodes",
+  // Knowledge graph analysis (8)
+  "graph_related",
+  "graph_decisions",
+  "graph_path",
+  "graph_dependencies",
+  "graph_call_path",
+  "graph_impact",
+  "graph_circular_dependencies",
+  "graph_unused_code",
+  // Search (3)
+  "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"
 ]);
@@ -8775,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);
@@ -10546,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
@@ -11437,12 +11774,12 @@ Created API key: ${maskApiKey(apiKey)}
     const modeChoice = normalizeInput(await rl.question("Choose [1/2] (default 1): ")) || "1";
     const mode = modeChoice === "2" ? "full" : "minimal";
     console.log("\nMCP toolset (which tools to expose to the AI):");
-    console.log("  1) Light \u2014 minimal essential tools for fastest responses (~7 tools)");
-    console.log("     Best for: simple tasks, resource-constrained environments");
-    console.log("  2) Standard (recommended) \u2014 balanced set of session and context tools (~20 tools)");
-    console.log("     Best for: most users, balances speed with capabilities");
-    console.log("  3) Complete \u2014 all tools including memory, knowledge graph, AI, integrations (~86 tools)");
-    console.log("     Best for: power users needing full workspace/project/graph capabilities");
+    console.log("  1) Light \u2014 core session, project, and basic memory/graph tools (~30 tools)");
+    console.log("     Best for: faster responses, simpler workflows, resource-constrained environments");
+    console.log("  2) Standard (recommended) \u2014 adds workspace, memory CRUD, graph analysis, search (~50 tools)");
+    console.log("     Best for: most users, full development workflow with memory and code analysis");
+    console.log("  3) Complete \u2014 all tools including AI, GitHub, Slack integrations (~86 tools)");
+    console.log("     Best for: power users needing integrations and advanced features");
     console.log("");
     console.log("  Tip: Change later by setting CONTEXTSTREAM_TOOLSET=light|standard|complete");
     const toolsetChoice = normalizeInput(await rl.question("Choose [1/2/3] (default 2): ")) || "2";
@@ -11730,7 +12067,7 @@ Applying to ${projects.length} project(s)...`);
       const skipped = writeActions.filter((a) => a.status === "skipped").length;
       const dry = writeActions.filter((a) => a.status === "dry-run").length;
       console.log(`Summary: ${created} created, ${updated} updated, ${appended} appended, ${skipped} skipped, ${dry} dry-run.`);
-      const toolsetDesc = toolset === "light" ? "~7 tools" : toolset === "complete" ? "~86 tools" : "~20 tools";
+      const toolsetDesc = toolset === "light" ? "~30 tools" : toolset === "complete" ? "~86 tools" : "~50 tools";
       console.log(`Toolset: ${toolset} (${toolsetDesc})`);
     }
     console.log("\nNext steps:");

package/package.json

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