@plur-ai/mcp 0.2.3 → 0.2.4

package/dist/index.js

@@ -1,403 +1,8 @@
 #!/usr/bin/env node
 
-// src/server.ts
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import { Plur, checkForUpdate } from "@plur-ai/core";
-
-// src/tools.ts
-function getToolDefinitions() {
-  return [
-    {
-      name: "plur.learn",
-      description: "Create an engram \u2014 record a reusable learning, preference, or correction",
-      inputSchema: {
-        type: "object",
-        properties: {
-          statement: { type: "string", description: "The knowledge assertion to store" },
-          type: {
-            type: "string",
-            enum: ["behavioral", "terminological", "procedural", "architectural"],
-            description: "Category of the engram"
-          },
-          scope: { type: "string", description: "Namespace, e.g. global, project:myapp" },
-          domain: { type: "string", description: "Domain tag, e.g. software.deployment" },
-          source: { type: "string", description: "Origin of this knowledge" }
-        },
-        required: ["statement"]
-      },
-      handler: async (args, plur) => {
-        const engram = plur.learn(args.statement, {
-          type: args.type,
-          scope: args.scope,
-          domain: args.domain,
-          source: args.source
-        });
-        return { id: engram.id, statement: engram.statement, scope: engram.scope, type: engram.type };
-      }
-    },
-    {
-      name: "plur.recall",
-      description: "Query engrams by semantic similarity \u2014 retrieve relevant learned knowledge",
-      inputSchema: {
-        type: "object",
-        properties: {
-          query: { type: "string", description: "Search query to find relevant engrams" },
-          scope: { type: "string", description: "Filter by scope (also includes global)" },
-          domain: { type: "string", description: "Filter by domain prefix" },
-          limit: { type: "number", description: "Max results to return (default 20)" },
-          min_strength: { type: "number", description: "Minimum retrieval strength (0-1)" }
-        },
-        required: ["query"]
-      },
-      handler: async (args, plur) => {
-        const results = plur.recall(args.query, {
-          scope: args.scope,
-          domain: args.domain,
-          limit: args.limit,
-          min_strength: args.min_strength
-        });
-        return {
-          results: results.map((e) => ({
-            id: e.id,
-            statement: e.statement,
-            type: e.type,
-            scope: e.scope,
-            domain: e.domain,
-            retrieval_strength: e.activation.retrieval_strength
-          })),
-          count: results.length
-        };
-      }
-    },
-    {
-      name: "plur.recall.hybrid",
-      description: "Hybrid search \u2014 BM25 + local embeddings merged via Reciprocal Rank Fusion. No API calls, fully local. Best default for most use cases.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          query: { type: "string", description: "Search query to find relevant engrams" },
-          scope: { type: "string", description: "Filter by scope (also includes global)" },
-          domain: { type: "string", description: "Filter by domain prefix" },
-          limit: { type: "number", description: "Max results to return (default 20)" },
-          min_strength: { type: "number", description: "Minimum retrieval strength (0-1)" }
-        },
-        required: ["query"]
-      },
-      handler: async (args, plur) => {
-        const results = await plur.recallHybrid(args.query, {
-          scope: args.scope,
-          domain: args.domain,
-          limit: args.limit,
-          min_strength: args.min_strength
-        });
-        return {
-          results: results.map((e) => ({
-            id: e.id,
-            statement: e.statement,
-            type: e.type,
-            scope: e.scope,
-            domain: e.domain,
-            retrieval_strength: e.activation.retrieval_strength
-          })),
-          count: results.length,
-          mode: "hybrid"
-        };
-      }
-    },
-    {
-      name: "plur.inject",
-      description: "Get a scored context injection for a task \u2014 returns directives and considerations within token budget",
-      inputSchema: {
-        type: "object",
-        properties: {
-          task: { type: "string", description: "The task description to inject context for" },
-          budget: { type: "number", description: "Token budget for injection (default 2000)" },
-          scope: { type: "string", description: "Scope filter for engram selection" }
-        },
-        required: ["task"]
-      },
-      handler: async (args, plur) => {
-        const result = plur.inject(args.task, {
-          budget: args.budget,
-          scope: args.scope
-        });
-        return {
-          directives: result.directives,
-          consider: result.consider,
-          count: result.count,
-          tokens_used: result.tokens_used
-        };
-      }
-    },
-    {
-      name: "plur.feedback",
-      description: "Rate an engram's usefulness \u2014 trains injection relevance over time",
-      inputSchema: {
-        type: "object",
-        properties: {
-          id: { type: "string", description: "Engram ID (e.g. ENG-001)" },
-          signal: {
-            type: "string",
-            enum: ["positive", "negative", "neutral"],
-            description: "Feedback signal to apply"
-          }
-        },
-        required: ["id", "signal"]
-      },
-      handler: async (args, plur) => {
-        plur.feedback(args.id, args.signal);
-        return { success: true, id: args.id, signal: args.signal };
-      }
-    },
-    {
-      name: "plur.forget",
-      description: "Retire an engram \u2014 marks it as no longer active without deleting history",
-      inputSchema: {
-        type: "object",
-        properties: {
-          id: { type: "string", description: "Engram ID to retire" },
-          reason: { type: "string", description: "Optional reason for retiring this engram" }
-        },
-        required: ["id"]
-      },
-      handler: async (args, plur) => {
-        plur.forget(args.id, args.reason);
-        return { success: true, id: args.id, status: "retired" };
-      }
-    },
-    {
-      name: "plur.capture",
-      description: "Append an episode to the episodic timeline \u2014 records what happened in a session",
-      inputSchema: {
-        type: "object",
-        properties: {
-          summary: { type: "string", description: "What happened or was accomplished" },
-          agent: { type: "string", description: "Agent identifier capturing this episode" },
-          channel: { type: "string", description: "Communication channel (e.g. claude-code, chat)" },
-          session_id: { type: "string", description: "Session identifier for grouping episodes" },
-          tags: {
-            type: "array",
-            items: { type: "string" },
-            description: "Tags for categorizing the episode"
-          }
-        },
-        required: ["summary"]
-      },
-      handler: async (args, plur) => {
-        const episode = plur.capture(args.summary, {
-          agent: args.agent,
-          channel: args.channel,
-          session_id: args.session_id,
-          tags: args.tags
-        });
-        return { id: episode.id, summary: episode.summary, timestamp: episode.timestamp };
-      }
-    },
-    {
-      name: "plur.timeline",
-      description: "Query the episodic timeline \u2014 retrieve past episodes filtered by time, agent, or search",
-      inputSchema: {
-        type: "object",
-        properties: {
-          since: { type: "string", description: "ISO date string \u2014 only episodes after this time" },
-          until: { type: "string", description: "ISO date string \u2014 only episodes before this time" },
-          agent: { type: "string", description: "Filter by agent identifier" },
-          channel: { type: "string", description: "Filter by channel" },
-          search: { type: "string", description: "Full-text search within episode summaries" }
-        }
-      },
-      handler: async (args, plur) => {
-        const query = {};
-        if (args.since) query.since = new Date(args.since);
-        if (args.until) query.until = new Date(args.until);
-        if (args.agent) query.agent = args.agent;
-        if (args.channel) query.channel = args.channel;
-        if (args.search) query.search = args.search;
-        const episodes = plur.timeline(Object.keys(query).length > 0 ? query : void 0);
-        return {
-          episodes: episodes.map((e) => ({
-            id: e.id,
-            summary: e.summary,
-            timestamp: e.timestamp,
-            agent: e.agent,
-            channel: e.channel,
-            tags: e.tags
-          })),
-          count: episodes.length
-        };
-      }
-    },
-    {
-      name: "plur.ingest",
-      description: "Extract engram candidates from content using pattern matching \u2014 optionally auto-save them",
-      inputSchema: {
-        type: "object",
-        properties: {
-          content: { type: "string", description: "Text content to extract learnings from" },
-          source: { type: "string", description: "Source attribution for extracted engrams" },
-          extract_only: {
-            type: "boolean",
-            description: "If true, return candidates without saving (default false \u2014 saves automatically)"
-          },
-          scope: { type: "string", description: "Scope to assign to saved engrams" },
-          domain: { type: "string", description: "Domain to assign to saved engrams" }
-        },
-        required: ["content"]
-      },
-      handler: async (args, plur) => {
-        const candidates = plur.ingest(args.content, {
-          source: args.source,
-          extract_only: args.extract_only,
-          scope: args.scope,
-          domain: args.domain
-        });
-        return {
-          candidates: candidates.map((c) => ({
-            statement: c.statement,
-            type: c.type,
-            source: c.source
-          })),
-          count: candidates.length,
-          saved: !(args.extract_only ?? false)
-        };
-      }
-    },
-    {
-      name: "plur.packs.install",
-      description: "Install an engram pack from a directory path \u2014 adds curated engrams to the store",
-      inputSchema: {
-        type: "object",
-        properties: {
-          source: { type: "string", description: "Path to the pack directory to install" }
-        },
-        required: ["source"]
-      },
-      handler: async (args, plur) => {
-        const result = plur.installPack(args.source);
-        return { installed: result.installed, name: result.name, success: true };
-      }
-    },
-    {
-      name: "plur.packs.list",
-      description: "List all installed engram packs",
-      inputSchema: {
-        type: "object",
-        properties: {}
-      },
-      handler: async (_args, plur) => {
-        const packs = plur.listPacks();
-        return {
-          packs: packs.map((p) => ({
-            name: p.name,
-            version: p.version,
-            description: p.description,
-            engram_count: p.engram_count
-          })),
-          count: packs.length
-        };
-      }
-    },
-    {
-      name: "plur.sync",
-      description: "Sync engrams via git \u2014 initializes repo on first call, commits and pushes/pulls on subsequent calls. Provide a remote URL on first call to enable cross-device sync.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          remote: {
-            type: "string",
-            description: "Git remote URL (e.g. git@github.com:user/plur-engrams.git). Only needed on first call to set up remote."
-          }
-        }
-      },
-      handler: async (args, plur) => {
-        const result = plur.sync(args.remote);
-        return result;
-      }
-    },
-    {
-      name: "plur.sync.status",
-      description: "Check git sync status \u2014 whether repo is initialized, has remote, is dirty, ahead/behind counts",
-      inputSchema: {
-        type: "object",
-        properties: {}
-      },
-      handler: async (_args, plur) => {
-        return plur.syncStatus();
-      }
-    },
-    {
-      name: "plur.status",
-      description: "Return system health \u2014 engram count, episode count, pack count, storage root",
-      inputSchema: {
-        type: "object",
-        properties: {}
-      },
-      handler: async (_args, plur) => {
-        const status = plur.status();
-        return {
-          engram_count: status.engram_count,
-          episode_count: status.episode_count,
-          pack_count: status.pack_count,
-          storage_root: status.storage_root
-        };
-      }
-    }
-  ];
-}
-
-// src/server.ts
-var VERSION = "0.2.3";
-async function createServer(plur) {
-  const instance = plur ?? new Plur();
-  const tools = getToolDefinitions();
-  checkForUpdate("@plur-ai/mcp", VERSION, (r) => {
-    if (r.updateAvailable) {
-      console.error(`[plur] Update available: ${r.current} \u2192 ${r.latest}. Run: npx @plur-ai/mcp@latest`);
-    }
-  });
-  const server = new Server(
-    { name: "plur-mcp", version: VERSION },
-    { capabilities: { tools: {} } }
-  );
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: tools.map((t) => ({
-      name: t.name,
-      description: t.description,
-      inputSchema: t.inputSchema
-    }))
-  }));
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const tool = tools.find((t) => t.name === request.params.name);
-    if (!tool) {
-      return {
-        content: [{ type: "text", text: `Unknown tool: ${request.params.name}` }],
-        isError: true
-      };
-    }
-    try {
-      const result = await tool.handler(request.params.arguments ?? {}, instance);
-      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
-    } catch (err) {
-      return {
-        content: [{ type: "text", text: `Error: ${err.message}` }],
-        isError: true
-      };
-    }
-  });
-  return server;
-}
-async function runStdio() {
-  const server = await createServer();
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-}
-
 // src/index.ts
-import { detectPlurStorage } from "@plur-ai/core";
-var VERSION2 = "0.2.3";
-var HELP = `plur-mcp v${VERSION2} \u2014 persistent memory for AI agents
+var VERSION = "0.2.4";
+var HELP = `plur-mcp v${VERSION} \u2014 persistent memory for AI agents
 
 Usage:
   plur-mcp              Start the MCP server (stdio transport)
@@ -425,11 +30,12 @@ if (arg === "--help" || arg === "-h") {
   process.exit(0);
 }
 if (arg === "--version" || arg === "-v") {
-  process.stdout.write(`${VERSION2}
+  process.stdout.write(`${VERSION}
 `);
   process.exit(0);
 }
 if (arg === "init") {
+  const { detectPlurStorage } = await import("@plur-ai/core");
   const paths = detectPlurStorage();
   process.stdout.write(`PLUR initialized.
 
@@ -463,6 +69,7 @@ if (arg === "init") {
   process.exit(0);
 }
 if (arg === "serve" || arg === void 0) {
+  const { runStdio } = await import("./server-ZKOBQAZR.js");
   runStdio().catch((err) => {
     console.error("Failed to start PLUR MCP server:", err);
     process.exit(1);

package/dist/server-ZKOBQAZR.js

@@ -0,0 +1,397 @@
+// src/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { Plur, checkForUpdate } from "@plur-ai/core";
+
+// src/tools.ts
+function getToolDefinitions() {
+  return [
+    {
+      name: "plur.learn",
+      description: "Create an engram \u2014 record a reusable learning, preference, or correction",
+      inputSchema: {
+        type: "object",
+        properties: {
+          statement: { type: "string", description: "The knowledge assertion to store" },
+          type: {
+            type: "string",
+            enum: ["behavioral", "terminological", "procedural", "architectural"],
+            description: "Category of the engram"
+          },
+          scope: { type: "string", description: "Namespace, e.g. global, project:myapp" },
+          domain: { type: "string", description: "Domain tag, e.g. software.deployment" },
+          source: { type: "string", description: "Origin of this knowledge" }
+        },
+        required: ["statement"]
+      },
+      handler: async (args, plur) => {
+        const engram = plur.learn(args.statement, {
+          type: args.type,
+          scope: args.scope,
+          domain: args.domain,
+          source: args.source
+        });
+        return { id: engram.id, statement: engram.statement, scope: engram.scope, type: engram.type };
+      }
+    },
+    {
+      name: "plur.recall",
+      description: "Query engrams by semantic similarity \u2014 retrieve relevant learned knowledge",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "Search query to find relevant engrams" },
+          scope: { type: "string", description: "Filter by scope (also includes global)" },
+          domain: { type: "string", description: "Filter by domain prefix" },
+          limit: { type: "number", description: "Max results to return (default 20)" },
+          min_strength: { type: "number", description: "Minimum retrieval strength (0-1)" }
+        },
+        required: ["query"]
+      },
+      handler: async (args, plur) => {
+        const results = plur.recall(args.query, {
+          scope: args.scope,
+          domain: args.domain,
+          limit: args.limit,
+          min_strength: args.min_strength
+        });
+        return {
+          results: results.map((e) => ({
+            id: e.id,
+            statement: e.statement,
+            type: e.type,
+            scope: e.scope,
+            domain: e.domain,
+            retrieval_strength: e.activation.retrieval_strength
+          })),
+          count: results.length
+        };
+      }
+    },
+    {
+      name: "plur.recall.hybrid",
+      description: "Hybrid search \u2014 BM25 + local embeddings merged via Reciprocal Rank Fusion. No API calls, fully local. Best default for most use cases.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "Search query to find relevant engrams" },
+          scope: { type: "string", description: "Filter by scope (also includes global)" },
+          domain: { type: "string", description: "Filter by domain prefix" },
+          limit: { type: "number", description: "Max results to return (default 20)" },
+          min_strength: { type: "number", description: "Minimum retrieval strength (0-1)" }
+        },
+        required: ["query"]
+      },
+      handler: async (args, plur) => {
+        const results = await plur.recallHybrid(args.query, {
+          scope: args.scope,
+          domain: args.domain,
+          limit: args.limit,
+          min_strength: args.min_strength
+        });
+        return {
+          results: results.map((e) => ({
+            id: e.id,
+            statement: e.statement,
+            type: e.type,
+            scope: e.scope,
+            domain: e.domain,
+            retrieval_strength: e.activation.retrieval_strength
+          })),
+          count: results.length,
+          mode: "hybrid"
+        };
+      }
+    },
+    {
+      name: "plur.inject",
+      description: "Get a scored context injection for a task \u2014 returns directives and considerations within token budget",
+      inputSchema: {
+        type: "object",
+        properties: {
+          task: { type: "string", description: "The task description to inject context for" },
+          budget: { type: "number", description: "Token budget for injection (default 2000)" },
+          scope: { type: "string", description: "Scope filter for engram selection" }
+        },
+        required: ["task"]
+      },
+      handler: async (args, plur) => {
+        const result = plur.inject(args.task, {
+          budget: args.budget,
+          scope: args.scope
+        });
+        return {
+          directives: result.directives,
+          consider: result.consider,
+          count: result.count,
+          tokens_used: result.tokens_used
+        };
+      }
+    },
+    {
+      name: "plur.feedback",
+      description: "Rate an engram's usefulness \u2014 trains injection relevance over time",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "Engram ID (e.g. ENG-001)" },
+          signal: {
+            type: "string",
+            enum: ["positive", "negative", "neutral"],
+            description: "Feedback signal to apply"
+          }
+        },
+        required: ["id", "signal"]
+      },
+      handler: async (args, plur) => {
+        plur.feedback(args.id, args.signal);
+        return { success: true, id: args.id, signal: args.signal };
+      }
+    },
+    {
+      name: "plur.forget",
+      description: "Retire an engram \u2014 marks it as no longer active without deleting history",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "Engram ID to retire" },
+          reason: { type: "string", description: "Optional reason for retiring this engram" }
+        },
+        required: ["id"]
+      },
+      handler: async (args, plur) => {
+        plur.forget(args.id, args.reason);
+        return { success: true, id: args.id, status: "retired" };
+      }
+    },
+    {
+      name: "plur.capture",
+      description: "Append an episode to the episodic timeline \u2014 records what happened in a session",
+      inputSchema: {
+        type: "object",
+        properties: {
+          summary: { type: "string", description: "What happened or was accomplished" },
+          agent: { type: "string", description: "Agent identifier capturing this episode" },
+          channel: { type: "string", description: "Communication channel (e.g. claude-code, chat)" },
+          session_id: { type: "string", description: "Session identifier for grouping episodes" },
+          tags: {
+            type: "array",
+            items: { type: "string" },
+            description: "Tags for categorizing the episode"
+          }
+        },
+        required: ["summary"]
+      },
+      handler: async (args, plur) => {
+        const episode = plur.capture(args.summary, {
+          agent: args.agent,
+          channel: args.channel,
+          session_id: args.session_id,
+          tags: args.tags
+        });
+        return { id: episode.id, summary: episode.summary, timestamp: episode.timestamp };
+      }
+    },
+    {
+      name: "plur.timeline",
+      description: "Query the episodic timeline \u2014 retrieve past episodes filtered by time, agent, or search",
+      inputSchema: {
+        type: "object",
+        properties: {
+          since: { type: "string", description: "ISO date string \u2014 only episodes after this time" },
+          until: { type: "string", description: "ISO date string \u2014 only episodes before this time" },
+          agent: { type: "string", description: "Filter by agent identifier" },
+          channel: { type: "string", description: "Filter by channel" },
+          search: { type: "string", description: "Full-text search within episode summaries" }
+        }
+      },
+      handler: async (args, plur) => {
+        const query = {};
+        if (args.since) query.since = new Date(args.since);
+        if (args.until) query.until = new Date(args.until);
+        if (args.agent) query.agent = args.agent;
+        if (args.channel) query.channel = args.channel;
+        if (args.search) query.search = args.search;
+        const episodes = plur.timeline(Object.keys(query).length > 0 ? query : void 0);
+        return {
+          episodes: episodes.map((e) => ({
+            id: e.id,
+            summary: e.summary,
+            timestamp: e.timestamp,
+            agent: e.agent,
+            channel: e.channel,
+            tags: e.tags
+          })),
+          count: episodes.length
+        };
+      }
+    },
+    {
+      name: "plur.ingest",
+      description: "Extract engram candidates from content using pattern matching \u2014 optionally auto-save them",
+      inputSchema: {
+        type: "object",
+        properties: {
+          content: { type: "string", description: "Text content to extract learnings from" },
+          source: { type: "string", description: "Source attribution for extracted engrams" },
+          extract_only: {
+            type: "boolean",
+            description: "If true, return candidates without saving (default false \u2014 saves automatically)"
+          },
+          scope: { type: "string", description: "Scope to assign to saved engrams" },
+          domain: { type: "string", description: "Domain to assign to saved engrams" }
+        },
+        required: ["content"]
+      },
+      handler: async (args, plur) => {
+        const candidates = plur.ingest(args.content, {
+          source: args.source,
+          extract_only: args.extract_only,
+          scope: args.scope,
+          domain: args.domain
+        });
+        return {
+          candidates: candidates.map((c) => ({
+            statement: c.statement,
+            type: c.type,
+            source: c.source
+          })),
+          count: candidates.length,
+          saved: !(args.extract_only ?? false)
+        };
+      }
+    },
+    {
+      name: "plur.packs.install",
+      description: "Install an engram pack from a directory path \u2014 adds curated engrams to the store",
+      inputSchema: {
+        type: "object",
+        properties: {
+          source: { type: "string", description: "Path to the pack directory to install" }
+        },
+        required: ["source"]
+      },
+      handler: async (args, plur) => {
+        const result = plur.installPack(args.source);
+        return { installed: result.installed, name: result.name, success: true };
+      }
+    },
+    {
+      name: "plur.packs.list",
+      description: "List all installed engram packs",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      },
+      handler: async (_args, plur) => {
+        const packs = plur.listPacks();
+        return {
+          packs: packs.map((p) => ({
+            name: p.name,
+            version: p.version,
+            description: p.description,
+            engram_count: p.engram_count
+          })),
+          count: packs.length
+        };
+      }
+    },
+    {
+      name: "plur.sync",
+      description: "Sync engrams via git \u2014 initializes repo on first call, commits and pushes/pulls on subsequent calls. Provide a remote URL on first call to enable cross-device sync.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          remote: {
+            type: "string",
+            description: "Git remote URL (e.g. git@github.com:user/plur-engrams.git). Only needed on first call to set up remote."
+          }
+        }
+      },
+      handler: async (args, plur) => {
+        const result = plur.sync(args.remote);
+        return result;
+      }
+    },
+    {
+      name: "plur.sync.status",
+      description: "Check git sync status \u2014 whether repo is initialized, has remote, is dirty, ahead/behind counts",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      },
+      handler: async (_args, plur) => {
+        return plur.syncStatus();
+      }
+    },
+    {
+      name: "plur.status",
+      description: "Return system health \u2014 engram count, episode count, pack count, storage root",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      },
+      handler: async (_args, plur) => {
+        const status = plur.status();
+        return {
+          engram_count: status.engram_count,
+          episode_count: status.episode_count,
+          pack_count: status.pack_count,
+          storage_root: status.storage_root
+        };
+      }
+    }
+  ];
+}
+
+// src/server.ts
+var VERSION = "0.2.4";
+async function createServer(plur) {
+  const instance = plur ?? new Plur();
+  const tools = getToolDefinitions();
+  checkForUpdate("@plur-ai/mcp", VERSION, (r) => {
+    if (r.updateAvailable) {
+      console.error(`[plur] Update available: ${r.current} \u2192 ${r.latest}. Run: npx @plur-ai/mcp@latest`);
+    }
+  });
+  const server = new Server(
+    { name: "plur-mcp", version: VERSION },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      inputSchema: t.inputSchema
+    }))
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const tool = tools.find((t) => t.name === request.params.name);
+    if (!tool) {
+      return {
+        content: [{ type: "text", text: `Unknown tool: ${request.params.name}` }],
+        isError: true
+      };
+    }
+    try {
+      const result = await tool.handler(request.params.arguments ?? {}, instance);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    } catch (err) {
+      return {
+        content: [{ type: "text", text: `Error: ${err.message}` }],
+        isError: true
+      };
+    }
+  });
+  return server;
+}
+async function runStdio() {
+  const server = await createServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+export {
+  createServer,
+  runStdio
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plur-ai/mcp",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "type": "module",
   "bin": {
     "plur-mcp": "dist/index.js",
@@ -13,7 +13,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",
     "zod": "^3.23.0",
-    "@plur-ai/core": "0.2.3"
+    "@plur-ai/core": "0.2.4"
   },
   "devDependencies": {
     "@types/node": "^25.5.0"