@plures/praxis 1.2.41 → 1.4.0

package/dist/node/server-SYZPDULV.js

@@ -0,0 +1,361 @@
+import {
+  auditCompleteness,
+  formatReport
+} from "./chunk-2IUFZBH3.js";
+import {
+  getContractFromDescriptor
+} from "./chunk-PGVSB6NR.js";
+import {
+  LogicEngine,
+  RuleResult
+} from "./chunk-KMJWAFZV.js";
+import "./chunk-QGM4M3NI.js";
+
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+function createPraxisMcpServer(options) {
+  const {
+    name = "@plures/praxis",
+    version = "1.0.0",
+    initialContext,
+    registry,
+    initialFacts
+  } = options;
+  const engine = new LogicEngine({
+    initialContext,
+    registry,
+    initialFacts
+  });
+  const server = new McpServer({
+    name,
+    version
+  });
+  server.tool(
+    "praxis.inspect",
+    "List all registered rules, constraints, and their contracts",
+    {
+      filter: z.string().optional().describe("Filter rule/constraint IDs by pattern (substring match)"),
+      includeContracts: z.boolean().optional().describe("Include full contract details (default: false)")
+    },
+    async (params) => {
+      const filter = params.filter;
+      const includeContracts = params.includeContracts ?? false;
+      let rules = registry.getAllRules();
+      let constraints = registry.getAllConstraints();
+      if (filter) {
+        rules = rules.filter((r) => r.id.includes(filter));
+        constraints = constraints.filter((c) => c.id.includes(filter));
+      }
+      const ruleInfos = rules.map((r) => {
+        const contract = getContractFromDescriptor(r);
+        return {
+          id: r.id,
+          description: r.description,
+          eventTypes: r.eventTypes,
+          hasContract: !!contract,
+          contract: includeContracts ? contract : void 0,
+          meta: r.meta
+        };
+      });
+      const constraintInfos = constraints.map((c) => {
+        const contract = getContractFromDescriptor(c);
+        return {
+          id: c.id,
+          description: c.description,
+          hasContract: !!contract,
+          contract: includeContracts ? contract : void 0,
+          meta: c.meta
+        };
+      });
+      const output = {
+        rules: ruleInfos,
+        constraints: constraintInfos,
+        summary: {
+          totalRules: ruleInfos.length,
+          totalConstraints: constraintInfos.length,
+          rulesWithContracts: ruleInfos.filter((r) => r.hasContract).length,
+          constraintsWithContracts: constraintInfos.filter((c) => c.hasContract).length
+        }
+      };
+      return { content: [{ type: "text", text: JSON.stringify(output, null, 2) }] };
+    }
+  );
+  server.tool(
+    "praxis.evaluate",
+    "Run a specific rule against given events and return the result",
+    {
+      ruleId: z.string().describe("The rule ID to evaluate"),
+      events: z.array(z.object({
+        tag: z.string(),
+        payload: z.unknown()
+      })).describe("Events to process through the rule")
+    },
+    async (params) => {
+      const rule = registry.getRule(params.ruleId);
+      if (!rule) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: `Rule "${params.ruleId}" not found` }) }]
+        };
+      }
+      const state = engine.getState();
+      const stateWithEvents = { ...state, events: params.events };
+      try {
+        const rawResult = rule.impl(stateWithEvents, params.events);
+        let output;
+        if (rawResult instanceof RuleResult) {
+          output = {
+            ruleId: params.ruleId,
+            resultKind: rawResult.kind,
+            facts: rawResult.facts,
+            retractedTags: rawResult.retractTags,
+            reason: rawResult.reason,
+            diagnostics: []
+          };
+        } else if (Array.isArray(rawResult)) {
+          output = {
+            ruleId: params.ruleId,
+            resultKind: "emit",
+            facts: rawResult,
+            retractedTags: [],
+            diagnostics: []
+          };
+        } else {
+          output = {
+            ruleId: params.ruleId,
+            resultKind: "noop",
+            facts: [],
+            retractedTags: [],
+            diagnostics: []
+          };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(output, null, 2) }] };
+      } catch (error) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              error: `Rule evaluation failed: ${error instanceof Error ? error.message : String(error)}`,
+              ruleId: params.ruleId
+            })
+          }]
+        };
+      }
+    }
+  );
+  server.tool(
+    "praxis.audit",
+    "Run completeness audit against a manifest and return the report",
+    {
+      branches: z.array(z.object({
+        location: z.string(),
+        condition: z.string(),
+        kind: z.enum(["domain", "invariant", "ui", "transport", "wiring", "transform"]),
+        coveredBy: z.string().nullable(),
+        note: z.string().optional()
+      })).describe("Logic branches to audit"),
+      stateFields: z.array(z.object({
+        source: z.string(),
+        field: z.string(),
+        inContext: z.boolean(),
+        usedByRule: z.boolean()
+      })).describe("State fields to check context coverage"),
+      transitions: z.array(z.object({
+        description: z.string(),
+        eventTag: z.string().nullable(),
+        location: z.string()
+      })).describe("State transitions to check event coverage"),
+      rulesNeedingContracts: z.array(z.string()).describe("Rule IDs that should have contracts"),
+      threshold: z.number().optional().describe("Minimum passing score (default: 90)")
+    },
+    async (params) => {
+      const rulesWithContracts = registry.getAllRules().filter((r) => getContractFromDescriptor(r)).map((r) => r.id);
+      const report = auditCompleteness(
+        {
+          branches: params.branches,
+          stateFields: params.stateFields,
+          transitions: params.transitions,
+          rulesNeedingContracts: params.rulesNeedingContracts
+        },
+        registry.getRuleIds(),
+        registry.getConstraintIds(),
+        rulesWithContracts,
+        { threshold: params.threshold }
+      );
+      const output = {
+        report,
+        formatted: formatReport(report)
+      };
+      return { content: [{ type: "text", text: JSON.stringify(output, null, 2) }] };
+    }
+  );
+  server.tool(
+    "praxis.suggest",
+    "Given a gap or description, suggest rules/constraints to add",
+    {
+      gap: z.string().describe("Description of the gap or failing expectation"),
+      context: z.record(z.string(), z.unknown()).optional().describe("Current context for suggestions")
+    },
+    async (params) => {
+      const existingRules = registry.getAllRules();
+      const _constraints = registry.getAllConstraints();
+      void _constraints;
+      const suggestions = [];
+      const gapLower = params.gap.toLowerCase();
+      const relatedRules = existingRules.filter(
+        (r) => r.description.toLowerCase().includes(gapLower) || gapLower.includes(r.id.toLowerCase())
+      );
+      if (relatedRules.length > 0) {
+        for (const rule of relatedRules) {
+          suggestions.push({
+            type: "constraint",
+            id: `${rule.id}/guard`,
+            description: `Add a constraint to guard the behavior described by rule "${rule.id}"`,
+            rationale: `Rule "${rule.id}" (${rule.description}) exists but may not fully cover: ${params.gap}`
+          });
+        }
+      }
+      const invariantTerms = ["must", "never", "always", "require", "valid", "invalid", "prevent"];
+      if (invariantTerms.some((t) => gapLower.includes(t))) {
+        suggestions.push({
+          type: "constraint",
+          id: suggestId(params.gap, "constraint"),
+          description: `Constraint: ${params.gap}`,
+          rationale: "Gap description contains invariant language \u2014 a constraint would encode this guarantee"
+        });
+      }
+      const ruleTerms = ["when", "if", "show", "emit", "trigger", "display", "update"];
+      if (ruleTerms.some((t) => gapLower.includes(t))) {
+        suggestions.push({
+          type: "rule",
+          id: suggestId(params.gap, "rule"),
+          description: `Rule: ${params.gap}`,
+          rationale: "Gap description contains conditional behavior \u2014 a rule would implement this logic"
+        });
+      }
+      const contractGaps = registry.getContractGaps();
+      if (contractGaps.length > 0) {
+        const relatedGaps = contractGaps.filter(
+          (g) => gapLower.includes(g.ruleId.toLowerCase())
+        );
+        for (const g of relatedGaps) {
+          suggestions.push({
+            type: "contract",
+            id: g.ruleId,
+            description: `Add contract for "${g.ruleId}" \u2014 missing: ${g.missing.join(", ")}`,
+            rationale: `Related rule "${g.ruleId}" lacks a contract, which could prevent this gap`
+          });
+        }
+      }
+      const eventTerms = ["transition", "change", "happen", "occur", "fire", "dispatch"];
+      if (eventTerms.some((t) => gapLower.includes(t))) {
+        suggestions.push({
+          type: "event",
+          id: suggestId(params.gap, "event"),
+          description: `Event for: ${params.gap}`,
+          rationale: "Gap description suggests a state transition \u2014 an event would make it observable"
+        });
+      }
+      if (suggestions.length === 0) {
+        suggestions.push({
+          type: "rule",
+          id: suggestId(params.gap, "rule"),
+          description: `Rule: ${params.gap}`,
+          rationale: "No existing rules or constraints cover this gap \u2014 a new rule is recommended"
+        });
+      }
+      const output = { suggestions };
+      return { content: [{ type: "text", text: JSON.stringify(output, null, 2) }] };
+    }
+  );
+  server.tool(
+    "praxis.facts",
+    "Get the current fact state of the engine",
+    {},
+    async () => {
+      const facts = engine.getFacts();
+      const output = {
+        facts,
+        count: facts.length
+      };
+      return { content: [{ type: "text", text: JSON.stringify(output, null, 2) }] };
+    }
+  );
+  server.tool(
+    "praxis.step",
+    "Step the engine with events and return the new state",
+    {
+      events: z.array(z.object({
+        tag: z.string(),
+        payload: z.unknown()
+      })).describe("Events to process")
+    },
+    async (params) => {
+      const result = engine.step(params.events);
+      const output = {
+        facts: result.state.facts,
+        diagnostics: result.diagnostics,
+        factCount: result.state.facts.length
+      };
+      return { content: [{ type: "text", text: JSON.stringify(output, null, 2) }] };
+    }
+  );
+  server.tool(
+    "praxis.contracts",
+    "List all contracts with their coverage status",
+    {
+      filter: z.string().optional().describe("Filter by rule/constraint ID (substring match)")
+    },
+    async (params) => {
+      const rules = registry.getAllRules();
+      const constraints = registry.getAllConstraints();
+      let contracts = [
+        ...rules.map((r) => ({
+          ruleId: r.id,
+          hasContract: !!getContractFromDescriptor(r),
+          contract: getContractFromDescriptor(r),
+          type: "rule"
+        })),
+        ...constraints.map((c) => ({
+          ruleId: c.id,
+          hasContract: !!getContractFromDescriptor(c),
+          contract: getContractFromDescriptor(c),
+          type: "constraint"
+        }))
+      ];
+      if (params.filter) {
+        contracts = contracts.filter((c) => c.ruleId.includes(params.filter));
+      }
+      const total = contracts.length;
+      const withContracts = contracts.filter((c) => c.hasContract).length;
+      const output = {
+        contracts,
+        coverage: {
+          total,
+          withContracts,
+          percentage: total > 0 ? Math.round(withContracts / total * 100) : 100
+        }
+      };
+      return { content: [{ type: "text", text: JSON.stringify(output, null, 2) }] };
+    }
+  );
+  return {
+    /** The underlying MCP server instance */
+    mcpServer: server,
+    /** The underlying Praxis engine */
+    engine,
+    /** Start the server on stdio transport */
+    async start() {
+      const transport = new StdioServerTransport();
+      await server.connect(transport);
+    }
+  };
+}
+function suggestId(description, type) {
+  const slug = description.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim().split(/\s+/).slice(0, 3).join("-");
+  return `suggested/${type}/${slug}`;
+}
+export {
+  createPraxisMcpServer
+};

package/dist/node/{validate-EN3M4FUR.js → validate-TQGVIG7G.js}

@@ -4,13 +4,14 @@ import {
   formatValidationReportJSON,
   formatValidationReportSARIF,
   validateContracts
-} from "./chunk-PTH6MD6P.js";
+} from "./chunk-FWOXU4MM.js";
 import {
   writeLogicLedgerEntry
-} from "./chunk-WZ6B3LZ6.js";
+} from "./chunk-7CSWBDFL.js";
+import "./chunk-PGVSB6NR.js";
 import {
   PraxisRegistry
-} from "./chunk-R2PSBPKQ.js";
+} from "./chunk-TEMFJOIH.js";
 import "./chunk-QGM4M3NI.js";
 
 // src/cli/commands/validate.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plures/praxis",
-  "version": "1.2.41",
+  "version": "1.4.0",
   "description": "The Full Plures Application Framework - declarative schemas, logic engine, component generation, and local-first data",
   "type": "module",
   "packageManager": "pnpm@9.15.1",
@@ -62,6 +62,30 @@
       "import": "./dist/node/components/index.js",
       "require": "./dist/node/components/index.cjs",
       "default": "./dist/node/components/index.js"
+    },
+    "./mcp": {
+      "types": "./dist/node/mcp/index.d.ts",
+      "import": "./dist/node/mcp/index.js",
+      "require": "./dist/node/mcp/index.cjs",
+      "default": "./dist/node/mcp/index.js"
+    },
+    "./expectations": {
+      "types": "./dist/node/expectations/index.d.ts",
+      "import": "./dist/node/expectations/index.js",
+      "require": "./dist/node/expectations/index.cjs",
+      "default": "./dist/node/expectations/index.js"
+    },
+    "./factory": {
+      "types": "./dist/node/factory/index.d.ts",
+      "import": "./dist/node/factory/index.js",
+      "require": "./dist/node/factory/index.cjs",
+      "default": "./dist/node/factory/index.js"
+    },
+    "./project": {
+      "types": "./dist/node/project/index.d.ts",
+      "import": "./dist/node/project/index.js",
+      "require": "./dist/node/project/index.cjs",
+      "default": "./dist/node/project/index.js"
     }
   },
   "files": [
@@ -123,9 +147,11 @@
     "vitest": "^4.0.15"
   },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "@plures/pluresdb": "^2.9.7",
     "commander": "^14.0.2",
     "js-yaml": "^4.1.1",
-    "@plures/pluresdb": "^2.9.7"
+    "zod": "^4.3.6"
   },
   "peerDependencies": {
     "svelte": "^5.46.0"
@@ -138,4 +164,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}