@run-iq/mcp-server 0.1.0

package/dist/index.js

@@ -0,0 +1,1115 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/engine.ts
+import { PPEEngine } from "@run-iq/core";
+import { FiscalPlugin } from "@run-iq/plugin-fiscal";
+import { JsonLogicEvaluator } from "@run-iq/dsl-jsonlogic";
+import { fiscalDescriptor } from "@run-iq/plugin-fiscal";
+
+// src/descriptors/registry.ts
+var DescriptorRegistry = class {
+  descriptors = [];
+  register(descriptor) {
+    this.descriptors.push(descriptor);
+  }
+  getAll() {
+    return this.descriptors;
+  }
+  getRuleExtensions() {
+    return this.descriptors.flatMap((d) => d.ruleExtensions);
+  }
+  getInputFields() {
+    const seen = /* @__PURE__ */ new Set();
+    const fields = [];
+    for (const d of this.descriptors) {
+      for (const f of d.inputFields) {
+        if (!seen.has(f.name)) {
+          seen.add(f.name);
+          fields.push(f);
+        }
+      }
+    }
+    return fields;
+  }
+  getExamples() {
+    return this.descriptors.flatMap((d) => d.examples);
+  }
+  isEmpty() {
+    return this.descriptors.length === 0;
+  }
+};
+
+// src/engine.ts
+function createEngine(bundles2) {
+  const descriptorRegistry2 = new DescriptorRegistry();
+  const allPlugins = [];
+  const allDsls = [];
+  if (bundles2 && bundles2.length > 0) {
+    for (const bundle of bundles2) {
+      allPlugins.push(bundle.plugin);
+      descriptorRegistry2.register(bundle.descriptor);
+      if (bundle.dsls) {
+        allDsls.push(...bundle.dsls);
+      }
+    }
+  } else {
+    allPlugins.push(new FiscalPlugin());
+    allDsls.push(new JsonLogicEvaluator());
+    descriptorRegistry2.register(fiscalDescriptor);
+  }
+  const engine2 = new PPEEngine({
+    plugins: allPlugins,
+    dsls: allDsls,
+    dryRun: true,
+    strict: false,
+    onConflict: "first",
+    onChecksumMismatch: "skip"
+  });
+  const models2 = /* @__PURE__ */ new Map();
+  for (const plugin of allPlugins) {
+    const pluginWithModels = plugin;
+    if (Array.isArray(pluginWithModels.models)) {
+      for (const model of pluginWithModels.models) {
+        models2.set(model.name, model);
+      }
+    }
+  }
+  return { engine: engine2, models: models2, descriptorRegistry: descriptorRegistry2, plugins: allPlugins, dsls: allDsls };
+}
+
+// src/loader/plugin-loader.ts
+import { readdir } from "fs/promises";
+import { resolve } from "path";
+async function loadPluginsFromDir(dir) {
+  const bundles2 = [];
+  const absoluteDir = resolve(dir);
+  const entries = await readdir(absoluteDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    if (!entry.name.endsWith(".js") && !entry.name.endsWith(".mjs")) continue;
+    const filePath = resolve(absoluteDir, entry.name);
+    const mod = await import(filePath);
+    const bundle = mod["default"] ?? mod;
+    if (bundle["plugin"] && typeof bundle["plugin"] === "object" && bundle["descriptor"] && typeof bundle["descriptor"] === "object") {
+      bundles2.push(bundle);
+    }
+  }
+  return bundles2;
+}
+
+// src/tools/create-checksum.ts
+import { createHash } from "crypto";
+import { z } from "zod";
+function registerCreateChecksumTool(server2) {
+  server2.tool(
+    "create_checksum",
+    "Compute the SHA-256 checksum of a params object. Used to generate the checksum field for Run-IQ rules.",
+    { params: z.record(z.unknown()).describe("The params object to hash") },
+    (args) => {
+      const checksum = createHash("sha256").update(JSON.stringify(args.params)).digest("hex");
+      return {
+        content: [{ type: "text", text: JSON.stringify({ checksum }, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/create-rule.ts
+import { createHash as createHash2 } from "crypto";
+
+// src/tools/schema-builder.ts
+import { z as z2 } from "zod";
+function buildFieldSchema(field) {
+  let schema;
+  if (field.enum && field.enum.length > 0) {
+    schema = z2.enum(field.enum);
+  } else {
+    switch (field.type) {
+      case "string":
+        schema = z2.string();
+        break;
+      case "number":
+        schema = z2.number();
+        break;
+      case "boolean":
+        schema = z2.boolean();
+        break;
+    }
+  }
+  if (!field.required) {
+    schema = schema.optional();
+  }
+  return schema.describe(field.description);
+}
+function buildCreateRuleSchema(descriptors2) {
+  const shape = {
+    id: z2.string().describe("Unique rule identifier"),
+    model: z2.string().describe("Calculation model name (e.g. FLAT_RATE, PROGRESSIVE_BRACKET)"),
+    params: z2.record(z2.unknown()).describe("Model-specific parameters"),
+    priority: z2.number().int().optional().describe("Rule priority (may be auto-computed by plugins, e.g. from jurisdiction+scope)"),
+    effectiveFrom: z2.string().describe("ISO 8601 date string for when the rule becomes active"),
+    effectiveUntil: z2.string().nullable().optional().describe("ISO 8601 date string for when the rule expires (null = no expiry)"),
+    tags: z2.array(z2.string()).optional().describe("Optional tags for filtering"),
+    condition: z2.object({
+      dsl: z2.string().describe('DSL identifier (e.g. "jsonlogic")'),
+      value: z2.unknown().describe("DSL-specific condition expression")
+    }).optional().describe("Optional condition expression")
+  };
+  for (const descriptor of descriptors2) {
+    for (const field of descriptor.ruleExtensions) {
+      shape[field.name] = buildFieldSchema(field);
+    }
+  }
+  return shape;
+}
+function buildValidateExtensionErrors(rule, descriptors2) {
+  const errors = [];
+  for (const descriptor of descriptors2) {
+    for (const field of descriptor.ruleExtensions) {
+      const value = rule[field.name];
+      if (field.required && (value === void 0 || value === null)) {
+        errors.push(`"${field.name}" is required by ${descriptor.name}: ${field.description}`);
+        continue;
+      }
+      if (value === void 0 || value === null) continue;
+      if (field.enum && !field.enum.includes(String(value))) {
+        errors.push(
+          `"${field.name}" must be one of: ${field.enum.join(", ")} (got "${String(value)}")`
+        );
+      }
+      if (field.type === "string" && typeof value !== "string") {
+        errors.push(`"${field.name}" must be a string`);
+      }
+      if (field.type === "number" && typeof value !== "number") {
+        errors.push(`"${field.name}" must be a number`);
+      }
+      if (field.type === "boolean" && typeof value !== "boolean") {
+        errors.push(`"${field.name}" must be a boolean`);
+      }
+    }
+  }
+  return errors;
+}
+
+// src/tools/create-rule.ts
+function registerCreateRuleTool(server2, descriptors2) {
+  const schema = buildCreateRuleSchema(descriptors2);
+  const extensionFields = descriptors2.flatMap((d) => d.ruleExtensions.map((f) => f.name));
+  server2.tool(
+    "create_rule",
+    "Generate a valid Run-IQ Rule JSON object with auto-computed SHA-256 checksum. Includes plugin-specific fields based on loaded plugins.",
+    schema,
+    (args) => {
+      const params = args["params"];
+      const checksum = createHash2("sha256").update(JSON.stringify(params)).digest("hex");
+      const rule = {
+        id: args["id"],
+        version: 1,
+        model: args["model"],
+        params,
+        priority: args["priority"] ?? 1e3,
+        effectiveFrom: args["effectiveFrom"],
+        effectiveUntil: args["effectiveUntil"] ?? null,
+        tags: args["tags"] ?? [],
+        checksum
+      };
+      if (args["condition"]) {
+        rule["condition"] = args["condition"];
+      }
+      for (const field of extensionFields) {
+        if (args[field] !== void 0) {
+          rule[field] = args[field];
+        }
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify({ rule }, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/validate.ts
+import { createHash as createHash3 } from "crypto";
+import { z as z3 } from "zod";
+var RuleSchema = z3.object({
+  id: z3.string(),
+  version: z3.number(),
+  model: z3.string(),
+  params: z3.unknown(),
+  priority: z3.number().optional(),
+  effectiveFrom: z3.string(),
+  effectiveUntil: z3.string().nullable(),
+  tags: z3.array(z3.string()),
+  checksum: z3.string(),
+  condition: z3.object({ dsl: z3.string(), value: z3.unknown() }).optional()
+});
+function registerValidateRulesTool(server2, models2, descriptors2) {
+  server2.tool(
+    "validate_rules",
+    "Validate the structure, checksum, model params, and plugin-specific fields of Run-IQ rules.",
+    {
+      rules: z3.array(z3.record(z3.unknown())).describe("Array of Rule JSON objects to validate")
+    },
+    (args) => {
+      const entries = [];
+      for (const raw of args.rules) {
+        const parsed = RuleSchema.safeParse(raw);
+        const ruleId = typeof raw["id"] === "string" ? raw["id"] : "unknown";
+        if (!parsed.success) {
+          entries.push({
+            ruleId,
+            valid: false,
+            errors: parsed.error.errors.map((e) => `${e.path.join(".")}: ${e.message}`)
+          });
+          continue;
+        }
+        const rule = parsed.data;
+        const errors = [];
+        const computed = createHash3("sha256").update(JSON.stringify(rule.params)).digest("hex");
+        if (computed !== rule.checksum) {
+          errors.push(`Checksum mismatch: expected ${computed}, got ${rule.checksum}`);
+        }
+        const model = models2.get(rule.model);
+        if (!model) {
+          errors.push(
+            `Model "${rule.model}" not found. Available: ${[...models2.keys()].join(", ")}`
+          );
+        } else {
+          const validation = model.validateParams(rule.params);
+          if (!validation.valid && validation.errors) {
+            errors.push(...validation.errors);
+          }
+        }
+        const extensionErrors = buildValidateExtensionErrors(raw, descriptors2);
+        errors.push(...extensionErrors);
+        entries.push({
+          ruleId: rule.id,
+          valid: errors.length === 0,
+          ...errors.length > 0 ? { errors } : {}
+        });
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify({ entries }, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/list-models.ts
+function registerListModelsTool(server2, models2) {
+  server2.tool(
+    "list_models",
+    "List all available calculation models with their parameter schemas. Shows model name, version, and expected parameters.",
+    {},
+    () => {
+      const result = [];
+      for (const [, model] of models2) {
+        const validation = model.validateParams({});
+        const paramsSchema = {};
+        if (validation.errors) {
+          for (const error of validation.errors) {
+            const match = error.match(/^"(\w+)"\s+must be (?:a |an )?(.+)$/);
+            if (match?.[1] && match[2]) {
+              paramsSchema[match[1]] = match[2];
+            }
+          }
+        }
+        result.push({
+          name: model.name,
+          version: model.version,
+          paramsSchema
+        });
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify({ models: result }, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/evaluate.ts
+import { z as z4 } from "zod";
+import { hydrateRules } from "@run-iq/core";
+function registerEvaluateTool(server2, engine2) {
+  server2.tool(
+    "evaluate",
+    "Evaluate Run-IQ rules against input data in dry-run mode. Returns the computed value, breakdown per rule, applied/skipped rules, and execution trace.",
+    {
+      rules: z4.array(z4.record(z4.unknown())).describe("Array of Rule JSON objects"),
+      input: z4.object({
+        data: z4.record(z4.unknown()).describe("Input data for evaluation"),
+        requestId: z4.string().describe("Unique request identifier"),
+        meta: z4.object({
+          tenantId: z4.string().describe("Tenant identifier"),
+          userId: z4.string().optional().describe("User identifier"),
+          tags: z4.array(z4.string()).optional().describe("Tags for rule filtering"),
+          context: z4.record(z4.unknown()).optional().describe("Additional context"),
+          effectiveDate: z4.string().optional().describe("ISO 8601 date for effective date evaluation")
+        })
+      }).describe("Evaluation input")
+    },
+    async (args) => {
+      try {
+        const rules = hydrateRules(args.rules);
+        const input = {
+          data: args.input.data,
+          requestId: args.input.requestId,
+          meta: {
+            ...args.input.meta,
+            effectiveDate: args.input.meta.effectiveDate ? new Date(args.input.meta.effectiveDate) : void 0
+          }
+        };
+        const result = await engine2.evaluate(rules, input);
+        const serializable = {
+          value: result.value,
+          breakdown: result.breakdown,
+          appliedRules: result.appliedRules.map((r) => ({
+            id: r.id,
+            model: r.model,
+            priority: r.priority
+          })),
+          skippedRules: result.skippedRules.map((s) => ({
+            ruleId: s.rule.id,
+            reason: s.reason
+          })),
+          trace: {
+            steps: result.trace.steps.map((s) => ({
+              ruleId: s.ruleId,
+              modelUsed: s.modelUsed,
+              contribution: s.contribution,
+              durationMs: s.durationMs
+            })),
+            totalDurationMs: result.trace.totalDurationMs
+          }
+        };
+        return {
+          content: [{ type: "text", text: JSON.stringify(serializable, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: message }) }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/inspect-rule.ts
+import { createHash as createHash4 } from "crypto";
+import { z as z5 } from "zod";
+function registerInspectRuleTool(server2, models2, descriptors2) {
+  server2.tool(
+    "inspect_rule",
+    "Analyze a single Run-IQ rule in detail: checksum, model, active dates, params, and plugin-specific fields.",
+    {
+      rule: z5.record(z5.unknown()).describe("A single Rule JSON object to inspect")
+    },
+    (args) => {
+      const rule = args.rule;
+      const id = typeof rule["id"] === "string" ? rule["id"] : "unknown";
+      const modelName = typeof rule["model"] === "string" ? rule["model"] : "";
+      const params = rule["params"];
+      const checksum = typeof rule["checksum"] === "string" ? rule["checksum"] : "";
+      const computed = createHash4("sha256").update(JSON.stringify(params)).digest("hex");
+      const checksumMatch = computed === checksum;
+      const model = models2.get(modelName);
+      const modelFound = model !== void 0;
+      let paramErrors;
+      if (model) {
+        const validation = model.validateParams(params);
+        if (!validation.valid && validation.errors) {
+          paramErrors = [...validation.errors];
+        }
+      }
+      const extensionErrors = buildValidateExtensionErrors(rule, descriptors2);
+      const now = /* @__PURE__ */ new Date();
+      const effectiveFrom = typeof rule["effectiveFrom"] === "string" ? new Date(rule["effectiveFrom"]) : null;
+      const effectiveUntil = typeof rule["effectiveUntil"] === "string" ? new Date(rule["effectiveUntil"]) : null;
+      const isActive = effectiveFrom !== null && effectiveFrom <= now && (effectiveUntil === null || effectiveUntil > now);
+      const effectivePeriod = {
+        from: effectiveFrom?.toISOString() ?? null,
+        until: effectiveUntil?.toISOString() ?? null
+      };
+      const allErrors = [...paramErrors ?? [], ...extensionErrors];
+      const valid = checksumMatch && modelFound && allErrors.length === 0 && isActive;
+      const result = {
+        ruleId: id,
+        valid,
+        checksumMatch,
+        modelFound,
+        isActive,
+        effectivePeriod
+      };
+      if (paramErrors && paramErrors.length > 0) {
+        result["paramErrors"] = paramErrors;
+      }
+      if (extensionErrors.length > 0) {
+        result["extensionErrors"] = extensionErrors;
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/explain.ts
+import { z as z6 } from "zod";
+var EvaluationResultSchema = {
+  result: z6.object({
+    value: z6.unknown(),
+    breakdown: z6.array(
+      z6.object({
+        ruleId: z6.string(),
+        contribution: z6.unknown(),
+        modelUsed: z6.string(),
+        label: z6.string().optional()
+      })
+    ),
+    appliedRules: z6.array(
+      z6.object({
+        id: z6.string(),
+        model: z6.string(),
+        priority: z6.number()
+      })
+    ),
+    skippedRules: z6.array(
+      z6.object({
+        ruleId: z6.string(),
+        reason: z6.string()
+      })
+    ),
+    trace: z6.object({
+      totalDurationMs: z6.number(),
+      steps: z6.array(z6.record(z6.unknown())).optional()
+    }).optional()
+  }).describe("An EvaluationResult (or simplified result from the evaluate tool)")
+};
+function registerExplainResultTool(server2) {
+  server2.tool(
+    "explain_result",
+    "Generate a human-readable explanation of an evaluation result. Summarizes the total value, applied rules with their contributions, skipped rules with reasons, and execution timing.",
+    EvaluationResultSchema,
+    (args) => {
+      const { result } = args;
+      const lines = [];
+      lines.push(`## Evaluation Result Summary`);
+      lines.push("");
+      lines.push(`**Total Value**: ${String(result.value)}`);
+      lines.push("");
+      if (result.appliedRules.length > 0) {
+        lines.push(`### Applied Rules (${result.appliedRules.length})`);
+        lines.push("");
+        for (const applied of result.appliedRules) {
+          const breakdown = result.breakdown.find((b) => b.ruleId === applied.id);
+          const contribution = breakdown ? String(breakdown.contribution) : "N/A";
+          const label = breakdown?.label ? ` (${breakdown.label})` : "";
+          lines.push(
+            `- **${applied.id}**${label}: model=${applied.model}, priority=${applied.priority}, contribution=${contribution}`
+          );
+        }
+        lines.push("");
+      } else {
+        lines.push("### No rules were applied.");
+        lines.push("");
+      }
+      if (result.skippedRules.length > 0) {
+        lines.push(`### Skipped Rules (${result.skippedRules.length})`);
+        lines.push("");
+        for (const skipped of result.skippedRules) {
+          lines.push(`- **${skipped.ruleId}**: ${skipped.reason}`);
+        }
+        lines.push("");
+      }
+      if (result.trace?.totalDurationMs !== void 0) {
+        lines.push(`### Timing`);
+        lines.push("");
+        lines.push(`Total duration: ${result.trace.totalDurationMs}ms`);
+      }
+      const explanation = lines.join("\n");
+      return {
+        content: [{ type: "text", text: JSON.stringify({ explanation }, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/simulate.ts
+import { z as z7 } from "zod";
+import { hydrateRules as hydrateRules2 } from "@run-iq/core";
+var ScenarioSchema = z7.object({
+  label: z7.string().describe("Human-readable scenario label"),
+  input: z7.object({
+    data: z7.record(z7.unknown()),
+    requestId: z7.string(),
+    meta: z7.object({
+      tenantId: z7.string(),
+      userId: z7.string().optional(),
+      tags: z7.array(z7.string()).optional(),
+      context: z7.record(z7.unknown()).optional(),
+      effectiveDate: z7.string().optional()
+    })
+  })
+});
+function registerSimulateTool(server2, engine2) {
+  server2.tool(
+    "simulate",
+    "Compare N scenarios using the same rules. Evaluates each scenario independently and returns side-by-side results for comparison.",
+    {
+      rules: z7.array(z7.record(z7.unknown())).describe("Array of Rule JSON objects (shared across all scenarios)"),
+      scenarios: z7.array(ScenarioSchema).min(1).describe("Array of scenarios to compare")
+    },
+    async (args) => {
+      try {
+        const rules = hydrateRules2(args.rules);
+        const results = [];
+        for (const scenario of args.scenarios) {
+          const input = {
+            data: scenario.input.data,
+            requestId: scenario.input.requestId,
+            meta: {
+              ...scenario.input.meta,
+              effectiveDate: scenario.input.meta.effectiveDate ? new Date(scenario.input.meta.effectiveDate) : void 0
+            }
+          };
+          const result = await engine2.evaluate(rules, input);
+          results.push({
+            label: scenario.label,
+            value: result.value,
+            appliedCount: result.appliedRules.length,
+            skippedCount: result.skippedRules.length,
+            breakdown: result.breakdown.map((b) => ({
+              ruleId: b.ruleId,
+              contribution: b.contribution,
+              modelUsed: b.modelUsed
+            }))
+          });
+        }
+        return {
+          content: [{ type: "text", text: JSON.stringify({ results }, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: message }) }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/resources/models.ts
+function buildModelsCatalog(models2) {
+  const lines = [];
+  lines.push("# Run-IQ Calculation Models");
+  lines.push("");
+  for (const [, model] of models2) {
+    lines.push(`## ${model.name} (v${model.version})`);
+    lines.push("");
+    const validation = model.validateParams({});
+    if (validation.errors) {
+      lines.push("### Parameters");
+      lines.push("");
+      for (const error of validation.errors) {
+        lines.push(`- ${error}`);
+      }
+      lines.push("");
+    }
+    switch (model.name) {
+      case "FLAT_RATE":
+        lines.push("Applies a flat rate to a base value: `base_value * rate`.");
+        lines.push("");
+        lines.push('**Example params**: `{ "rate": 0.18, "base": "revenue" }`');
+        lines.push("**Use case**: TVA, flat tax rates.");
+        break;
+      case "PROGRESSIVE_BRACKET":
+        lines.push(
+          "Applies progressive tax brackets cumulatively. Each bracket taxes only the portion within its range."
+        );
+        lines.push("");
+        lines.push(
+          '**Example params**: `{ "base": "income", "brackets": [{ "from": 0, "to": 500000, "rate": 0 }, { "from": 500000, "to": 1000000, "rate": 0.1 }] }`'
+        );
+        lines.push("**Use case**: IRPP (income tax), progressive taxes.");
+        break;
+      case "MINIMUM_TAX":
+        lines.push("Computes `MAX(base_value * rate, minimum)`. Ensures a minimum tax amount.");
+        lines.push("");
+        lines.push('**Example params**: `{ "rate": 0.01, "base": "revenue", "minimum": 50000 }`');
+        lines.push("**Use case**: Minimum corporate tax.");
+        break;
+      case "THRESHOLD_BASED":
+        lines.push(
+          "Applies a rate only when the base value exceeds a threshold. If `above_only` is true, taxes only the amount above the threshold."
+        );
+        lines.push("");
+        lines.push(
+          '**Example params**: `{ "base": "revenue", "threshold": 1000000, "rate": 0.05, "above_only": true }`'
+        );
+        lines.push("**Use case**: Luxury tax, excess profit tax.");
+        break;
+      case "FIXED_AMOUNT":
+        lines.push("Returns a fixed amount regardless of input values.");
+        lines.push("");
+        lines.push('**Example params**: `{ "amount": 25000, "currency": "XOF" }`');
+        lines.push("**Use case**: Fixed registration fees, stamps.");
+        break;
+      case "COMPOSITE":
+        lines.push(
+          "Combines multiple sub-models using an aggregation function (SUM, MAX, or MIN)."
+        );
+        lines.push("");
+        lines.push(
+          '**Example params**: `{ "steps": [{ "model": "FLAT_RATE", "params": { "rate": 0.18, "base": "revenue" } }], "aggregation": "SUM" }`'
+        );
+        lines.push("**Use case**: Complex tax calculations combining multiple methods.");
+        break;
+    }
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function registerModelsResource(server2, models2) {
+  server2.resource(
+    "models-catalog",
+    "models://catalog",
+    {
+      description: "Documentation of all available calculation models with parameter schemas and usage examples"
+    },
+    () => {
+      const catalog = buildModelsCatalog(models2);
+      return {
+        contents: [
+          {
+            uri: "models://catalog",
+            mimeType: "text/markdown",
+            text: catalog
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/resources/plugins.ts
+function registerPluginsResource(server2, plugins2, dsls2, registry) {
+  server2.resource(
+    "plugins-loaded",
+    "plugins://loaded",
+    { description: "Information about loaded plugins, DSL evaluators, and their descriptors" },
+    () => {
+      const descriptors2 = registry.getAll();
+      const info = {
+        plugins: plugins2.map((p) => {
+          const desc = descriptors2.find((d) => d.name === p.name);
+          const pluginWithModels = p;
+          return {
+            name: p.name,
+            version: p.version,
+            models: Array.isArray(pluginWithModels.models) ? pluginWithModels.models.map((m) => m.name) : [],
+            hasDescriptor: desc !== void 0,
+            ruleExtensions: desc?.ruleExtensions.map((f) => f.name) ?? []
+          };
+        }),
+        dsls: dsls2.map((d) => ({
+          name: d.dsl,
+          version: d.version
+        }))
+      };
+      return {
+        contents: [
+          {
+            uri: "plugins://loaded",
+            mimeType: "application/json",
+            text: JSON.stringify(info, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/resources/schema.ts
+function buildSchemaDocument(models2, registry) {
+  const lines = [];
+  lines.push("# Run-IQ Rule Schema");
+  lines.push("");
+  lines.push("Complete schema for creating valid rules with the currently loaded plugins.");
+  lines.push("");
+  lines.push("## Base Rule Fields (always required)");
+  lines.push("");
+  lines.push("| Field | Type | Required | Description |");
+  lines.push("|-------|------|----------|-------------|");
+  lines.push("| id | string | yes | Unique rule identifier |");
+  lines.push("| version | number | auto (=1) | Rule version |");
+  lines.push("| model | string | yes | Calculation model name |");
+  lines.push("| params | object | yes | Model-specific parameters |");
+  lines.push(
+    "| priority | number | optional | Auto-computed by plugins (e.g. jurisdiction+scope) |"
+  );
+  lines.push("| effectiveFrom | string | yes | ISO 8601 date |");
+  lines.push("| effectiveUntil | string\\|null | optional | ISO 8601 date or null |");
+  lines.push("| tags | string[] | optional | Filtering tags |");
+  lines.push("| checksum | string | auto | SHA-256 of params (auto-computed by create_rule) |");
+  lines.push("| condition | {dsl,value} | optional | DSL condition (e.g. jsonlogic) |");
+  lines.push("");
+  const descriptors2 = registry.getAll();
+  if (descriptors2.length > 0) {
+    lines.push("## Plugin Extension Fields");
+    lines.push("");
+    for (const desc of descriptors2) {
+      lines.push(`### ${desc.name} (v${desc.version})`);
+      lines.push("");
+      lines.push(desc.description);
+      lines.push("");
+      lines.push("| Field | Type | Required | Values | Description |");
+      lines.push("|-------|------|----------|--------|-------------|");
+      for (const field of desc.ruleExtensions) {
+        const values = field.enum ? field.enum.join(", ") : "-";
+        lines.push(
+          `| ${field.name} | ${field.type} | ${field.required ? "yes" : "no"} | ${values} | ${field.description} |`
+        );
+      }
+      lines.push("");
+    }
+  }
+  lines.push("## Available Calculation Models");
+  lines.push("");
+  for (const [, model] of models2) {
+    lines.push(`### ${model.name} (v${model.version})`);
+    lines.push("");
+    const validation = model.validateParams({});
+    if (validation.errors) {
+      lines.push("**Required params:**");
+      for (const error of validation.errors) {
+        lines.push(`- ${error}`);
+      }
+    }
+    lines.push("");
+  }
+  const inputFields = registry.getInputFields();
+  if (inputFields.length > 0) {
+    lines.push("## Input Data Fields (input.data)");
+    lines.push("");
+    lines.push('Variables available for use in JSONLogic conditions (`{"var": "fieldName"}`)');
+    lines.push("and as `base` parameter in calculation models.");
+    lines.push("");
+    lines.push("| Field | Type | Description | Examples |");
+    lines.push("|-------|------|-------------|----------|");
+    for (const field of inputFields) {
+      const examples2 = field.examples ? field.examples.join(", ") : "-";
+      lines.push(`| ${field.name} | ${field.type} | ${field.description} | ${examples2} |`);
+    }
+    lines.push("");
+  }
+  lines.push("## JSONLogic Condition Syntax");
+  lines.push("");
+  lines.push("Conditions use the `jsonlogic` DSL. Format:");
+  lines.push("```json");
+  lines.push('{ "dsl": "jsonlogic", "value": <expression> }');
+  lines.push("```");
+  lines.push("");
+  lines.push("**Common operators:**");
+  lines.push('- `{">=": [{"var": "revenue"}, 1000000]}` - comparison');
+  lines.push('- `{"and": [expr1, expr2]}` - logical AND');
+  lines.push('- `{"or": [expr1, expr2]}` - logical OR');
+  lines.push('- `{"!": expr}` - logical NOT');
+  lines.push('- `{"in": ["value", {"var": "tags"}]}` - membership');
+  lines.push('- `{"==": [{"var": "type"}, "enterprise"]}` - equality');
+  lines.push("");
+  const examples = registry.getExamples();
+  if (examples.length > 0) {
+    lines.push("## Complete Rule Examples");
+    lines.push("");
+    for (const example of examples) {
+      lines.push(`### ${example.title}`);
+      lines.push("");
+      lines.push(example.description);
+      lines.push("");
+      lines.push("**Rule:**");
+      lines.push("```json");
+      lines.push(JSON.stringify(example.rule, null, 2));
+      lines.push("```");
+      if (example.input) {
+        lines.push("");
+        lines.push("**Input data:**");
+        lines.push("```json");
+        lines.push(JSON.stringify(example.input, null, 2));
+        lines.push("```");
+      }
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+function registerSchemaResource(server2, models2, registry) {
+  server2.resource(
+    "rule-schema",
+    "schema://rules",
+    {
+      description: "Complete rule schema including base fields, plugin extensions, model params, input variables, DSL syntax, and examples. THE reference for creating valid rules."
+    },
+    () => ({
+      contents: [
+        {
+          uri: "schema://rules",
+          mimeType: "text/markdown",
+          text: buildSchemaDocument(models2, registry)
+        }
+      ]
+    })
+  );
+}
+
+// src/prompts/analyze-text.ts
+import { z as z8 } from "zod";
+function buildDomainLabel(registry) {
+  const descriptors2 = registry.getAll();
+  if (descriptors2.length === 0) return "policy";
+  return descriptors2.map((d) => d.domainLabel).join(" / ");
+}
+function buildModelDocs(models2) {
+  const lines = [];
+  for (const [, model] of models2) {
+    const validation = model.validateParams({});
+    const paramHints = validation.errors ? validation.errors.join("; ") : "none";
+    lines.push(`- **${model.name}** (v${model.version}): ${paramHints}`);
+  }
+  return lines.join("\n");
+}
+function buildExtensionDocs(registry) {
+  const descriptors2 = registry.getAll();
+  if (descriptors2.length === 0) return "";
+  const lines = [];
+  for (const desc of descriptors2) {
+    lines.push(`
+### Plugin: ${desc.name}`);
+    lines.push(desc.description);
+    lines.push("\n**Required fields on each rule:**");
+    for (const field of desc.ruleExtensions) {
+      const values = field.enum ? ` (values: ${field.enum.join(", ")})` : "";
+      const req = field.required ? " [REQUIRED]" : " [optional]";
+      lines.push(`- \`${field.name}\`${req}: ${field.description}${values}`);
+    }
+  }
+  return lines.join("\n");
+}
+function buildExampleDocs(registry) {
+  const examples = registry.getExamples();
+  if (examples.length === 0) return "";
+  const lines = ["\n## Concrete Examples"];
+  for (const ex of examples) {
+    lines.push(`
+### ${ex.title}`);
+    lines.push(ex.description);
+    lines.push("```json");
+    lines.push(JSON.stringify(ex.rule, null, 2));
+    lines.push("```");
+  }
+  return lines.join("\n");
+}
+function buildInputDocs(registry) {
+  const fields = registry.getInputFields();
+  if (fields.length === 0) return "";
+  const lines = ["\n## Available input.data Fields"];
+  lines.push('Use these as `{"var": "fieldName"}` in JSONLogic conditions');
+  lines.push('and as `"base"` parameter in calculation models:\n');
+  for (const f of fields) {
+    const examples = f.examples ? ` (e.g. ${f.examples.join(", ")})` : "";
+    lines.push(`- \`${f.name}\` (${f.type}): ${f.description}${examples}`);
+  }
+  return lines.join("\n");
+}
+function buildGuidelinesSection(registry) {
+  const descriptors2 = registry.getAll();
+  const lines = [];
+  for (const desc of descriptors2) {
+    if (desc.promptGuidelines.length > 0) {
+      lines.push(`
+## ${desc.domainLabel} Guidelines`);
+      for (const g of desc.promptGuidelines) {
+        lines.push(`- ${g}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function registerAnalyzeTextPrompt(server2, models2, registry) {
+  const domainLabel = buildDomainLabel(registry);
+  server2.prompt(
+    "analyze-text",
+    `Translate a ${domainLabel} text (law, regulation, policy) into Run-IQ rule definitions. Plugin-aware: includes all required fields.`,
+    {
+      source_text: z8.string().describe("The regulatory, legal, or policy text to analyze and convert into rules"),
+      country: z8.string().optional().describe("ISO country code (e.g. TG, FR, US, IN)")
+    },
+    (args) => {
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `You are an expert at translating regulatory and policy texts into structured Run-IQ rules.
+
+## Available Calculation Models
+${buildModelDocs(models2)}
+${buildExtensionDocs(registry)}
+${buildInputDocs(registry)}
+${buildGuidelinesSection(registry)}
+
+## Rule Creation Workflow
+1. Read the source text carefully
+2. Identify each rule, rate, threshold, bracket, condition, or exemption
+3. Map each identified element to the appropriate calculation model
+4. Use the \`create_rule\` tool \u2014 it knows ALL required fields for loaded plugins
+5. Use the \`validate_rules\` tool to verify your rules are valid
+6. Read \`schema://rules\` for the complete field reference if needed
+
+## JSONLogic Conditions
+\`\`\`json
+{ "dsl": "jsonlogic", "value": { ">=": [{ "var": "revenue" }, 100000] } }
+\`\`\`
+${buildExampleDocs(registry)}
+${args.country ? `
+## Target Country: ${args.country}
+` : ""}
+## Source Text to Analyze
+${args.source_text}`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/prompts/domain-expert.ts
+import { z as z9 } from "zod";
+function buildGuidelinesSection2(registry) {
+  const descriptors2 = registry.getAll();
+  const allGuidelines = [];
+  for (const desc of descriptors2) {
+    if (desc.promptGuidelines.length > 0) {
+      allGuidelines.push(`### ${desc.name} (${desc.domainLabel})`);
+      for (const g of desc.promptGuidelines) {
+        allGuidelines.push(`- ${g}`);
+      }
+    }
+  }
+  if (allGuidelines.length === 0) return "";
+  return `## Domain-Specific Guidelines
+${allGuidelines.join("\n")}`;
+}
+function buildDomainLabel2(registry) {
+  const descriptors2 = registry.getAll();
+  if (descriptors2.length === 0) return "general-purpose";
+  return descriptors2.map((d) => d.domainLabel).join(" + ");
+}
+function registerDomainExpertPrompt(server2, registry) {
+  const descriptors2 = registry.getAll();
+  const domainLabel = buildDomainLabel2(registry);
+  const pluginList = descriptors2.map((d) => `- ${d.name}: ${d.description}`).join("\n");
+  server2.prompt(
+    "domain-expert",
+    `${domainLabel} calculation expertise: scenario comparison, result explanation, recommendations`,
+    {
+      question: z9.string().describe("The question or scenario to analyze")
+    },
+    (args) => {
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `You are a ${domainLabel} expert assistant powered by the Run-IQ PPE (Parametric Policy Engine).
+
+## Loaded Plugins
+${pluginList || "No plugins loaded."}
+
+## Your Tools
+- **evaluate**: evaluate rules against input data (always dry-run)
+- **simulate**: compare N scenarios side-by-side
+- **validate_rules**: verify rule structure, checksum, and plugin-specific fields
+- **explain_result**: human-readable result explanation
+- **create_rule**: generate rules with ALL required plugin fields
+- **inspect_rule**: analyze a single rule in detail
+- **list_models**: show available calculation models
+- **create_checksum**: compute SHA-256 for params
+
+## Key Resources
+- \`schema://rules\` \u2014 THE complete rule schema reference
+- \`models://catalog\` \u2014 model documentation with examples
+- \`plugins://loaded\` \u2014 loaded plugins and their capabilities
+
+## General Guidelines
+1. Always read \`schema://rules\` before creating rules \u2014 it has ALL required fields
+2. When comparing scenarios, use the \`simulate\` tool with clear labels
+3. Always validate rules after creating them
+
+${buildGuidelinesSection2(registry)}
+
+## Question
+${args.question}`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/index.ts
+var pluginsDir;
+var argv = process.argv.slice(2);
+for (let i = 0; i < argv.length; i++) {
+  if (argv[i] === "--plugins-dir" && argv[i + 1]) {
+    pluginsDir = argv[i + 1];
+    i++;
+  }
+}
+var bundles;
+if (pluginsDir) {
+  bundles = await loadPluginsFromDir(pluginsDir);
+}
+var { engine, models, descriptorRegistry, plugins, dsls } = createEngine(bundles);
+var descriptors = descriptorRegistry.getAll();
+var server = new McpServer(
+  {
+    name: "@run-iq/mcp-server",
+    version: "0.1.0"
+  },
+  {
+    capabilities: {
+      tools: {},
+      resources: {},
+      prompts: {}
+    }
+  }
+);
+registerCreateChecksumTool(server);
+registerCreateRuleTool(server, descriptors);
+registerValidateRulesTool(server, models, descriptors);
+registerListModelsTool(server, models);
+registerEvaluateTool(server, engine);
+registerInspectRuleTool(server, models, descriptors);
+registerExplainResultTool(server);
+registerSimulateTool(server, engine);
+registerModelsResource(server, models);
+registerPluginsResource(server, plugins, dsls, descriptorRegistry);
+registerSchemaResource(server, models, descriptorRegistry);
+registerAnalyzeTextPrompt(server, models, descriptorRegistry);
+registerDomainExpertPrompt(server, descriptorRegistry);
+var transport = new StdioServerTransport();
+await server.connect(transport);
+//# sourceMappingURL=index.js.map