@contextstream/mcp-server 0.3.73 → 0.4.1

package/dist/index.js

@@ -7662,6 +7662,13 @@ ${options.workspaceId ? `# Workspace ID: ${options.workspaceId}` : ""}
     content: content.trim() + "\n"
   };
 }
+function generateAllRuleFiles(options) {
+  return getAvailableEditors().map((editor) => {
+    const result = generateRuleContent(editor, options);
+    if (!result) return null;
+    return { editor, ...result };
+  }).filter((r) => r !== null);
+}
 
 // src/tool-catalog.ts
 var TOOL_CATALOG = [
@@ -8511,6 +8518,31 @@ function getOperationSchema(name) {
 }
 var OUTPUT_FORMAT = process.env.CONTEXTSTREAM_OUTPUT_FORMAT || "compact";
 var COMPACT_OUTPUT = OUTPUT_FORMAT === "compact";
+var CONSOLIDATED_MODE = process.env.CONTEXTSTREAM_CONSOLIDATED !== "false";
+var CONSOLIDATED_TOOLS = /* @__PURE__ */ new Set([
+  "session_init",
+  // Standalone - complex initialization
+  "context_smart",
+  // Standalone - called every message
+  "search",
+  // Consolidates search_semantic, search_hybrid, search_keyword, search_pattern
+  "session",
+  // Consolidates session_capture, session_recall, etc.
+  "memory",
+  // Consolidates memory_create_event, memory_get_event, etc.
+  "graph",
+  // Consolidates graph_dependencies, graph_impact, etc.
+  "project",
+  // Consolidates projects_list, projects_create, etc.
+  "workspace",
+  // Consolidates workspaces_list, workspace_associate, etc.
+  "reminder",
+  // Consolidates reminders_list, reminders_create, etc.
+  "integration",
+  // Consolidates slack_*, github_*, integrations_*
+  "help"
+  // Consolidates session_tools, auth_me, mcp_server_version, etc.
+]);
 var TOOLSET_ALIASES = {
   // Light mode - minimal, fastest
   light: LIGHT_TOOLSET,
@@ -8722,6 +8754,12 @@ function registerTools(server, client, sessionManager) {
   } else {
     console.error("[ContextStream] Output format: pretty (set CONTEXTSTREAM_OUTPUT_FORMAT=compact for fewer tokens)");
   }
+  if (CONSOLIDATED_MODE) {
+    console.error(`[ContextStream] Consolidated mode: ENABLED (~${CONSOLIDATED_TOOLS.size} domain tools, ~75% token reduction)`);
+    console.error("[ContextStream] Set CONTEXTSTREAM_CONSOLIDATED=false to use individual tools.");
+  } else {
+    console.error("[ContextStream] Consolidated mode: disabled (using individual tools)");
+  }
   let serverRef = server;
   const defaultProTools = /* @__PURE__ */ new Set([
     // AI endpoints (typically paid/credit-metered)
@@ -9107,7 +9145,18 @@ Upgrade: ${upgradeUrl2}` : "";
   }
   const ROUTER_DIRECT_TOOLS = /* @__PURE__ */ new Set(["contextstream", "contextstream_help"]);
   function registerTool(name, config, handler) {
-    if (toolAllowlist && !toolAllowlist.has(name)) {
+    if (CONSOLIDATED_MODE && !CONSOLIDATED_TOOLS.has(name)) {
+      operationsRegistry.set(name, {
+        name,
+        title: config.title,
+        description: config.description,
+        inputSchema: config.inputSchema,
+        handler,
+        category: inferOperationCategory(name)
+      });
+      return;
+    }
+    if (!CONSOLIDATED_MODE && toolAllowlist && !toolAllowlist.has(name)) {
       if (ROUTER_MODE && !ROUTER_DIRECT_TOOLS.has(name)) {
         operationsRegistry.set(name, {
           name,
@@ -9120,7 +9169,7 @@ Upgrade: ${upgradeUrl2}` : "";
       }
       return;
     }
-    if (!shouldRegisterIntegrationTool(name)) {
+    if (!CONSOLIDATED_MODE && !shouldRegisterIntegrationTool(name)) {
       return;
     }
     if (ROUTER_MODE && !ROUTER_DIRECT_TOOLS.has(name)) {
@@ -12296,6 +12345,1175 @@ Use this to remove a reminder that is no longer relevant.`,
       };
     }
   );
+  if (CONSOLIDATED_MODE) {
+    registerTool(
+      "search",
+      {
+        title: "Search",
+        description: `Search workspace memory and knowledge. Modes: semantic (meaning-based), hybrid (semantic + keyword), keyword (exact match), pattern (regex).`,
+        inputSchema: external_exports.object({
+          mode: external_exports.enum(["semantic", "hybrid", "keyword", "pattern"]).describe("Search mode"),
+          query: external_exports.string().describe("Search query"),
+          workspace_id: external_exports.string().uuid().optional(),
+          project_id: external_exports.string().uuid().optional(),
+          limit: external_exports.number().optional()
+        })
+      },
+      async (input) => {
+        const params = {
+          query: input.query,
+          workspace_id: resolveWorkspaceId(input.workspace_id),
+          project_id: resolveProjectId(input.project_id),
+          limit: input.limit
+        };
+        let result;
+        switch (input.mode) {
+          case "semantic":
+            result = await client.searchSemantic(params);
+            break;
+          case "hybrid":
+            result = await client.searchHybrid(params);
+            break;
+          case "keyword":
+            result = await client.searchKeyword(params);
+            break;
+          case "pattern":
+            result = await client.searchPattern(params);
+            break;
+        }
+        return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+      }
+    );
+    registerTool(
+      "session",
+      {
+        title: "Session",
+        description: `Session management operations. Actions: capture (save decision/insight), capture_lesson (save lesson from mistake), get_lessons (retrieve lessons), recall (natural language recall), remember (quick save), user_context (get preferences), summary (workspace summary), compress (compress chat), delta (changes since timestamp), smart_search (context-enriched search), decision_trace (trace decision provenance).`,
+        inputSchema: external_exports.object({
+          action: external_exports.enum([
+            "capture",
+            "capture_lesson",
+            "get_lessons",
+            "recall",
+            "remember",
+            "user_context",
+            "summary",
+            "compress",
+            "delta",
+            "smart_search",
+            "decision_trace"
+          ]).describe("Action to perform"),
+          workspace_id: external_exports.string().uuid().optional(),
+          project_id: external_exports.string().uuid().optional(),
+          // Content params
+          query: external_exports.string().optional().describe("Query for recall/search/lessons/decision_trace"),
+          content: external_exports.string().optional().describe("Content for capture/remember/compress"),
+          title: external_exports.string().optional().describe("Title for capture/capture_lesson"),
+          event_type: external_exports.enum(["decision", "preference", "insight", "task", "bug", "feature", "correction", "lesson", "warning", "frustration", "conversation"]).optional().describe("Event type for capture"),
+          importance: external_exports.enum(["low", "medium", "high", "critical"]).optional(),
+          tags: external_exports.array(external_exports.string()).optional(),
+          // Lesson-specific
+          category: external_exports.enum(["workflow", "code_quality", "verification", "communication", "project_specific"]).optional(),
+          trigger: external_exports.string().optional().describe("What caused the problem"),
+          impact: external_exports.string().optional().describe("What went wrong"),
+          prevention: external_exports.string().optional().describe("How to prevent in future"),
+          severity: external_exports.enum(["low", "medium", "high", "critical"]).optional(),
+          keywords: external_exports.array(external_exports.string()).optional(),
+          // Other params
+          since: external_exports.string().optional().describe("ISO timestamp for delta"),
+          limit: external_exports.number().optional(),
+          max_tokens: external_exports.number().optional().describe("Max tokens for summary"),
+          include_decisions: external_exports.boolean().optional(),
+          include_related: external_exports.boolean().optional(),
+          include_impact: external_exports.boolean().optional(),
+          session_id: external_exports.string().optional(),
+          code_refs: external_exports.array(external_exports.object({
+            file_path: external_exports.string(),
+            symbol_id: external_exports.string().optional(),
+            symbol_name: external_exports.string().optional()
+          })).optional(),
+          provenance: external_exports.object({
+            repo: external_exports.string().optional(),
+            branch: external_exports.string().optional(),
+            commit_sha: external_exports.string().optional(),
+            pr_url: external_exports.string().url().optional(),
+            issue_url: external_exports.string().url().optional(),
+            slack_thread_url: external_exports.string().url().optional()
+          }).optional()
+        })
+      },
+      async (input) => {
+        const workspaceId = resolveWorkspaceId(input.workspace_id);
+        const projectId = resolveProjectId(input.project_id);
+        switch (input.action) {
+          case "capture": {
+            if (!input.event_type || !input.title || !input.content) {
+              return errorResult("capture requires: event_type, title, content");
+            }
+            const result = await client.captureContext({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              event_type: input.event_type,
+              title: input.title,
+              content: input.content,
+              importance: input.importance,
+              tags: input.tags,
+              session_id: input.session_id,
+              code_refs: input.code_refs,
+              provenance: input.provenance
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "capture_lesson": {
+            if (!input.title || !input.category || !input.trigger || !input.impact || !input.prevention) {
+              return errorResult("capture_lesson requires: title, category, trigger, impact, prevention");
+            }
+            const lessonInput = {
+              title: input.title,
+              category: input.category,
+              trigger: input.trigger,
+              impact: input.impact,
+              prevention: input.prevention,
+              severity: input.severity || "medium",
+              keywords: input.keywords,
+              workspace_id: workspaceId,
+              project_id: projectId
+            };
+            const signature = buildLessonSignature(lessonInput, workspaceId || "global", projectId);
+            if (isDuplicateLessonCapture(signature)) {
+              return { content: [{ type: "text", text: formatContent({ deduplicated: true, message: "Lesson already captured recently" }) }] };
+            }
+            const result = await client.captureLesson(lessonInput);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "get_lessons": {
+            const result = await client.getLessons({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              query: input.query,
+              category: input.category,
+              severity: input.severity,
+              limit: input.limit
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "recall": {
+            if (!input.query) {
+              return errorResult("recall requires: query");
+            }
+            const result = await client.recallContext({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              query: input.query
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "remember": {
+            if (!input.content) {
+              return errorResult("remember requires: content");
+            }
+            const result = await client.rememberContext({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              content: input.content,
+              importance: input.importance
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "user_context": {
+            const result = await client.getUserContext({ workspace_id: workspaceId });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "summary": {
+            const result = await client.getSessionSummary({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              max_tokens: input.max_tokens
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "compress": {
+            if (!input.content) {
+              return errorResult("compress requires: content (the chat history to compress)");
+            }
+            const result = await client.compressSession({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              chat_history: input.content
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "delta": {
+            if (!input.since) {
+              return errorResult("delta requires: since (ISO timestamp)");
+            }
+            const result = await client.getSessionDelta({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              since: input.since,
+              limit: input.limit
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "smart_search": {
+            if (!input.query) {
+              return errorResult("smart_search requires: query");
+            }
+            const result = await client.smartSearch({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              query: input.query,
+              include_decisions: input.include_decisions,
+              include_related: input.include_related
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "decision_trace": {
+            if (!input.query) {
+              return errorResult("decision_trace requires: query");
+            }
+            const result = await client.decisionTrace({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              query: input.query,
+              include_impact: input.include_impact,
+              limit: input.limit
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          default:
+            return errorResult(`Unknown action: ${input.action}`);
+        }
+      }
+    );
+    registerTool(
+      "memory",
+      {
+        title: "Memory",
+        description: `Memory operations for events and nodes. Event actions: create_event, get_event, update_event, delete_event, list_events, distill_event. Node actions: create_node, get_node, update_node, delete_node, list_nodes, supersede_node. Query actions: search, decisions, timeline, summary.`,
+        inputSchema: external_exports.object({
+          action: external_exports.enum([
+            "create_event",
+            "get_event",
+            "update_event",
+            "delete_event",
+            "list_events",
+            "distill_event",
+            "create_node",
+            "get_node",
+            "update_node",
+            "delete_node",
+            "list_nodes",
+            "supersede_node",
+            "search",
+            "decisions",
+            "timeline",
+            "summary"
+          ]).describe("Action to perform"),
+          workspace_id: external_exports.string().uuid().optional(),
+          project_id: external_exports.string().uuid().optional(),
+          // ID params
+          event_id: external_exports.string().uuid().optional(),
+          node_id: external_exports.string().uuid().optional(),
+          // Content params
+          title: external_exports.string().optional(),
+          content: external_exports.string().optional(),
+          event_type: external_exports.string().optional(),
+          node_type: external_exports.string().optional(),
+          metadata: external_exports.record(external_exports.any()).optional(),
+          // Query params
+          query: external_exports.string().optional(),
+          category: external_exports.string().optional(),
+          limit: external_exports.number().optional(),
+          // Node relations
+          relations: external_exports.array(external_exports.object({
+            type: external_exports.string(),
+            target_id: external_exports.string().uuid()
+          })).optional(),
+          new_node_id: external_exports.string().uuid().optional().describe("For supersede: the new node ID"),
+          // Provenance
+          provenance: external_exports.object({
+            repo: external_exports.string().optional(),
+            branch: external_exports.string().optional(),
+            commit_sha: external_exports.string().optional(),
+            pr_url: external_exports.string().url().optional(),
+            issue_url: external_exports.string().url().optional(),
+            slack_thread_url: external_exports.string().url().optional()
+          }).optional(),
+          code_refs: external_exports.array(external_exports.object({
+            file_path: external_exports.string(),
+            symbol_id: external_exports.string().optional(),
+            symbol_name: external_exports.string().optional()
+          })).optional()
+        })
+      },
+      async (input) => {
+        const workspaceId = resolveWorkspaceId(input.workspace_id);
+        const projectId = resolveProjectId(input.project_id);
+        switch (input.action) {
+          case "create_event": {
+            if (!input.event_type || !input.title || !input.content) {
+              return errorResult("create_event requires: event_type, title, content");
+            }
+            const result = await client.createMemoryEvent({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              event_type: input.event_type,
+              title: input.title,
+              content: input.content,
+              metadata: input.metadata,
+              provenance: input.provenance,
+              code_refs: input.code_refs
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "get_event": {
+            if (!input.event_id) {
+              return errorResult("get_event requires: event_id");
+            }
+            const result = await client.getMemoryEvent(input.event_id);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "update_event": {
+            if (!input.event_id) {
+              return errorResult("update_event requires: event_id");
+            }
+            const result = await client.updateMemoryEvent({
+              event_id: input.event_id,
+              title: input.title,
+              content: input.content,
+              metadata: input.metadata
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "delete_event": {
+            if (!input.event_id) {
+              return errorResult("delete_event requires: event_id");
+            }
+            const result = await client.deleteMemoryEvent(input.event_id);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "list_events": {
+            const result = await client.listMemoryEvents({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              limit: input.limit
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "distill_event": {
+            if (!input.event_id) {
+              return errorResult("distill_event requires: event_id");
+            }
+            const result = await client.distillEvent(input.event_id);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "create_node": {
+            if (!input.node_type || !input.title || !input.content) {
+              return errorResult("create_node requires: node_type, title, content");
+            }
+            const result = await client.createKnowledgeNode({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              node_type: input.node_type,
+              title: input.title,
+              content: input.content,
+              relations: input.relations
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "get_node": {
+            if (!input.node_id) {
+              return errorResult("get_node requires: node_id");
+            }
+            const result = await client.getKnowledgeNode(input.node_id);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "update_node": {
+            if (!input.node_id) {
+              return errorResult("update_node requires: node_id");
+            }
+            const result = await client.updateKnowledgeNode({
+              node_id: input.node_id,
+              title: input.title,
+              content: input.content
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "delete_node": {
+            if (!input.node_id) {
+              return errorResult("delete_node requires: node_id");
+            }
+            const result = await client.deleteKnowledgeNode(input.node_id);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "list_nodes": {
+            const result = await client.listKnowledgeNodes({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              limit: input.limit
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "supersede_node": {
+            if (!input.node_id || !input.new_node_id) {
+              return errorResult("supersede_node requires: node_id, new_node_id");
+            }
+            const result = await client.supersedeKnowledgeNode({
+              node_id: input.node_id,
+              new_node_id: input.new_node_id
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "search": {
+            if (!input.query) {
+              return errorResult("search requires: query");
+            }
+            const result = await client.searchMemory({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              query: input.query,
+              limit: input.limit
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "decisions": {
+            const result = await client.memoryDecisions({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              category: input.category,
+              limit: input.limit
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "timeline": {
+            const result = await client.memoryTimeline({
+              workspace_id: workspaceId
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "summary": {
+            const result = await client.memorySummary({
+              workspace_id: workspaceId
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          default:
+            return errorResult(`Unknown action: ${input.action}`);
+        }
+      }
+    );
+    registerTool(
+      "graph",
+      {
+        title: "Graph",
+        description: `Code graph analysis. Actions: dependencies (module deps), impact (change impact), call_path (function call path), related (related nodes), path (path between nodes), decisions (decision history), ingest (build graph), circular_dependencies, unused_code, contradictions.`,
+        inputSchema: external_exports.object({
+          action: external_exports.enum([
+            "dependencies",
+            "impact",
+            "call_path",
+            "related",
+            "path",
+            "decisions",
+            "ingest",
+            "circular_dependencies",
+            "unused_code",
+            "contradictions"
+          ]).describe("Action to perform"),
+          workspace_id: external_exports.string().uuid().optional(),
+          project_id: external_exports.string().uuid().optional(),
+          // ID params
+          node_id: external_exports.string().uuid().optional().describe("For related/contradictions"),
+          source_id: external_exports.string().uuid().optional().describe("For path"),
+          target_id: external_exports.string().uuid().optional().describe("For path"),
+          // Target specification
+          target: external_exports.object({
+            type: external_exports.string().describe("module|function|type|variable"),
+            id: external_exports.string().describe("Element identifier")
+          }).optional().describe("For dependencies/impact"),
+          source: external_exports.object({
+            type: external_exports.string().describe("function"),
+            id: external_exports.string().describe("Function identifier")
+          }).optional().describe("For call_path"),
+          // Options
+          max_depth: external_exports.number().optional(),
+          include_transitive: external_exports.boolean().optional(),
+          limit: external_exports.number().optional(),
+          wait: external_exports.boolean().optional().describe("For ingest: wait for completion")
+        })
+      },
+      async (input) => {
+        const workspaceId = resolveWorkspaceId(input.workspace_id);
+        const projectId = resolveProjectId(input.project_id);
+        const gatedActions = ["related", "path", "decisions", "call_path", "circular_dependencies", "unused_code", "ingest", "contradictions"];
+        if (gatedActions.includes(input.action)) {
+          const gate = await gateIfGraphTool(`graph_${input.action}`, input);
+          if (gate) return gate;
+        }
+        switch (input.action) {
+          case "dependencies": {
+            if (!input.target) {
+              return errorResult("dependencies requires: target { type, id }");
+            }
+            const result = await client.graphDependencies({
+              target: input.target,
+              max_depth: input.max_depth,
+              include_transitive: input.include_transitive
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "impact": {
+            if (!input.target) {
+              return errorResult("impact requires: target { type, id }");
+            }
+            const result = await client.graphImpact({
+              target: input.target,
+              max_depth: input.max_depth
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "call_path": {
+            if (!input.source || !input.target) {
+              return errorResult("call_path requires: source { type, id }, target { type, id }");
+            }
+            const result = await client.graphCallPath({
+              source: input.source,
+              target: input.target,
+              max_depth: input.max_depth
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "related": {
+            if (!input.node_id) {
+              return errorResult("related requires: node_id");
+            }
+            const result = await client.graphRelated({
+              node_id: input.node_id,
+              workspace_id: workspaceId,
+              project_id: projectId,
+              limit: input.limit
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "path": {
+            if (!input.source_id || !input.target_id) {
+              return errorResult("path requires: source_id, target_id");
+            }
+            const result = await client.graphPath({
+              source_id: input.source_id,
+              target_id: input.target_id,
+              workspace_id: workspaceId,
+              project_id: projectId
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "decisions": {
+            const result = await client.graphDecisions({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              limit: input.limit
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "ingest": {
+            if (!projectId) {
+              return errorResult("ingest requires: project_id");
+            }
+            const result = await client.graphIngest({
+              project_id: projectId,
+              wait: input.wait
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "circular_dependencies": {
+            if (!projectId) {
+              return errorResult("circular_dependencies requires: project_id");
+            }
+            const result = await client.findCircularDependencies(projectId);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "unused_code": {
+            if (!projectId) {
+              return errorResult("unused_code requires: project_id");
+            }
+            const result = await client.findUnusedCode(projectId);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "contradictions": {
+            if (!input.node_id) {
+              return errorResult("contradictions requires: node_id");
+            }
+            const result = await client.findContradictions(input.node_id);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          default:
+            return errorResult(`Unknown action: ${input.action}`);
+        }
+      }
+    );
+    registerTool(
+      "project",
+      {
+        title: "Project",
+        description: `Project management. Actions: list, get, create, update, index (trigger indexing), overview, statistics, files, index_status, ingest_local (index local folder).`,
+        inputSchema: external_exports.object({
+          action: external_exports.enum([
+            "list",
+            "get",
+            "create",
+            "update",
+            "index",
+            "overview",
+            "statistics",
+            "files",
+            "index_status",
+            "ingest_local"
+          ]).describe("Action to perform"),
+          workspace_id: external_exports.string().uuid().optional(),
+          project_id: external_exports.string().uuid().optional(),
+          // Create/update params
+          name: external_exports.string().optional(),
+          description: external_exports.string().optional(),
+          folder_path: external_exports.string().optional(),
+          generate_editor_rules: external_exports.boolean().optional(),
+          // Ingest params
+          path: external_exports.string().optional().describe("Local path to ingest"),
+          overwrite: external_exports.boolean().optional(),
+          write_to_disk: external_exports.boolean().optional(),
+          // Pagination
+          page: external_exports.number().optional(),
+          page_size: external_exports.number().optional()
+        })
+      },
+      async (input) => {
+        const workspaceId = resolveWorkspaceId(input.workspace_id);
+        const projectId = resolveProjectId(input.project_id);
+        switch (input.action) {
+          case "list": {
+            const result = await client.listProjects({
+              workspace_id: workspaceId,
+              page: input.page,
+              page_size: input.page_size
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "get": {
+            if (!projectId) {
+              return errorResult("get requires: project_id");
+            }
+            const result = await client.getProject(projectId);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "create": {
+            if (!input.name) {
+              return errorResult("create requires: name");
+            }
+            const result = await client.createProject({
+              workspace_id: workspaceId,
+              name: input.name,
+              description: input.description,
+              folder_path: input.folder_path,
+              generate_editor_rules: input.generate_editor_rules
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "update": {
+            if (!projectId) {
+              return errorResult("update requires: project_id");
+            }
+            const result = await client.updateProject({
+              project_id: projectId,
+              name: input.name,
+              description: input.description
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "index": {
+            if (!projectId) {
+              return errorResult("index requires: project_id");
+            }
+            const result = await client.indexProject(projectId);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "overview": {
+            if (!projectId) {
+              return errorResult("overview requires: project_id");
+            }
+            const result = await client.projectOverview(projectId);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "statistics": {
+            if (!projectId) {
+              return errorResult("statistics requires: project_id");
+            }
+            const result = await client.projectStatistics(projectId);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "files": {
+            if (!projectId) {
+              return errorResult("files requires: project_id");
+            }
+            const result = await client.projectFiles(projectId);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "index_status": {
+            if (!projectId) {
+              return errorResult("index_status requires: project_id");
+            }
+            const result = await client.projectIndexStatus(projectId);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "ingest_local": {
+            if (!input.path) {
+              return errorResult("ingest_local requires: path");
+            }
+            const validPath = await validateReadableDirectory(input.path);
+            if (!validPath.ok) {
+              return errorResult(validPath.error);
+            }
+            const files = await readAllFilesInBatches(validPath.resolvedPath, async (batch) => {
+              await client.ingestLocalFiles({
+                project_id: projectId,
+                files: batch,
+                overwrite: input.overwrite,
+                write_to_disk: input.write_to_disk
+              });
+            });
+            const result = { files_ingested: files, project_id: projectId };
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          default:
+            return errorResult(`Unknown action: ${input.action}`);
+        }
+      }
+    );
+    registerTool(
+      "workspace",
+      {
+        title: "Workspace",
+        description: `Workspace management. Actions: list, get, associate (link folder to workspace), bootstrap (create workspace and initialize).`,
+        inputSchema: external_exports.object({
+          action: external_exports.enum(["list", "get", "associate", "bootstrap"]).describe("Action to perform"),
+          workspace_id: external_exports.string().uuid().optional(),
+          // Associate/bootstrap params
+          folder_path: external_exports.string().optional(),
+          workspace_name: external_exports.string().optional(),
+          create_parent_mapping: external_exports.boolean().optional(),
+          generate_editor_rules: external_exports.boolean().optional(),
+          // Bootstrap-specific
+          description: external_exports.string().optional(),
+          visibility: external_exports.enum(["private", "public"]).optional(),
+          auto_index: external_exports.boolean().optional(),
+          context_hint: external_exports.string().optional(),
+          // Pagination
+          page: external_exports.number().optional(),
+          page_size: external_exports.number().optional()
+        })
+      },
+      async (input) => {
+        switch (input.action) {
+          case "list": {
+            const result = await client.listWorkspaces({
+              page: input.page,
+              page_size: input.page_size
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "get": {
+            if (!input.workspace_id) {
+              return errorResult("get requires: workspace_id");
+            }
+            const result = await client.getWorkspace(input.workspace_id);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "associate": {
+            if (!input.folder_path || !input.workspace_id) {
+              return errorResult("associate requires: folder_path, workspace_id");
+            }
+            const result = await client.associateWorkspace({
+              folder_path: input.folder_path,
+              workspace_id: input.workspace_id,
+              workspace_name: input.workspace_name,
+              create_parent_mapping: input.create_parent_mapping,
+              generate_editor_rules: input.generate_editor_rules
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "bootstrap": {
+            if (!input.workspace_name) {
+              return errorResult("bootstrap requires: workspace_name");
+            }
+            const result = await client.bootstrapWorkspace({
+              workspace_name: input.workspace_name,
+              folder_path: input.folder_path,
+              description: input.description,
+              visibility: input.visibility,
+              create_parent_mapping: input.create_parent_mapping,
+              generate_editor_rules: input.generate_editor_rules,
+              auto_index: input.auto_index,
+              context_hint: input.context_hint
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          default:
+            return errorResult(`Unknown action: ${input.action}`);
+        }
+      }
+    );
+    registerTool(
+      "reminder",
+      {
+        title: "Reminder",
+        description: `Reminder management. Actions: list, active (pending/overdue), create, snooze, complete, dismiss.`,
+        inputSchema: external_exports.object({
+          action: external_exports.enum(["list", "active", "create", "snooze", "complete", "dismiss"]).describe("Action to perform"),
+          workspace_id: external_exports.string().uuid().optional(),
+          project_id: external_exports.string().uuid().optional(),
+          reminder_id: external_exports.string().uuid().optional(),
+          // Create params
+          title: external_exports.string().optional(),
+          content: external_exports.string().optional(),
+          remind_at: external_exports.string().optional().describe("ISO 8601 datetime"),
+          priority: external_exports.enum(["low", "normal", "high", "urgent"]).optional(),
+          recurrence: external_exports.enum(["daily", "weekly", "monthly"]).optional(),
+          keywords: external_exports.array(external_exports.string()).optional(),
+          // Snooze params
+          until: external_exports.string().optional().describe("ISO 8601 datetime"),
+          // Filter params
+          status: external_exports.enum(["pending", "completed", "dismissed", "snoozed"]).optional(),
+          context: external_exports.string().optional(),
+          limit: external_exports.number().optional()
+        })
+      },
+      async (input) => {
+        const workspaceId = resolveWorkspaceId(input.workspace_id);
+        const projectId = resolveProjectId(input.project_id);
+        switch (input.action) {
+          case "list": {
+            const result = await client.remindersList({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              status: input.status,
+              priority: input.priority,
+              limit: input.limit
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "active": {
+            const result = await client.remindersActive({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              context: input.context,
+              limit: input.limit
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "create": {
+            if (!input.title || !input.content || !input.remind_at) {
+              return errorResult("create requires: title, content, remind_at");
+            }
+            const result = await client.remindersCreate({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              title: input.title,
+              content: input.content,
+              remind_at: input.remind_at,
+              priority: input.priority,
+              recurrence: input.recurrence,
+              keywords: input.keywords
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "snooze": {
+            if (!input.reminder_id || !input.until) {
+              return errorResult("snooze requires: reminder_id, until");
+            }
+            const result = await client.remindersSnooze({
+              reminder_id: input.reminder_id,
+              until: input.until
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "complete": {
+            if (!input.reminder_id) {
+              return errorResult("complete requires: reminder_id");
+            }
+            const result = await client.remindersComplete({
+              reminder_id: input.reminder_id
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "dismiss": {
+            if (!input.reminder_id) {
+              return errorResult("dismiss requires: reminder_id");
+            }
+            const result = await client.remindersDismiss({
+              reminder_id: input.reminder_id
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          default:
+            return errorResult(`Unknown action: ${input.action}`);
+        }
+      }
+    );
+    registerTool(
+      "integration",
+      {
+        title: "Integration",
+        description: `Integration operations for Slack and GitHub. Provider: slack, github, all. Actions: status, search, stats, activity, contributors, knowledge, summary, channels (slack), discussions (slack), repos (github), issues (github).`,
+        inputSchema: external_exports.object({
+          provider: external_exports.enum(["slack", "github", "all"]).describe("Integration provider"),
+          action: external_exports.enum([
+            "status",
+            "search",
+            "stats",
+            "activity",
+            "contributors",
+            "knowledge",
+            "summary",
+            "channels",
+            "discussions",
+            "sync_users",
+            "repos",
+            "issues"
+          ]).describe("Action to perform"),
+          workspace_id: external_exports.string().uuid().optional(),
+          project_id: external_exports.string().uuid().optional(),
+          query: external_exports.string().optional(),
+          limit: external_exports.number().optional(),
+          since: external_exports.string().optional(),
+          until: external_exports.string().optional()
+        })
+      },
+      async (input) => {
+        const workspaceId = resolveWorkspaceId(input.workspace_id);
+        const projectId = resolveProjectId(input.project_id);
+        const integrationGated = await gateIfIntegrationTool(
+          input.provider === "slack" ? "slack_search" : input.provider === "github" ? "github_search" : "integrations_status"
+        );
+        if (integrationGated) return integrationGated;
+        const params = {
+          workspace_id: workspaceId,
+          project_id: projectId,
+          query: input.query,
+          limit: input.limit,
+          since: input.since,
+          until: input.until
+        };
+        switch (input.action) {
+          case "status": {
+            const result = await client.integrationsStatus(params);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "search": {
+            if (input.provider === "slack") {
+              const result = await client.slackSearch(params);
+              return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+            } else if (input.provider === "github") {
+              const result = await client.githubSearch(params);
+              return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+            } else {
+              const result = await client.integrationsSearch(params);
+              return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+            }
+          }
+          case "stats": {
+            if (input.provider === "slack") {
+              const result = await client.slackStats(params);
+              return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+            } else if (input.provider === "github") {
+              const result = await client.githubStats(params);
+              return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+            }
+            return errorResult("stats requires provider: slack or github");
+          }
+          case "activity": {
+            if (input.provider === "slack") {
+              const result = await client.slackActivity(params);
+              return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+            } else if (input.provider === "github") {
+              const result = await client.githubActivity(params);
+              return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+            }
+            return errorResult("activity requires provider: slack or github");
+          }
+          case "contributors": {
+            if (input.provider === "slack") {
+              const result = await client.slackContributors(params);
+              return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+            } else if (input.provider === "github") {
+              const result = await client.githubContributors(params);
+              return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+            }
+            return errorResult("contributors requires provider: slack or github");
+          }
+          case "knowledge": {
+            if (input.provider === "slack") {
+              const result = await client.slackKnowledge(params);
+              return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+            } else if (input.provider === "github") {
+              const result = await client.githubKnowledge(params);
+              return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+            } else {
+              const result = await client.integrationsKnowledge(params);
+              return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+            }
+          }
+          case "summary": {
+            if (input.provider === "slack") {
+              const result = await client.slackSummary(params);
+              return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+            } else if (input.provider === "github") {
+              const result = await client.githubSummary(params);
+              return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+            } else {
+              const result = await client.integrationsSummary(params);
+              return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+            }
+          }
+          case "channels": {
+            if (input.provider !== "slack") {
+              return errorResult("channels is only available for slack provider");
+            }
+            const result = await client.slackChannels(params);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "discussions": {
+            if (input.provider !== "slack") {
+              return errorResult("discussions is only available for slack provider");
+            }
+            const result = await client.slackDiscussions(params);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "sync_users": {
+            if (input.provider !== "slack") {
+              return errorResult("sync_users is only available for slack provider");
+            }
+            const result = await client.slackSyncUsers(params);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "repos": {
+            if (input.provider !== "github") {
+              return errorResult("repos is only available for github provider");
+            }
+            const result = await client.githubRepos(params);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "issues": {
+            if (input.provider !== "github") {
+              return errorResult("issues is only available for github provider");
+            }
+            const result = await client.githubIssues(params);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          default:
+            return errorResult(`Unknown action: ${input.action}`);
+        }
+      }
+    );
+    registerTool(
+      "help",
+      {
+        title: "Help",
+        description: `Utility and help. Actions: tools (list available tools), auth (current user), version (server version), editor_rules (generate AI editor rules), enable_bundle (enable tool bundle in progressive mode).`,
+        inputSchema: external_exports.object({
+          action: external_exports.enum(["tools", "auth", "version", "editor_rules", "enable_bundle"]).describe("Action to perform"),
+          // For tools
+          format: external_exports.enum(["grouped", "minimal", "full"]).optional(),
+          category: external_exports.string().optional(),
+          // For editor_rules
+          folder_path: external_exports.string().optional(),
+          editors: external_exports.array(external_exports.string()).optional(),
+          mode: external_exports.enum(["minimal", "full"]).optional(),
+          dry_run: external_exports.boolean().optional(),
+          workspace_id: external_exports.string().uuid().optional(),
+          workspace_name: external_exports.string().optional(),
+          project_name: external_exports.string().optional(),
+          additional_rules: external_exports.string().optional(),
+          // For enable_bundle
+          bundle: external_exports.enum(["session", "memory", "search", "graph", "workspace", "project", "reminders", "integrations"]).optional(),
+          list_bundles: external_exports.boolean().optional()
+        })
+      },
+      async (input) => {
+        switch (input.action) {
+          case "tools": {
+            const format = input.format || "grouped";
+            const catalog = generateToolCatalog(format, input.category);
+            const consolidatedInfo = CONSOLIDATED_MODE ? `
+
+[Consolidated Mode]
+Domain tools: ${Array.from(CONSOLIDATED_TOOLS).join(", ")}
+Each domain tool has an 'action' parameter for specific operations.` : "";
+            return {
+              content: [{ type: "text", text: catalog + consolidatedInfo }],
+              structuredContent: {
+                format,
+                catalog,
+                consolidated_mode: CONSOLIDATED_MODE,
+                domain_tools: CONSOLIDATED_MODE ? Array.from(CONSOLIDATED_TOOLS) : void 0
+              }
+            };
+          }
+          case "auth": {
+            const result = await client.me();
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "version": {
+            const result = { name: "contextstream-mcp", version: VERSION };
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "editor_rules": {
+            if (!input.folder_path) {
+              return errorResult("editor_rules requires: folder_path");
+            }
+            const result = await generateAllRuleFiles(input.folder_path, {
+              editors: input.editors,
+              mode: input.mode,
+              dryRun: input.dry_run,
+              workspaceId: input.workspace_id,
+              workspaceName: input.workspace_name,
+              projectName: input.project_name,
+              additionalRules: input.additional_rules
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "enable_bundle": {
+            if (input.list_bundles) {
+              const bundles = getBundleInfo();
+              const result2 = {
+                progressive_mode: PROGRESSIVE_MODE,
+                consolidated_mode: CONSOLIDATED_MODE,
+                bundles,
+                hint: CONSOLIDATED_MODE ? "Consolidated mode is enabled. All operations are available via domain tools." : PROGRESSIVE_MODE ? "Progressive mode is enabled. Use enable_bundle to unlock additional tools." : "Neither progressive nor consolidated mode is enabled."
+              };
+              return { content: [{ type: "text", text: formatContent(result2) }], structuredContent: toStructured(result2) };
+            }
+            if (!input.bundle) {
+              return errorResult("enable_bundle requires: bundle (or use list_bundles: true)");
+            }
+            if (CONSOLIDATED_MODE) {
+              return {
+                content: [{ type: "text", text: "Consolidated mode is enabled. All operations are available via domain tools (search, session, memory, graph, project, workspace, reminder, integration, help)." }]
+              };
+            }
+            if (!PROGRESSIVE_MODE) {
+              return {
+                content: [{ type: "text", text: "Progressive mode is not enabled. All tools from your toolset are already available." }]
+              };
+            }
+            const result = enableBundle(input.bundle);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          default:
+            return errorResult(`Unknown action: ${input.action}`);
+        }
+      }
+    );
+    console.error(`[ContextStream] Consolidated mode: Registered ${CONSOLIDATED_TOOLS.size} domain tools.`);
+  }
 }
 
 // src/resources.ts
@@ -14779,6 +15997,7 @@ Environment variables:
   CONTEXTSTREAM_PROGRESSIVE_MODE  Progressive disclosure: true|false (default: false, starts with ~13 core tools)
   CONTEXTSTREAM_ROUTER_MODE   Router pattern: true|false (default: false, exposes only 2 meta-tools)
   CONTEXTSTREAM_OUTPUT_FORMAT Output verbosity: compact|pretty (default: compact, ~30% fewer tokens)
+  CONTEXTSTREAM_CONSOLIDATED  Consolidated domain tools: true|false (default: true in v0.4.x, ~75% token reduction)
   CONTEXTSTREAM_PRO_TOOLS     Optional comma-separated PRO tool names (default: AI tools)
   CONTEXTSTREAM_UPGRADE_URL   Optional upgrade URL shown for PRO tools on Free plan
   CONTEXTSTREAM_ENABLE_PROMPTS Enable MCP prompts list (default: true)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@contextstream/mcp-server",
   "mcpName": "io.github.contextstreamio/mcp-server",
-  "version": "0.3.73",
+  "version": "0.4.1",
   "description": "MCP server exposing ContextStream public API - code context, memory, search, and AI tools for developers",
   "type": "module",
   "license": "MIT",