@contractspec/bundle.library 3.0.0 → 3.2.0

package/dist/application/index.js

@@ -1,4 +1,30 @@
 // @bun
+// src/application/context-storage/index.ts
+import {
+  EmbeddingService,
+  VectorIndexer
+} from "@contractspec/lib.knowledge/ingestion";
+import {
+  ContextSnapshotPipeline,
+  PostgresContextStorage
+} from "@contractspec/module.context-storage";
+function createContextStorageService(options) {
+  const store = new PostgresContextStorage({
+    database: options.database,
+    schema: options.schema,
+    createTablesIfMissing: options.createTablesIfMissing
+  });
+  const embeddingService = options.embeddingProvider ? new EmbeddingService(options.embeddingProvider, options.embeddingBatchSize) : undefined;
+  const vectorIndexer = options.vectorStoreProvider && options.vectorIndex ? new VectorIndexer(options.vectorStoreProvider, options.vectorIndex) : undefined;
+  const pipeline = new ContextSnapshotPipeline({
+    store,
+    documentProcessor: options.documentProcessor,
+    embeddingService,
+    vectorIndexer
+  });
+  return { store, pipeline };
+}
+
 // src/application/mcp/common.ts
 import { PresentationRegistry } from "@contractspec/lib.contracts-spec/presentations";
 import { createMcpServer } from "@contractspec/lib.contracts-runtime-server-mcp/provider-mcp";
@@ -73,9 +99,13 @@ function createMcpElysiaHandler({
   ops,
   resources,
   prompts,
-  presentations
+  presentations,
+  validateAuth,
+  requiredAuthMethods
 }) {
-  logger.info("Setting up MCP handler...");
+  logger.info("Setting up MCP handler...", {
+    requiredAuthMethods: requiredAuthMethods ?? []
+  });
   const isStateful = process.env.CONTRACTSPEC_MCP_STATEFUL === "1";
   const sessions = new Map;
   async function handleStateless(request) {
@@ -146,6 +176,12 @@ function createMcpElysiaHandler({
   }
   return new Elysia({ name: `mcp-${serverName}` }).all(path, async ({ request }) => {
     try {
+      if (validateAuth) {
+        const authResult = await validateAuth(request);
+        if (!authResult.valid) {
+          return createJsonRpcErrorResponse(401, -32002, "Authentication failed", authResult.reason);
+        }
+      }
       if (isStateful) {
         return await handleStateful(request);
       }
@@ -777,8 +813,632 @@ function createInternalMcpHandler(path2 = "/api/mcp/internal") {
     prompts: buildInternalPrompts()
   });
 }
+
+// src/application/mcp/providerRankingMcp.ts
+import {
+  definePrompt as definePrompt4,
+  defineResourceTemplate as defineResourceTemplate4,
+  installOp as installOp4,
+  OperationSpecRegistry as OperationSpecRegistry4,
+  PromptRegistry as PromptRegistry4,
+  ResourceRegistry as ResourceRegistry4
+} from "@contractspec/lib.contracts-spec";
+import {
+  BenchmarkIngestCommand,
+  BenchmarkRunCustomCommand,
+  RankingRefreshCommand
+} from "@contractspec/lib.contracts-spec/provider-ranking";
+import z4 from "zod";
+import { InMemoryProviderRankingStore } from "@contractspec/lib.provider-ranking/in-memory-store";
+import { createDefaultIngesterRegistry } from "@contractspec/lib.provider-ranking/ingesters";
+import { computeModelRankings } from "@contractspec/lib.provider-ranking/scoring";
+import { normalizeBenchmarkResults } from "@contractspec/lib.provider-ranking/scoring";
+var TransportFilterSchema = z4.enum(["rest", "mcp", "webhook", "sdk"]).optional();
+var AuthFilterSchema = z4.enum([
+  "api-key",
+  "oauth2",
+  "bearer",
+  "header",
+  "basic",
+  "webhook-signing",
+  "service-account"
+]).optional();
+var RANKING_TAGS = ["ranking", "mcp", "ai"];
+var RANKING_OWNERS = ["platform.ai"];
+var sharedStore = null;
+function getStore() {
+  if (!sharedStore) {
+    sharedStore = new InMemoryProviderRankingStore;
+  }
+  return sharedStore;
+}
+function buildRankingResources() {
+  const resources = new ResourceRegistry4;
+  resources.register(defineResourceTemplate4({
+    meta: {
+      uriTemplate: "ranking://leaderboard",
+      title: "AI Model Leaderboard",
+      description: "Current ranked list of AI models by composite score. Supports optional transport and authMethod query filters.",
+      mimeType: "application/json",
+      tags: RANKING_TAGS
+    },
+    input: z4.object({
+      transport: TransportFilterSchema,
+      authMethod: AuthFilterSchema
+    }),
+    resolve: async ({ transport, authMethod }) => {
+      const store = getStore();
+      const result = await store.listModelRankings({
+        limit: 100,
+        requiredTransport: transport,
+        requiredAuthMethod: authMethod
+      });
+      return {
+        uri: "ranking://leaderboard",
+        mimeType: "application/json",
+        data: JSON.stringify(result, null, 2)
+      };
+    }
+  }));
+  resources.register(defineResourceTemplate4({
+    meta: {
+      uriTemplate: "ranking://leaderboard/{dimension}",
+      title: "AI Model Leaderboard by Dimension",
+      description: "Ranked list of AI models filtered by a specific dimension. Supports optional transport and authMethod query filters.",
+      mimeType: "application/json",
+      tags: RANKING_TAGS
+    },
+    input: z4.object({
+      dimension: z4.string(),
+      transport: TransportFilterSchema,
+      authMethod: AuthFilterSchema
+    }),
+    resolve: async ({ dimension, transport, authMethod }) => {
+      const store = getStore();
+      const result = await store.listModelRankings({
+        dimension,
+        limit: 100,
+        requiredTransport: transport,
+        requiredAuthMethod: authMethod
+      });
+      return {
+        uri: `ranking://leaderboard/${encodeURIComponent(dimension)}`,
+        mimeType: "application/json",
+        data: JSON.stringify(result, null, 2)
+      };
+    }
+  }));
+  resources.register(defineResourceTemplate4({
+    meta: {
+      uriTemplate: "ranking://model/{modelId}",
+      title: "AI Model Profile",
+      description: "Detailed profile for a specific AI model including scores and benchmarks.",
+      mimeType: "application/json",
+      tags: RANKING_TAGS
+    },
+    input: z4.object({ modelId: z4.string() }),
+    resolve: async ({ modelId }) => {
+      const store = getStore();
+      const profile = await store.getModelProfile(modelId);
+      if (!profile) {
+        return {
+          uri: `ranking://model/${encodeURIComponent(modelId)}`,
+          mimeType: "application/json",
+          data: JSON.stringify({ error: "not_found", modelId })
+        };
+      }
+      return {
+        uri: `ranking://model/${encodeURIComponent(modelId)}`,
+        mimeType: "application/json",
+        data: JSON.stringify(profile, null, 2)
+      };
+    }
+  }));
+  resources.register(defineResourceTemplate4({
+    meta: {
+      uriTemplate: "ranking://results",
+      title: "Benchmark Results",
+      description: "List of raw benchmark results from all ingested sources.",
+      mimeType: "application/json",
+      tags: RANKING_TAGS
+    },
+    input: z4.object({}),
+    resolve: async () => {
+      const store = getStore();
+      const result = await store.listBenchmarkResults({ limit: 200 });
+      return {
+        uri: "ranking://results",
+        mimeType: "application/json",
+        data: JSON.stringify(result, null, 2)
+      };
+    }
+  }));
+  return resources;
+}
+function buildRankingPrompts() {
+  const prompts = new PromptRegistry4;
+  prompts.register(definePrompt4({
+    meta: {
+      key: "ranking.advisor",
+      version: "1.0.0",
+      title: "AI Model Advisor",
+      description: "Which AI model is best for a given task? Uses the leaderboard to recommend.",
+      tags: RANKING_TAGS,
+      stability: "beta",
+      owners: RANKING_OWNERS
+    },
+    args: [
+      {
+        name: "task",
+        description: "The task or use case to recommend a model for.",
+        required: true,
+        schema: z4.string()
+      },
+      {
+        name: "priority",
+        description: "Priority dimension (coding, reasoning, cost, latency, etc.).",
+        required: false,
+        schema: z4.string().optional()
+      },
+      {
+        name: "transport",
+        description: "Required transport type (rest, mcp, webhook, sdk).",
+        required: false,
+        schema: TransportFilterSchema
+      },
+      {
+        name: "authMethod",
+        description: "Required auth method (api-key, oauth2, bearer, etc.).",
+        required: false,
+        schema: AuthFilterSchema
+      }
+    ],
+    input: z4.object({
+      task: z4.string(),
+      priority: z4.string().optional(),
+      transport: TransportFilterSchema,
+      authMethod: AuthFilterSchema
+    }),
+    render: async ({ task, priority, transport, authMethod }) => {
+      const constraints = [];
+      if (priority)
+        constraints.push(`Prioritize: ${priority}.`);
+      if (transport)
+        constraints.push(`Required transport: ${transport}.`);
+      if (authMethod)
+        constraints.push(`Required auth: ${authMethod}.`);
+      return [
+        {
+          type: "text",
+          text: `Recommend the best AI model for: "${task}".${constraints.length ? ` ${constraints.join(" ")}` : ""} Use the leaderboard data to justify your recommendation.`
+        },
+        {
+          type: "resource",
+          uri: priority ? `ranking://leaderboard/${priority}` : "ranking://leaderboard",
+          title: "Leaderboard"
+        }
+      ];
+    }
+  }));
+  return prompts;
+}
+function buildRankingOps() {
+  const registry = new OperationSpecRegistry4;
+  const ingesterRegistry = createDefaultIngesterRegistry();
+  installOp4(registry, BenchmarkIngestCommand, async (args) => {
+    const store = getStore();
+    const source = args.source;
+    const ingester = ingesterRegistry.get(source);
+    if (!ingester) {
+      throw new Error(`No ingester registered for source: ${source}`);
+    }
+    const rawResults = await ingester.ingest({
+      sourceUrl: args.sourceUrl,
+      dimensions: args.dimensions
+    });
+    const normalized = normalizeBenchmarkResults(rawResults);
+    for (const result of normalized) {
+      await store.upsertBenchmarkResult(result);
+    }
+    return {
+      ingestionId: `ingest-${source}-${Date.now()}`,
+      source,
+      resultsCount: normalized.length,
+      status: "completed",
+      ingestedAt: new Date
+    };
+  });
+  installOp4(registry, BenchmarkRunCustomCommand, async (args) => {
+    return {
+      runId: `custom-${Date.now()}`,
+      evalSuiteKey: args.evalSuiteKey,
+      modelId: args.modelId,
+      status: "started",
+      startedAt: new Date
+    };
+  });
+  installOp4(registry, RankingRefreshCommand, async (args) => {
+    const store = getStore();
+    const allResults = [];
+    let offset = 0;
+    const pageSize = 500;
+    while (true) {
+      const page = await store.listBenchmarkResults({
+        limit: pageSize,
+        offset
+      });
+      allResults.push(...page.results);
+      if (allResults.length >= page.total || page.results.length < pageSize)
+        break;
+      offset += pageSize;
+    }
+    const existingRankings = new Map((await store.listModelRankings({ limit: 1e4 })).rankings.map((r) => [
+      r.modelId,
+      r
+    ]));
+    const weightOverrides = args.weightOverrides ? Array.isArray(args.weightOverrides) ? args.weightOverrides : [args.weightOverrides] : undefined;
+    const newRankings = computeModelRankings(allResults, weightOverrides ? {
+      weightOverrides
+    } : undefined, existingRankings);
+    for (const ranking of newRankings) {
+      await store.upsertModelRanking(ranking);
+    }
+    return {
+      modelsRanked: newRankings.length,
+      updatedAt: new Date,
+      status: "completed"
+    };
+  });
+  return registry;
+}
+function createProviderRankingMcpHandler(path2 = "/api/mcp/ranking") {
+  return createMcpElysiaHandler({
+    logger: appLogger,
+    path: path2,
+    serverName: "contractspec-ranking-mcp",
+    ops: buildRankingOps(),
+    resources: buildRankingResources(),
+    prompts: buildRankingPrompts()
+  });
+}
+function setProviderRankingStore(store) {
+  sharedStore = store;
+}
+
+// src/application/mcp/contractsMcpTools.ts
+import {
+  defineCommand as defineCommand3,
+  installOp as installOp5,
+  OperationSpecRegistry as OperationSpecRegistry5
+} from "@contractspec/lib.contracts-spec";
+import { defineSchemaModel as defineSchemaModel3, ScalarTypeEnum as ScalarTypeEnum3 } from "@contractspec/lib.schema";
+var OWNERS = ["@contractspec"];
+var TAGS = ["contracts", "mcp"];
+function buildContractsOps(services) {
+  const registry = new OperationSpecRegistry5;
+  const ListInput = defineSchemaModel3({
+    name: "ContractsListInput",
+    fields: {
+      pattern: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
+      type: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true }
+    }
+  });
+  const ListOutput = defineSchemaModel3({
+    name: "ContractsListOutput",
+    fields: {
+      specs: { type: ScalarTypeEnum3.JSON(), isOptional: false },
+      total: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false }
+    }
+  });
+  installOp5(registry, defineCommand3({
+    meta: {
+      key: "contracts.list",
+      version: "1.0.0",
+      stability: "beta",
+      owners: OWNERS,
+      tags: TAGS,
+      description: "List contract specs in the workspace.",
+      goal: "Discover available contracts by type, pattern, or owner.",
+      context: "Contracts MCP server."
+    },
+    io: { input: ListInput, output: ListOutput },
+    policy: { auth: "anonymous" }
+  }), async ({ pattern, type }) => {
+    const specs = await services.listSpecs({ pattern, type });
+    return { specs, total: specs.length };
+  });
+  const GetInput = defineSchemaModel3({
+    name: "ContractsGetInput",
+    fields: {
+      path: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false }
+    }
+  });
+  const GetOutput = defineSchemaModel3({
+    name: "ContractsGetOutput",
+    fields: {
+      content: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+      info: { type: ScalarTypeEnum3.JSON(), isOptional: false }
+    }
+  });
+  installOp5(registry, defineCommand3({
+    meta: {
+      key: "contracts.get",
+      version: "1.0.0",
+      stability: "beta",
+      owners: OWNERS,
+      tags: TAGS,
+      description: "Read a single contract spec file.",
+      goal: "Fetch spec content and parsed metadata.",
+      context: "Contracts MCP server."
+    },
+    io: { input: GetInput, output: GetOutput },
+    policy: { auth: "anonymous" }
+  }), async ({ path: path2 }) => {
+    const result = await services.getSpec(path2);
+    if (!result)
+      throw new Error(`Spec not found: ${path2}`);
+    return result;
+  });
+  const ValidateInput = defineSchemaModel3({
+    name: "ContractsValidateInput",
+    fields: {
+      path: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false }
+    }
+  });
+  const ValidateOutput = defineSchemaModel3({
+    name: "ContractsValidateOutput",
+    fields: {
+      valid: { type: ScalarTypeEnum3.Boolean(), isOptional: false },
+      errors: { type: ScalarTypeEnum3.JSON(), isOptional: false },
+      warnings: { type: ScalarTypeEnum3.JSON(), isOptional: false }
+    }
+  });
+  installOp5(registry, defineCommand3({
+    meta: {
+      key: "contracts.validate",
+      version: "1.0.0",
+      stability: "beta",
+      owners: OWNERS,
+      tags: TAGS,
+      description: "Validate a contract spec structure.",
+      goal: "Check spec for structural or policy issues.",
+      context: "Contracts MCP server."
+    },
+    io: { input: ValidateInput, output: ValidateOutput },
+    policy: { auth: "anonymous" }
+  }), async ({ path: path2 }) => services.validateSpec(path2));
+  const BuildInput = defineSchemaModel3({
+    name: "ContractsBuildInput",
+    fields: {
+      path: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+      dryRun: { type: ScalarTypeEnum3.Boolean(), isOptional: true }
+    }
+  });
+  const BuildOutput = defineSchemaModel3({
+    name: "ContractsBuildOutput",
+    fields: {
+      results: { type: ScalarTypeEnum3.JSON(), isOptional: false }
+    }
+  });
+  installOp5(registry, defineCommand3({
+    meta: {
+      key: "contracts.build",
+      version: "1.0.0",
+      stability: "beta",
+      owners: OWNERS,
+      tags: TAGS,
+      description: "Generate implementation code from a contract spec.",
+      goal: "Produce handler, component, or test skeletons.",
+      context: "Contracts MCP server."
+    },
+    io: { input: BuildInput, output: BuildOutput },
+    policy: { auth: "user" }
+  }), async ({ path: path2, dryRun }) => services.buildSpec(path2, { dryRun }));
+  registerMutationTools(registry, services);
+  return registry;
+}
+function registerMutationTools(registry, services) {
+  const UpdateInput = defineSchemaModel3({
+    name: "ContractsUpdateInput",
+    fields: {
+      path: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+      content: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
+      fields: { type: ScalarTypeEnum3.JSON(), isOptional: true }
+    }
+  });
+  const UpdateOutput = defineSchemaModel3({
+    name: "ContractsUpdateOutput",
+    fields: {
+      updated: { type: ScalarTypeEnum3.Boolean(), isOptional: false },
+      errors: { type: ScalarTypeEnum3.JSON(), isOptional: false },
+      warnings: { type: ScalarTypeEnum3.JSON(), isOptional: false }
+    }
+  });
+  installOp5(registry, defineCommand3({
+    meta: {
+      key: "contracts.update",
+      version: "1.0.0",
+      stability: "beta",
+      owners: OWNERS,
+      tags: TAGS,
+      description: "Update an existing contract spec.",
+      goal: "Modify spec content or individual fields with validation.",
+      context: "Contracts MCP server."
+    },
+    io: { input: UpdateInput, output: UpdateOutput },
+    policy: { auth: "user" }
+  }), async ({ path: path2, content, fields }) => services.updateSpec(path2, {
+    content,
+    fields: Array.isArray(fields) ? fields : undefined
+  }));
+  const DeleteInput = defineSchemaModel3({
+    name: "ContractsDeleteInput",
+    fields: {
+      path: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+      clean: { type: ScalarTypeEnum3.Boolean(), isOptional: true }
+    }
+  });
+  const DeleteOutput = defineSchemaModel3({
+    name: "ContractsDeleteOutput",
+    fields: {
+      deleted: { type: ScalarTypeEnum3.Boolean(), isOptional: false },
+      cleanedFiles: { type: ScalarTypeEnum3.JSON(), isOptional: false },
+      errors: { type: ScalarTypeEnum3.JSON(), isOptional: false }
+    }
+  });
+  installOp5(registry, defineCommand3({
+    meta: {
+      key: "contracts.delete",
+      version: "1.0.0",
+      stability: "beta",
+      owners: OWNERS,
+      tags: TAGS,
+      description: "Delete a contract spec and optionally its artifacts.",
+      goal: "Remove a spec file and clean generated handlers/tests.",
+      context: "Contracts MCP server."
+    },
+    io: { input: DeleteInput, output: DeleteOutput },
+    policy: { auth: "user" }
+  }), async ({ path: path2, clean }) => services.deleteSpec(path2, { clean }));
+}
+
+// src/application/mcp/contractsMcpResources.ts
+import {
+  definePrompt as definePrompt5,
+  defineResourceTemplate as defineResourceTemplate5,
+  PromptRegistry as PromptRegistry5,
+  ResourceRegistry as ResourceRegistry5
+} from "@contractspec/lib.contracts-spec";
+import z5 from "zod";
+var OWNERS2 = ["@contractspec"];
+var TAGS2 = ["contracts", "mcp"];
+function buildContractsResources(services) {
+  const resources = new ResourceRegistry5;
+  resources.register(defineResourceTemplate5({
+    meta: {
+      uriTemplate: "contracts://list",
+      title: "Contract specs list",
+      description: "JSON list of all contract specs in the workspace.",
+      mimeType: "application/json",
+      tags: TAGS2
+    },
+    input: z5.object({}),
+    resolve: async () => {
+      const specs = await services.listSpecs();
+      return {
+        uri: "contracts://list",
+        mimeType: "application/json",
+        data: JSON.stringify(specs, null, 2)
+      };
+    }
+  }));
+  resources.register(defineResourceTemplate5({
+    meta: {
+      uriTemplate: "contracts://spec/{path}",
+      title: "Contract spec content",
+      description: "Read a single contract spec file by path.",
+      mimeType: "text/plain",
+      tags: TAGS2
+    },
+    input: z5.object({ path: z5.string() }),
+    resolve: async ({ path: path2 }) => {
+      const result = await services.getSpec(path2);
+      if (!result) {
+        return {
+          uri: `contracts://spec/${encodeURIComponent(path2)}`,
+          mimeType: "text/plain",
+          data: `Spec not found: ${path2}`
+        };
+      }
+      return {
+        uri: `contracts://spec/${encodeURIComponent(path2)}`,
+        mimeType: "text/plain",
+        data: result.content
+      };
+    }
+  }));
+  resources.register(defineResourceTemplate5({
+    meta: {
+      uriTemplate: "contracts://registry/manifest",
+      title: "Remote registry manifest",
+      description: "Contract registry manifest from the remote server.",
+      mimeType: "application/json",
+      tags: TAGS2
+    },
+    input: z5.object({}),
+    resolve: async () => {
+      const manifest = await services.fetchRegistryManifest();
+      return {
+        uri: "contracts://registry/manifest",
+        mimeType: "application/json",
+        data: JSON.stringify(manifest, null, 2)
+      };
+    }
+  }));
+  return resources;
+}
+function buildContractsPrompts() {
+  const prompts = new PromptRegistry5;
+  prompts.register(definePrompt5({
+    meta: {
+      key: "contracts.editor",
+      version: "1.0.0",
+      title: "Contract editing guide",
+      description: "Guide AI agents through reading, editing, and validating contracts.",
+      tags: TAGS2,
+      stability: "beta",
+      owners: OWNERS2
+    },
+    args: [
+      {
+        name: "goal",
+        description: "What the agent wants to achieve with the contract.",
+        required: false,
+        schema: z5.string().optional()
+      }
+    ],
+    input: z5.object({ goal: z5.string().optional() }),
+    render: async ({ goal }) => [
+      {
+        type: "text",
+        text: [
+          "Contract editing workflow:",
+          "1. Use contracts.list to discover specs",
+          "2. Use contracts.get to read a spec",
+          "3. Edit content and call contracts.update",
+          "4. Run contracts.validate to verify changes",
+          "5. Run contracts.build to regenerate artifacts",
+          goal ? `Agent goal: ${goal}` : ""
+        ].filter(Boolean).join(`
+`)
+      },
+      {
+        type: "resource",
+        uri: "contracts://list",
+        title: "Available contracts"
+      }
+    ]
+  }));
+  return prompts;
+}
+
+// src/application/mcp/contractsMcp.ts
+function createContractsMcpHandler(path2 = "/api/mcp/contracts", services) {
+  return createMcpElysiaHandler({
+    logger: appLogger,
+    path: path2,
+    serverName: "contractspec-contracts-mcp",
+    ops: buildContractsOps(services),
+    resources: buildContractsResources(services),
+    prompts: buildContractsPrompts()
+  });
+}
 export {
+  setProviderRankingStore,
+  createProviderRankingMcpHandler,
   createInternalMcpHandler,
   createDocsMcpHandler,
+  createContractsMcpHandler,
+  createContextStorageService,
   createCliMcpHandler
 };