@plur-ai/mcp 0.3.1 → 0.4.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-var VERSION = "0.3.1";
+var VERSION = "0.4.0";
 var HELP = `plur-mcp v${VERSION} \u2014 persistent memory for AI agents
 
 Usage:
@@ -75,7 +75,7 @@ if (arg === "init") {
   process.exit(0);
 }
 if (arg === "serve" || arg === void 0) {
-  const { runStdio } = await import("./server-ZY2JHPOE.js");
+  const { runStdio } = await import("./server-NPKYZFJ3.js");
   runStdio().catch((err) => {
     console.error("Failed to start PLUR MCP server:", err);
     process.exit(1);

package/dist/{server-ZY2JHPOE.js → server-NPKYZFJ3.js}

@@ -11,9 +11,31 @@ import {
   ErrorCode,
   McpError
 } from "@modelcontextprotocol/sdk/types.js";
-import { Plur, checkForUpdate } from "@plur-ai/core";
+import { Plur as Plur2, checkForUpdate } from "@plur-ai/core";
 
 // src/tools.ts
+import { extractMetaEngrams, validateMetaEngram, confidenceBand } from "@plur-ai/core";
+function makeHttpLlm(baseUrl, apiKey, model = "gpt-4o-mini") {
+  return async (prompt) => {
+    const response = await fetch(`${baseUrl.replace(/\/$/, "")}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        model,
+        messages: [{ role: "user", content: prompt }],
+        temperature: 0.1
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`LLM API error: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data.choices?.[0]?.message?.content ?? "";
+  };
+}
 function getToolDefinitions() {
   return [
     {
@@ -374,6 +396,154 @@ function getToolDefinitions() {
         return plur.syncStatus();
       }
     },
+    {
+      name: "plur_extract_meta",
+      description: "Extract meta-engrams from stored engrams using the 6-stage pipeline (structural analysis \u2192 clustering \u2192 alignment \u2192 formulation \u2192 hierarchy). Requires an LLM API endpoint.",
+      annotations: { title: "Extract meta-engrams", destructiveHint: false, idempotentHint: false },
+      inputSchema: {
+        type: "object",
+        properties: {
+          llm_base_url: { type: "string", description: "OpenAI-compatible API base URL (e.g. https://api.openai.com/v1)" },
+          llm_api_key: { type: "string", description: "API key for the LLM" },
+          llm_model: { type: "string", description: "Model name (default: gpt-4o-mini)" },
+          domain: { type: "string", description: "Filter source engrams by domain prefix" },
+          scope: { type: "string", description: "Filter source engrams by scope" },
+          run_validation: { type: "boolean", description: "Whether to run cross-domain validation (default: false)" },
+          dry_run: { type: "boolean", description: "If true, extract but do not persist meta-engrams (default: false)" }
+        },
+        required: ["llm_base_url", "llm_api_key"]
+      },
+      handler: async (args, plur) => {
+        const llm = makeHttpLlm(
+          args.llm_base_url,
+          args.llm_api_key,
+          args.llm_model
+        );
+        const sourceEngrams = plur.list({
+          domain: args.domain,
+          scope: args.scope
+        });
+        const existingMetas = plur.list().filter((e) => e.id.startsWith("META-"));
+        const result = await extractMetaEngrams(sourceEngrams, llm, {
+          run_validation: args.run_validation,
+          existing_metas: existingMetas
+        });
+        const isDryRun = args.dry_run === true;
+        let saveStats = null;
+        if (!isDryRun && result.results.length > 0) {
+          saveStats = plur.saveMetaEngrams(result.results);
+        }
+        return {
+          engrams_analyzed: result.engrams_analyzed,
+          clusters_found: result.clusters_found,
+          alignments_passed: result.alignments_passed,
+          meta_engrams_extracted: result.meta_engrams_extracted,
+          rejected_as_platitudes: result.rejected_as_platitudes,
+          duration_ms: result.duration_ms,
+          dry_run: isDryRun,
+          ...saveStats ? { saved: saveStats.saved, skipped: saveStats.skipped } : {},
+          results: result.results.map((m) => ({
+            id: m.id,
+            statement: m.statement,
+            domain: m.domain,
+            confidence: m.structured_data?.meta?.confidence?.composite ?? 0,
+            confidence_band: confidenceBand(m.structured_data?.meta?.confidence?.composite ?? 0),
+            hierarchy_level: m.structured_data?.meta?.hierarchy?.level ?? "mop"
+          }))
+        };
+      }
+    },
+    {
+      name: "plur_meta_engrams",
+      description: "List existing meta-engrams (engrams with META- prefix) with their structural templates and confidence scores",
+      annotations: { title: "List meta-engrams", readOnlyHint: true, idempotentHint: true },
+      inputSchema: {
+        type: "object",
+        properties: {
+          domain: { type: "string", description: "Filter by domain prefix (e.g. meta, meta.trading)" },
+          min_confidence: { type: "number", description: "Minimum composite confidence score (0-1)" },
+          hierarchy_level: { type: "string", enum: ["mop", "top"], description: "Filter by hierarchy level" },
+          limit: { type: "number", description: "Max results to return (default 20)" }
+        }
+      },
+      handler: async (args, plur) => {
+        const allEngrams = plur.list();
+        const metaEngrams = allEngrams.filter((e) => e.id.startsWith("META-"));
+        const minConfidence = args.min_confidence ?? 0;
+        const levelFilter = args.hierarchy_level;
+        const domainFilter = args.domain;
+        const limit = args.limit ?? 20;
+        const filtered = metaEngrams.filter((m) => {
+          const mf = m.structured_data?.meta;
+          if (!mf) return false;
+          if (mf.confidence?.composite < minConfidence) return false;
+          if (levelFilter && mf.hierarchy?.level !== levelFilter) return false;
+          if (domainFilter && !m.domain?.startsWith(domainFilter)) return false;
+          return true;
+        }).slice(0, limit);
+        return {
+          results: filtered.map((m) => {
+            const mf = m.structured_data?.meta;
+            return {
+              id: m.id,
+              statement: m.statement,
+              domain: m.domain,
+              template: mf?.structure?.template,
+              hierarchy_level: mf?.hierarchy?.level,
+              confidence: mf?.confidence?.composite,
+              confidence_band: confidenceBand(mf?.confidence?.composite ?? 0),
+              evidence_count: mf?.confidence?.evidence_count,
+              domain_count: mf?.confidence?.domain_count,
+              validated_domains: mf?.domain_coverage?.validated
+            };
+          }),
+          count: filtered.length,
+          total_meta_engrams: metaEngrams.length
+        };
+      }
+    },
+    {
+      name: "plur_validate_meta",
+      description: "Test a meta-engram template against engrams from a new domain \u2014 updates confidence and domain_coverage",
+      annotations: { title: "Validate meta-engram", destructiveHint: false, idempotentHint: false },
+      inputSchema: {
+        type: "object",
+        properties: {
+          meta_engram_id: { type: "string", description: "META- engram ID to validate" },
+          test_domain: { type: "string", description: "Domain to test against (e.g. medicine)" },
+          llm_base_url: { type: "string", description: "OpenAI-compatible API base URL" },
+          llm_api_key: { type: "string", description: "API key for the LLM" },
+          llm_model: { type: "string", description: "Model name (default: gpt-4o-mini)" }
+        },
+        required: ["meta_engram_id", "test_domain", "llm_base_url", "llm_api_key"]
+      },
+      handler: async (args, plur) => {
+        const allEngrams = plur.list();
+        const meta = allEngrams.find((e) => e.id === args.meta_engram_id);
+        if (!meta) {
+          throw new Error(`Meta-engram not found: ${args.meta_engram_id}`);
+        }
+        const testDomain = args.test_domain;
+        const testEngrams = plur.list({ domain: testDomain });
+        const llm = makeHttpLlm(
+          args.llm_base_url,
+          args.llm_api_key,
+          args.llm_model
+        );
+        const result = await validateMetaEngram(meta, testEngrams, testDomain, llm);
+        plur.updateEngram(meta);
+        return {
+          meta_engram_id: result.meta_engram_id,
+          test_domain: result.test_domain,
+          prediction_held: result.prediction_held,
+          matching_engram_id: result.matching_engram_id,
+          alignment_score: result.alignment_score,
+          rationale: result.rationale,
+          updated_confidence: meta.structured_data?.meta?.confidence?.composite,
+          updated_confidence_band: confidenceBand(meta.structured_data?.meta?.confidence?.composite ?? 0)
+        };
+      }
+    },
     {
       name: "plur_status",
       description: "Return system health \u2014 engram count, episode count, pack count, storage root",
@@ -397,7 +567,7 @@ function getToolDefinitions() {
 
 // src/server.ts
 import { z } from "zod";
-var VERSION = "0.3.1";
+var VERSION = "0.4.0";
 var INSTRUCTIONS = `PLUR is your persistent memory. It stores corrections, preferences, and conventions as engrams that persist across sessions.
 
 Use PLUR proactively:
@@ -479,7 +649,7 @@ Use \`scope\` to namespace engrams per project:
 Override with \`PLUR_PATH\` environment variable.
 `;
 async function createServer(plur) {
-  const instance = plur ?? new Plur();
+  const instance = plur ?? new Plur2();
   const tools = getToolDefinitions();
   checkForUpdate("@plur-ai/mcp", VERSION, (r) => {
     if (r.updateAvailable) {

package/package.json

@@ -1,10 +1,9 @@
 {
   "name": "@plur-ai/mcp",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "type": "module",
   "bin": {
-    "plur-mcp": "dist/index.js",
-    "plur": "dist/index.js"
+    "plur-mcp": "dist/index.js"
   },
   "main": "dist/index.js",
   "files": [
@@ -13,7 +12,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",
     "zod": "^3.23.0",
-    "@plur-ai/core": "0.3.1"
+    "@plur-ai/core": "0.4.0"
   },
   "devDependencies": {
     "@types/node": "^25.5.0"