@fragments-sdk/mcp 0.10.1 → 1.0.1

package/dist/index.js

@@ -1,223 +1,1123 @@
-import {
-  AutoExtractionAdapter,
-  BUILTIN_TOOLS,
-  CORE_TOOLS,
-  FragmentsJsonAdapter,
-  INFRA_TOOLS,
-  ToolRegistry,
-  VIEWER_TOOLS,
-  blockFromCompiledBlock,
-  buildCapabilities,
-  componentFromCompiledFragment,
-  createMcpServer,
-  createSandboxServer,
-  executeWithMiddleware,
-  loadConfigFile,
-  startMcpServer,
-  telemetryMiddleware,
-  tokensFromCompiledTokenData,
-  validateSnapshot
-} from "./chunk-KGFM5SCE.js";
-import {
-  generateRulesFiles
-} from "./chunk-WDQPNHZ2.js";
-import "./chunk-7D4SUZUM.js";
+// src/apps/resources.ts
+var MCP_APP_RESOURCES = [];
+function getResource(_uri) {
+  return null;
+}
+function listResources() {
+  return [];
+}
 
-// src/adapters/custom-json.ts
-import { readFile } from "fs/promises";
-import { existsSync } from "fs";
-import { mcpSnapshotSchema } from "@fragments-sdk/core";
-var CustomJsonAdapter = class {
-  constructor(filePath) {
-    this.filePath = filePath;
-  }
-  filePath;
-  name = "custom-json";
-  discover() {
-    return existsSync(this.filePath) ? [this.filePath] : [];
-  }
-  async load(_projectRoot = "") {
-    if (!existsSync(this.filePath)) {
-      throw new Error(`Custom data file not found: ${this.filePath}`);
-    }
-    const content = await readFile(this.filePath, "utf-8");
-    const raw = JSON.parse(content);
-    if (raw.schemaVersion === 1 && typeof raw.sourceType === "string" && raw.components && typeof raw.components === "object") {
-      const snapshot2 = mcpSnapshotSchema.parse(raw);
-      return {
-        snapshot: snapshot2,
-        components: snapshot2.components,
-        blocks: snapshot2.blocks,
-        tokens: snapshot2.tokens,
-        graph: snapshot2.graph,
-        performanceSummary: snapshot2.performanceSummary,
-        packageMap: snapshot2.packageMap,
-        defaultPackageName: snapshot2.defaultPackageName,
-        capabilities: new Set(snapshot2.capabilities)
+// src/tasks/store.ts
+var nextTaskId = 1;
+function createTaskId() {
+  const id = `task_${String(nextTaskId).padStart(6, "0")}`;
+  nextTaskId += 1;
+  return id;
+}
+var MemoryTaskStore = class {
+  tasks = /* @__PURE__ */ new Map();
+  async create(input) {
+    const now = Date.now();
+    const result = input.result ?? completedWorkflowResult(input.workflow?.kind);
+    const task = {
+      taskId: createTaskId(),
+      title: input.title,
+      status: result ? "completed" : "working",
+      createdAt: now,
+      updatedAt: now,
+      ttlMs: input.ttlMs ?? 15 * 60 * 1e3,
+      pollIntervalMs: input.pollIntervalMs ?? 1e3,
+      result,
+      progress: result ? { current: 1, total: 1, message: "Completed" } : { current: 0, total: 1, message: "Queued" }
+    };
+    this.tasks.set(task.taskId, task);
+    return task;
+  }
+  async get(taskId) {
+    return this.tasks.get(taskId) ?? null;
+  }
+  async update(taskId, patch) {
+    const existing = this.tasks.get(taskId);
+    if (!existing) return null;
+    const next = {
+      ...existing,
+      ...patch,
+      taskId,
+      updatedAt: Date.now()
+    };
+    this.tasks.set(taskId, next);
+    return next;
+  }
+  async cancel(taskId) {
+    return this.update(taskId, {
+      status: "cancelled",
+      progress: { message: "Cancellation requested" }
+    });
+  }
+};
+function completedWorkflowResult(kind) {
+  if (!kind) return void 0;
+  return {
+    content: [{ type: "text", text: `${kind} queued.` }],
+    structuredContent: {
+      kind,
+      status: "queued",
+      message: "Fragments accepted the workflow request. The hosted runtime attaches concrete job details."
+    }
+  };
+}
+
+// src/spec/generated/schema.ts
+var LATEST_PROTOCOL_VERSION = "DRAFT-2026-v1";
+var JSONRPC_VERSION = "2.0";
+
+// src/tools/primitives.ts
+var primitiveSchema = {
+  type: "object",
+  properties: {
+    id: { type: "string" },
+    name: { type: "string" },
+    primitiveName: { type: "string" },
+    filePath: { type: ["string", "null"] },
+    importPath: { type: ["string", "null"] },
+    packageName: { type: ["string", "null"] },
+    description: { type: "string" },
+    usageGuidance: { type: "string" },
+    props: { type: "object" },
+    examples: { type: "array" },
+    sourceRepoFullName: { type: ["string", "null"] }
+  },
+  required: ["id", "name", "primitiveName", "filePath", "importPath"],
+  additionalProperties: true
+};
+var primitiveTools = [
+  {
+    name: "design_system/list_primitives",
+    title: "List Primitives",
+    description: "List the design-system primitives curated in Fragments Cloud. Returns only reviewed primitives with their source file paths.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false,
+      maxProperties: 0
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        primitiveCount: { type: "integer" },
+        primitives: { type: "array", items: primitiveSchema }
+      },
+      required: ["primitiveCount", "primitives"],
+      additionalProperties: false
+    },
+    annotations: {
+      readOnlyHint: true,
+      idempotentHint: true
+    },
+    async call(_args, context) {
+      const primitives = await context.provider.listPrimitives();
+      return primitiveResult(primitives);
+    }
+  }
+];
+function primitiveResult(primitives) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: primitives.length === 0 ? "No primitives have been selected in Fragments Cloud yet." : `Found ${primitives.length} primitives.`
+      }
+    ],
+    structuredContent: {
+      primitiveCount: primitives.length,
+      primitives: primitives.map(normalizePrimitive)
+    }
+  };
+}
+function normalizePrimitive(primitive) {
+  return {
+    id: primitive.id,
+    name: primitive.name,
+    primitiveName: primitive.primitiveName ?? primitive.name,
+    filePath: primitive.filePath ?? null,
+    importPath: primitive.importPath ?? null,
+    packageName: primitive.packageName ?? null,
+    description: primitive.description ?? "",
+    usageGuidance: primitive.usageGuidance ?? "",
+    props: primitive.props ?? {},
+    examples: primitive.examples ?? [],
+    sourceRepoFullName: primitive.sourceRepoFullName ?? null
+  };
+}
+
+// src/tools/conform.ts
+var locationSchema = {
+  type: "object",
+  properties: {
+    line: { type: "integer" },
+    column: { type: "integer" },
+    endLine: { type: "integer" },
+    endColumn: { type: "integer" }
+  },
+  additionalProperties: false
+};
+var changeSchema = {
+  type: "object",
+  properties: {
+    kind: {
+      type: "string",
+      enum: ["swap-component", "rewrite-import", "rename-prop", "replace-token", "add-fallback"]
+    },
+    ruleId: { type: "string" },
+    code: { type: "string" },
+    severity: { type: "string", enum: ["error", "warning", "info"] },
+    message: { type: "string" },
+    before: { type: "string" },
+    after: { type: "string" },
+    canonical: { type: "string" },
+    confidence: { type: "string", enum: ["high", "medium", "low"] },
+    location: locationSchema
+  },
+  required: ["kind", "severity", "message", "confidence"],
+  additionalProperties: false
+};
+var suggestionSchema = {
+  type: "object",
+  properties: {
+    kind: {
+      type: "string",
+      enum: ["map-prop-value", "choose-among-alternates", "review-low-confidence"]
+    },
+    message: { type: "string" },
+    canonical: { type: "string" },
+    hint: { type: "string" },
+    confidence: { type: "string", enum: ["high", "medium", "low"] },
+    location: locationSchema
+  },
+  required: ["kind", "message", "confidence"],
+  additionalProperties: false
+};
+var unresolvedSchema = {
+  type: "object",
+  properties: {
+    element: { type: "string" },
+    canonical: { type: "string" },
+    reason: { type: "string" },
+    location: locationSchema
+  },
+  required: ["reason"],
+  additionalProperties: false
+};
+var conformTools = [
+  {
+    name: "design_system/conform",
+    title: "Conform to Design System",
+    description: "Rewrite a snippet of UI code so it matches THIS project's design system. Swaps raw HTML elements and components from other libraries (Material UI, shadcn/ui, Chakra, or custom) to the project's own components and import paths, replaces hardcoded colors/spacing/radii with the project's design tokens, and flags accessibility gaps. Call this whenever the user says 'fix this', 'make this match our design system', 'use our components here', right after pasting markup from elsewhere, or before committing UI you wrote. Input is the code itself \u2014 no repo access needed. Returns a conformed version plus a list of changes with rationale; ambiguous cross-library prop changes come back as suggestions for you to apply.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        code: {
+          type: "string",
+          description: "The UI code to conform (JSX/TSX, HTML, or a CSS/SCSS block)."
+        },
+        filename: {
+          type: "string",
+          description: "Filename or extension hint for parser selection (e.g. 'Form.tsx', 'styles.scss'). Defaults to TSX."
+        },
+        apply: {
+          type: "string",
+          enum: ["deterministic", "none"],
+          description: "deterministic (default): return code with safe edits applied. none: findings only."
+        }
+      },
+      required: ["code"],
+      additionalProperties: false
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        conformed: { type: "string" },
+        changed: { type: "boolean" },
+        summary: { type: "string" },
+        designSystem: {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            importsAdded: { type: "array", items: { type: "string" } }
+          },
+          required: ["importsAdded"],
+          additionalProperties: false
+        },
+        changes: { type: "array", items: changeSchema },
+        suggestions: { type: "array", items: suggestionSchema },
+        unresolved: { type: "array", items: unresolvedSchema }
+      },
+      required: ["conformed", "changed", "changes", "suggestions"],
+      additionalProperties: false
+    },
+    annotations: {
+      readOnlyHint: true,
+      idempotentHint: true,
+      // Output depends on the `code` argument, so it must not be served from a
+      // tenant-wide cache the way argument-free tools (list_primitives) are.
+      cacheScope: "none",
+      ttlMs: 0
+    },
+    async call(args, context) {
+      const input = {
+        code: typeof args.code === "string" ? args.code : "",
+        filename: typeof args.filename === "string" ? args.filename : void 0,
+        apply: args.apply === "none" ? "none" : "deterministic"
       };
+      const result = await context.provider.conform(input);
+      return conformResult(result);
     }
-    if (!raw.components || typeof raw.components !== "object") {
-      throw new Error(
-        `Invalid design system data: "components" field is required and must be an object. File: ${this.filePath}`
-      );
-    }
-    const packageMap = raw.packageMap ?? {};
-    const defaultPackageName = raw.defaultPackageName;
-    const metadata = raw.metadata;
-    const components = Object.fromEntries(
-      Object.entries(raw.components).map(
-        ([key, fragment]) => [
-          key,
-          componentFromCompiledFragment({
-            id: key,
-            fragment,
-            sourceType: "custom-json",
-            packageName: packageMap[fragment.meta.name] ?? defaultPackageName,
-            importPath: packageMap[fragment.meta.name] ?? defaultPackageName
-          })
-        ]
-      )
-    );
-    const blocks = raw.blocks ? Object.fromEntries(
-      Object.entries(raw.blocks).map(
-        ([key, block]) => [key, blockFromCompiledBlock(key, block)]
-      )
-    ) : void 0;
-    const tokens = raw.tokens ? tokensFromCompiledTokenData(raw.tokens) : void 0;
-    const snapshot = validateSnapshot({
-      schemaVersion: 1,
-      sourceType: "custom-json",
-      sourceLabel: this.filePath,
-      capabilities: buildCapabilities({
-        components,
-        blocks,
-        tokens,
-        graph: raw.graph,
-        performanceSummary: raw.performanceSummary
-      }),
-      metadata: {
-        designSystemName: metadata?.designSystemName,
-        packageName: metadata?.packageName ?? defaultPackageName,
-        importPath: metadata?.importPath ?? defaultPackageName,
-        revision: metadata?.revision,
-        updatedAt: metadata?.updatedAt
+  }
+];
+function conformResult(result) {
+  const summary = result.summary || defaultSummary(result);
+  return {
+    content: [{ type: "text", text: summary }],
+    structuredContent: {
+      conformed: result.conformed,
+      changed: result.changed,
+      summary,
+      ...result.designSystem ? {
+        designSystem: {
+          ...result.designSystem.name ? { name: result.designSystem.name } : {},
+          importsAdded: result.designSystem.importsAdded ?? []
+        }
+      } : {},
+      changes: result.changes,
+      suggestions: result.suggestions,
+      unresolved: result.unresolved
+    }
+  };
+}
+function defaultSummary(result) {
+  if (!result.changed && result.changes.length === 0) {
+    return "No conformance changes were applied.";
+  }
+  return `Applied ${result.changes.length} change(s); ${result.suggestions.length} suggestion(s) left for review.`;
+}
+
+// src/tools/prove-compliant-schema.ts
+var locationSchema2 = {
+  type: "object",
+  properties: {
+    line: { type: "integer" },
+    column: { type: "integer" },
+    endLine: { type: "integer" },
+    endColumn: { type: "integer" }
+  },
+  additionalProperties: false
+};
+var residualSchema = {
+  type: "object",
+  properties: {
+    reason: { type: "string" },
+    message: { type: "string" },
+    canonical: { type: "string" },
+    element: { type: "string" },
+    hint: { type: "string" },
+    confidence: { type: "string" },
+    location: locationSchema2
+  },
+  additionalProperties: true
+};
+var proveCompliantOutputSchema = {
+  type: "object",
+  properties: {
+    provedCompliant: { type: "boolean" },
+    conformed: { type: "string" },
+    changed: { type: "boolean" },
+    passes: { type: "integer" },
+    maxPasses: { type: "integer" },
+    initialIssueCount: { type: "integer" },
+    finalIssueCount: { type: "integer" },
+    corrections: { type: "integer" },
+    summary: { type: "string" },
+    taskId: { type: "string" },
+    changes: { type: "array", items: { type: "object", additionalProperties: true } },
+    suggestions: { type: "array", items: residualSchema },
+    unresolved: { type: "array", items: residualSchema },
+    passHistory: { type: "array", items: { type: "object", additionalProperties: true } }
+  },
+  required: [
+    "provedCompliant",
+    "conformed",
+    "changed",
+    "passes",
+    "maxPasses",
+    "initialIssueCount",
+    "finalIssueCount",
+    "corrections",
+    "summary",
+    "changes",
+    "suggestions",
+    "unresolved",
+    "passHistory"
+  ],
+  additionalProperties: false
+};
+
+// src/tools/prove-compliant.ts
+var TOOL_NAME = "design_system/prove_compliant";
+var DEFAULT_MAX_PASSES = 4;
+var MAX_PASSES = 8;
+var DEFAULT_TTL_MS = 15 * 60 * 1e3;
+var proveCompliantTools = [
+  {
+    name: TOOL_NAME,
+    title: "Prove Design-System Compliance",
+    description: "Run a closed validate-fix-validate loop over generated UI code until Fragments can prove it has zero design-system findings, or return the remaining issues. Uses deterministic fixes first, then MCP Sampling when the connected client supports it.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        code: {
+          type: "string",
+          description: "The UI code to prove compliant."
+        },
+        filename: {
+          type: "string",
+          description: "Filename or extension hint. Defaults to TSX."
+        },
+        maxPasses: {
+          type: "integer",
+          minimum: 1,
+          maximum: MAX_PASSES,
+          description: "Maximum validation/fix passes. Defaults to 4."
+        },
+        allowSampling: {
+          type: "boolean",
+          description: "Allow MCP Sampling for residual issues. Defaults to true."
+        }
       },
-      components,
-      blocks,
-      tokens,
-      graph: raw.graph,
-      performanceSummary: raw.performanceSummary,
-      packageMap,
-      defaultPackageName
+      required: ["code"],
+      additionalProperties: false
+    },
+    outputSchema: proveCompliantOutputSchema,
+    annotations: {
+      readOnlyHint: true,
+      idempotentHint: false,
+      cacheScope: "none",
+      ttlMs: 0
+    },
+    async call(args, context) {
+      return proveCompliant(args, context);
+    }
+  }
+];
+async function proveCompliant(args, context) {
+  const restored = decodeState(context.requestState);
+  const input = restored ?? initialState(args);
+  const task = await ensureTask(context, input);
+  if (task) input.taskId = task.taskId;
+  const sampled = consumeSamplingResponse(input, context.inputResponses);
+  if (sampled) {
+    input.samplingAttempts += 1;
+    if (sampled.code) {
+      input.code = sampled.code;
+    }
+    const last = input.passHistory[input.passHistory.length - 1];
+    if (last) {
+      last.sampling = {
+        ...last.sampling ?? {},
+        used: Boolean(sampled.code),
+        model: sampled.model,
+        stopReason: sampled.stopReason,
+        reason: sampled.reason
+      };
+    }
+  }
+  let current = input.code;
+  let lastResult = null;
+  while (input.passHistory.length < input.maxPasses) {
+    const pass = input.passHistory.length + 1;
+    await updateTask(context, input.taskId, {
+      status: "working",
+      progress: {
+        current: pass,
+        total: input.maxPasses,
+        message: `Validating pass ${pass}`
+      }
+    });
+    const result = await context.provider.conform({
+      code: current,
+      filename: input.filename,
+      apply: "deterministic"
     });
+    lastResult = result;
+    const issues = issueCount(result);
+    input.passHistory.push({
+      pass,
+      issues,
+      deterministicChanges: result.changes.length,
+      suggestions: result.suggestions.length,
+      unresolved: result.unresolved.length,
+      changed: result.changed
+    });
+    input.corrections += result.changes.length;
+    if (issues === 0) {
+      const final2 = completeResult({
+        state: input,
+        result,
+        originalCode: args.code,
+        provedCompliant: true,
+        reason: `0 findings after ${pass} pass${pass === 1 ? "" : "es"}.`
+      });
+      return finish(context, input.taskId, final2);
+    }
+    if (result.changed && result.conformed !== current) {
+      current = result.conformed;
+      input.code = current;
+      continue;
+    }
+    const residual = {
+      suggestions: result.suggestions,
+      unresolved: result.unresolved
+    };
+    if (canUseSampling(input, context, residual)) {
+      return requestSampling({ state: input, context, current, residual });
+    }
+    break;
+  }
+  const fallback = lastResult ?? emptyConformResult(current);
+  const final = completeResult({
+    state: input,
+    result: fallback,
+    originalCode: args.code,
+    provedCompliant: false,
+    reason: incompleteReason(input, context, fallback)
+  });
+  return finish(context, input.taskId, final);
+}
+function initialState(args) {
+  return {
+    tool: TOOL_NAME,
+    code: typeof args.code === "string" ? args.code : "",
+    filename: typeof args.filename === "string" ? args.filename : void 0,
+    maxPasses: typeof args.maxPasses === "number" ? Math.min(MAX_PASSES, Math.max(1, Math.trunc(args.maxPasses))) : DEFAULT_MAX_PASSES,
+    allowSampling: args.allowSampling !== false,
+    passHistory: [],
+    corrections: 0,
+    samplingAttempts: 0
+  };
+}
+async function ensureTask(context, state) {
+  try {
+    if (state.taskId) return await context.tasks.get(state.taskId);
+    return await context.tasks.create({
+      title: "Prove UI compliance",
+      ttlMs: DEFAULT_TTL_MS,
+      pollIntervalMs: 500
+    });
+  } catch {
+    return null;
+  }
+}
+async function requestSampling(args) {
+  const requestKey = `prove_compliant_sampling_${args.state.passHistory.length}`;
+  args.state.requestKey = requestKey;
+  const last = args.state.passHistory[args.state.passHistory.length - 1];
+  if (last) last.sampling = { requested: true };
+  await updateTask(args.context, args.state.taskId, {
+    status: "input_required",
+    progress: {
+      current: args.state.passHistory.length,
+      total: args.state.maxPasses,
+      message: "Waiting for MCP Sampling to repair residual issues"
+    }
+  });
+  return {
+    resultType: "input_required",
+    inputRequests: {
+      [requestKey]: {
+        method: "sampling/createMessage",
+        params: {
+          messages: [
+            {
+              role: "user",
+              content: {
+                type: "text",
+                text: samplingPrompt(args.current, args.residual)
+              }
+            }
+          ],
+          systemPrompt: "You repair UI code for Fragments design-system governance. Return only JSON with a single string field named code.",
+          includeContext: "none",
+          maxTokens: 4e3,
+          temperature: 0.1,
+          modelPreferences: {
+            costPriority: 0.2,
+            speedPriority: 0.3,
+            intelligencePriority: 0.8
+          }
+        }
+      }
+    },
+    requestState: encodeState(args.state)
+  };
+}
+function canUseSampling(state, context, residual) {
+  if (!state.allowSampling) return false;
+  if (state.samplingAttempts >= state.maxPasses - 1) return false;
+  if (residual.suggestions.length === 0 && residual.unresolved.length === 0) return false;
+  const sampling = context.clientCapabilities?.sampling;
+  return Boolean(sampling && typeof sampling === "object");
+}
+function consumeSamplingResponse(state, responses) {
+  if (!state.requestKey || !responses) return null;
+  const response = responses[state.requestKey];
+  if (!response) return null;
+  const text = extractText(response.content);
+  const code = extractSampledCode(text);
+  state.requestKey = void 0;
+  if (!code) {
     return {
-      snapshot,
-      components: snapshot.components,
-      blocks: snapshot.blocks,
-      tokens: snapshot.tokens,
-      graph: snapshot.graph,
-      performanceSummary: snapshot.performanceSummary,
-      packageMap: snapshot.packageMap,
-      defaultPackageName: snapshot.defaultPackageName,
-      capabilities: new Set(snapshot.capabilities)
+      attempted: true,
+      reason: "sampling response did not include code",
+      model: typeof response.model === "string" ? response.model : void 0,
+      stopReason: typeof response.stopReason === "string" ? response.stopReason : void 0
     };
   }
-};
+  return {
+    attempted: true,
+    code,
+    model: typeof response.model === "string" ? response.model : void 0,
+    stopReason: typeof response.stopReason === "string" ? response.stopReason : void 0
+  };
+}
+function completeResult(args) {
+  const initialIssueCount = args.state.passHistory[0]?.issues ?? 0;
+  const finalIssueCount = issueCount(args.result);
+  const changed = typeof args.originalCode === "string" && args.result.conformed !== args.originalCode;
+  const summary = args.provedCompliant ? `Proved compliant: ${args.reason}` : `Could not prove compliance: ${args.reason}`;
+  return {
+    content: [{ type: "text", text: summary }],
+    structuredContent: {
+      provedCompliant: args.provedCompliant,
+      conformed: args.result.conformed,
+      changed,
+      passes: args.state.passHistory.length,
+      maxPasses: args.state.maxPasses,
+      initialIssueCount,
+      finalIssueCount,
+      corrections: args.state.corrections,
+      summary,
+      taskId: args.state.taskId,
+      changes: args.result.changes,
+      suggestions: args.result.suggestions,
+      unresolved: args.result.unresolved,
+      passHistory: args.state.passHistory
+    }
+  };
+}
+async function finish(context, taskId, result) {
+  await updateTask(context, taskId, {
+    status: "completed",
+    result,
+    progress: { current: 1, total: 1, message: "Proof loop completed" }
+  });
+  return result;
+}
+async function updateTask(context, taskId, patch) {
+  if (!taskId) return null;
+  try {
+    return await context.tasks.update(taskId, patch);
+  } catch {
+    return null;
+  }
+}
+function issueCount(result) {
+  return result.changes.length + result.suggestions.length + result.unresolved.length;
+}
+function incompleteReason(state, context, result) {
+  if (state.passHistory.length >= state.maxPasses) {
+    return `stopped after ${state.maxPasses} passes with ${issueCount(result)} finding(s).`;
+  }
+  if (!state.allowSampling) return "sampling was disabled and residual issues remain.";
+  if (!context.clientCapabilities?.sampling) {
+    return "the MCP client did not declare sampling support and residual issues remain.";
+  }
+  return `${issueCount(result)} residual finding(s) remain after deterministic and sampled fixes.`;
+}
+function samplingPrompt(code, residual) {
+  return [
+    "Repair this UI code so it satisfies the remaining Fragments findings.",
+    "Preserve behavior, text, event handlers, and existing imports unless a finding requires a change.",
+    'Return JSON only: {"code":"...full revised code..."}.',
+    "",
+    "Remaining findings:",
+    JSON.stringify(residual, null, 2),
+    "",
+    "Current code:",
+    "```tsx",
+    code,
+    "```"
+  ].join("\n");
+}
+function extractText(content) {
+  if (!content) return "";
+  if (Array.isArray(content)) return content.map(extractText).join("\n");
+  if (typeof content === "object") {
+    const record = content;
+    return typeof record.text === "string" ? record.text : "";
+  }
+  return typeof content === "string" ? content : "";
+}
+function extractSampledCode(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (typeof parsed.code === "string" && parsed.code.trim()) return parsed.code;
+  } catch {
+  }
+  const fence = /```(?:[A-Za-z0-9_-]+)?\n([\s\S]*?)```/.exec(trimmed);
+  if (fence?.[1]?.trim()) return fence[1].trim();
+  return trimmed;
+}
+function encodeState(state) {
+  return JSON.stringify(state);
+}
+function decodeState(value) {
+  if (!value) return null;
+  try {
+    const parsed = JSON.parse(value);
+    return parsed?.tool === TOOL_NAME ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function emptyConformResult(code) {
+  return {
+    conformed: code,
+    changed: false,
+    summary: "No conform result was produced.",
+    changes: [],
+    suggestions: [],
+    unresolved: []
+  };
+}
+
+// src/tools/registry.ts
+var MAX_SCHEMA_DEPTH = 16;
+var MCP_TOOLS = [
+  ...primitiveTools,
+  ...conformTools,
+  ...proveCompliantTools
+];
+function getTool(name) {
+  return MCP_TOOLS.find((tool) => tool.name === name) ?? null;
+}
+function listToolDescriptors() {
+  return MCP_TOOLS.map(({ call: _call, ...tool }) => ({
+    ...tool,
+    inputSchema: validateToolSchema(tool.name, tool.inputSchema),
+    ...tool.outputSchema ? { outputSchema: validateToolSchema(tool.name, tool.outputSchema) } : {},
+    annotations: {
+      cacheScope: "tenant",
+      ttlMs: 6e4,
+      ...tool.annotations ?? {}
+    }
+  }));
+}
+function validateToolSchema(toolName, schema) {
+  assertSchemaNode(toolName, schema, 0);
+  return schema;
+}
+function assertSchemaNode(toolName, value, depth) {
+  if (depth > MAX_SCHEMA_DEPTH) {
+    throw new Error(`Tool ${toolName} schema exceeds maximum depth`);
+  }
+  if (!value || typeof value !== "object") return;
+  if (Array.isArray(value)) {
+    for (const item of value) assertSchemaNode(toolName, item, depth + 1);
+    return;
+  }
+  const record = value;
+  const ref = record.$ref;
+  if (typeof ref === "string" && !ref.startsWith("#/")) {
+    throw new Error(`Tool ${toolName} schema contains external $ref`);
+  }
+  for (const child of Object.values(record)) {
+    assertSchemaNode(toolName, child, depth + 1);
+  }
+}
 
-// src/orama-index.ts
-import { create, insertMultiple, search } from "@orama/orama";
-var SYNONYM_MAP = {
-  "form": ["input", "field", "submit", "validation"],
-  "input": ["form", "field", "text", "entry"],
-  "button": ["action", "click", "submit", "trigger"],
-  "action": ["button", "click", "trigger"],
-  "submit": ["button", "form", "action", "send"],
-  "alert": ["notification", "message", "warning", "error", "feedback"],
-  "notification": ["alert", "message", "toast"],
-  "feedback": ["form", "comment", "review", "rating"],
-  "card": ["container", "panel", "box", "content"],
-  "toggle": ["switch", "checkbox", "boolean", "on/off"],
-  "switch": ["toggle", "checkbox", "boolean"],
-  "badge": ["tag", "label", "status", "indicator"],
-  "status": ["badge", "indicator", "state"],
-  "login": ["auth", "signin", "authentication", "form"],
-  "auth": ["login", "signin", "authentication"],
-  "chat": ["message", "conversation", "ai"],
-  "table": ["data", "grid", "list", "rows"],
-  "textarea": ["text", "input", "multiline", "area", "comment"],
-  "area": ["textarea", "multiline", "text"],
-  "landing": ["page", "hero", "marketing", "section", "layout"],
-  "hero": ["landing", "marketing", "banner", "headline", "section"],
-  "marketing": ["landing", "hero", "pricing", "testimonial", "cta"],
-  "cta": ["marketing", "banner", "action", "button"],
-  "testimonial": ["marketing", "review", "quote", "feedback"],
-  "layout": ["stack", "grid", "box", "container", "page"],
-  "page": ["layout", "landing", "section", "container"],
-  "section": ["hero", "feature", "testimonial", "cta", "faq"],
-  "pricing": ["card", "plan", "tier", "marketing"],
-  "plan": ["pricing", "card", "tier", "subscription"],
-  "dashboard": ["metrics", "stats", "chart", "card", "grid"],
-  "metrics": ["dashboard", "stats", "progress", "number"],
-  "stats": ["metrics", "dashboard", "progress", "badge"],
-  "chart": ["dashboard", "metrics", "data", "graph"]
+// src/protocol/server.ts
+var McpProtocolError = class extends Error {
+  code;
+  data;
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+  }
 };
-var USE_CASE_TOKEN_CATEGORIES = {
-  "table": ["spacing", "borders", "surfaces", "text"],
-  "data": ["spacing", "borders", "surfaces"],
-  "grid": ["spacing", "layout"],
-  "form": ["spacing", "borders", "radius", "focus"],
-  "input": ["spacing", "borders", "radius", "focus"],
-  "card": ["surfaces", "shadows", "radius", "borders", "spacing"],
-  "button": ["colors", "radius", "spacing", "focus"],
-  "layout": ["spacing", "layout", "surfaces"],
-  "dashboard": ["spacing", "surfaces", "borders", "shadows"],
-  "chat": ["spacing", "surfaces", "radius", "shadows"],
-  "modal": ["shadows", "surfaces", "radius", "spacing"],
-  "dialog": ["shadows", "surfaces", "radius", "spacing"],
-  "navigation": ["spacing", "surfaces", "borders"],
-  "sidebar": ["spacing", "surfaces", "borders"],
-  "hero": ["spacing", "typography", "colors"],
-  "landing": ["spacing", "typography", "colors"],
-  "pricing": ["spacing", "surfaces", "borders", "radius"],
-  "auth": ["spacing", "borders", "radius", "focus"],
-  "login": ["spacing", "borders", "radius", "focus"],
-  "dark": ["colors", "surfaces"],
-  "theme": ["colors", "surfaces", "text"]
+var FragmentsMcpServer = class {
+  provider;
+  tasks;
+  constructor(options) {
+    this.provider = options.provider;
+    this.tasks = options.tasks ?? new MemoryTaskStore();
+  }
+  async handleJsonRpc(request) {
+    try {
+      const result = await this.dispatch(request);
+      return success(request.id ?? null, result);
+    } catch (error) {
+      return failure(request.id ?? null, toProtocolError(error));
+    }
+  }
+  async dispatch(request) {
+    const params = request.params ?? {};
+    switch (request.method) {
+      case "server/discover":
+        return this.discover();
+      case "tools/list":
+        return { tools: listToolDescriptors() };
+      case "tools/call":
+        return this.callTool(params);
+      case "resources/list":
+        return { resources: listResources() };
+      case "resources/read":
+        return this.readResource(params);
+      case "tasks/get":
+        return this.getTask(params);
+      case "tasks/update":
+        return this.updateTask(params);
+      case "tasks/cancel":
+        return this.cancelTask(params);
+      default:
+        throw new McpProtocolError(-32601, `Unknown MCP method ${request.method}`);
+    }
+  }
+  discover() {
+    return {
+      protocolVersion: LATEST_PROTOCOL_VERSION,
+      serverInfo: {
+        name: "@fragments-sdk/mcp",
+        version: "0.11.0-rc"
+      },
+      capabilities: {
+        tools: { listChanged: false }
+      }
+    };
+  }
+  async callTool(params) {
+    const name = requireString(params.name, "name");
+    const tool = getTool(name);
+    if (!tool) {
+      throw new McpProtocolError(-32602, `Unknown tool ${name}`);
+    }
+    const context = {
+      provider: this.provider,
+      tasks: this.tasks,
+      requestMeta: readMeta(params),
+      clientCapabilities: readClientCapabilities(params),
+      inputResponses: readInputResponses(params),
+      requestState: readRequestState(params)
+    };
+    const args = readArgs(params);
+    validateArgs(tool.name, tool.inputSchema, args);
+    return tool.call(args, context);
+  }
+  async readResource(params) {
+    const uri = requireString(params.uri, "uri");
+    const resource = getResource(uri);
+    if (!resource) {
+      throw new McpProtocolError(-32602, `Unknown resource ${uri}`);
+    }
+    return resource.read({
+      provider: this.provider,
+      tasks: this.tasks,
+      requestMeta: readMeta(params)
+    });
+  }
+  async getTask(params) {
+    const taskId = requireString(params.taskId, "taskId");
+    const task = await this.tasks.get(taskId);
+    if (!task) {
+      throw new McpProtocolError(-32602, `Unknown task ${taskId}`);
+    }
+    return { task };
+  }
+  async updateTask(params) {
+    const taskId = requireString(params.taskId, "taskId");
+    const task = await this.tasks.update(taskId, {});
+    if (!task) {
+      throw new McpProtocolError(-32602, `Unknown task ${taskId}`);
+    }
+    return { task };
+  }
+  async cancelTask(params) {
+    const taskId = requireString(params.taskId, "taskId");
+    const task = await this.tasks.cancel(taskId);
+    if (!task) {
+      throw new McpProtocolError(-32602, `Unknown task ${taskId}`);
+    }
+    return { task };
+  }
 };
+async function handleMcpJsonRpc(request, options) {
+  return new FragmentsMcpServer(options).handleJsonRpc(request);
+}
+async function handleMcpHttpRequest(request, options) {
+  let body;
+  try {
+    body = await request.json();
+  } catch {
+    return Response.json(failure(null, new McpProtocolError(-32700, "Invalid JSON")), {
+      status: 400
+    });
+  }
+  const response = await handleMcpJsonRpc(body, options);
+  return Response.json(response, {
+    status: "error" in response ? 400 : 200,
+    headers: {
+      "Cache-Control": "no-store",
+      "Mcp-Protocol-Version": LATEST_PROTOCOL_VERSION
+    }
+  });
+}
+function success(id, result) {
+  return { jsonrpc: "2.0", id, result };
+}
+function failure(id, error) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    error: {
+      code: error.code,
+      message: error.message,
+      data: error.data
+    }
+  };
+}
+function toProtocolError(error) {
+  if (error instanceof McpProtocolError) return error;
+  return new McpProtocolError(
+    -32603,
+    error instanceof Error ? error.message : "Internal MCP error"
+  );
+}
+function requireString(value, key) {
+  if (typeof value === "string" && value.trim()) return value.trim();
+  throw new McpProtocolError(-32602, `Missing ${key}`);
+}
+function readArgs(params) {
+  const args = params.arguments ?? {};
+  if (!args || typeof args !== "object" || Array.isArray(args)) return {};
+  return args;
+}
+function readMeta(params) {
+  const meta = params._meta;
+  if (!meta || typeof meta !== "object" || Array.isArray(meta)) return void 0;
+  return meta;
+}
+function readClientCapabilities(params) {
+  const meta = readMeta(params);
+  const capabilities = meta?.["io.modelcontextprotocol/clientCapabilities"];
+  if (!capabilities || typeof capabilities !== "object" || Array.isArray(capabilities)) {
+    return void 0;
+  }
+  return capabilities;
+}
+function readInputResponses(params) {
+  const responses = params.inputResponses;
+  if (!responses || typeof responses !== "object" || Array.isArray(responses)) {
+    return void 0;
+  }
+  return responses;
+}
+function readRequestState(params) {
+  return typeof params.requestState === "string" ? params.requestState : void 0;
+}
+function validateArgs(toolName, schema, args) {
+  if (schema.type !== "object") return;
+  const properties = readProperties(schema.properties);
+  const required = Array.isArray(schema.required) ? schema.required.filter((item) => typeof item === "string") : [];
+  const argCount = Object.keys(args).filter(
+    (key) => args[key] !== void 0 && args[key] !== null
+  ).length;
+  if (typeof schema.minProperties === "number" && argCount < schema.minProperties) {
+    throw new McpProtocolError(
+      -32602,
+      `Invalid arguments for ${toolName}: expected at least ${schema.minProperties} argument(s)`
+    );
+  }
+  if (typeof schema.maxProperties === "number" && argCount > schema.maxProperties) {
+    throw new McpProtocolError(
+      -32602,
+      `Invalid arguments for ${toolName}: expected at most ${schema.maxProperties} argument(s)`
+    );
+  }
+  for (const key of required) {
+    if (!(key in args) || args[key] === void 0 || args[key] === null) {
+      throw new McpProtocolError(-32602, `Invalid arguments for ${toolName}: missing ${key}`);
+    }
+    if (properties[key]?.type === "string" && typeof args[key] === "string" && !args[key].trim()) {
+      throw new McpProtocolError(-32602, `Invalid arguments for ${toolName}: missing ${key}`);
+    }
+  }
+  if (schema.additionalProperties === false) {
+    for (const key of Object.keys(args)) {
+      if (!(key in properties)) {
+        throw new McpProtocolError(-32602, `Invalid arguments for ${toolName}: unknown ${key}`);
+      }
+    }
+  }
+  for (const [key, value] of Object.entries(args)) {
+    const property = properties[key];
+    if (!property || value === void 0 || value === null) continue;
+    validateValue(toolName, key, property, value);
+  }
+}
+function readProperties(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const properties = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (child && typeof child === "object" && !Array.isArray(child)) {
+      properties[key] = child;
+    }
+  }
+  return properties;
+}
+function validateValue(toolName, key, schema, value) {
+  if (Array.isArray(schema.enum) && !schema.enum.includes(value)) {
+    throw new McpProtocolError(
+      -32602,
+      `Invalid arguments for ${toolName}: ${key} must be one of ${schema.enum.join(", ")}`
+    );
+  }
+  const type = schema.type;
+  if (typeof type !== "string") return;
+  const valid = type === "integer" ? typeof value === "number" && Number.isInteger(value) : type === "number" ? typeof value === "number" && Number.isFinite(value) : type === "string" ? typeof value === "string" : type === "boolean" ? typeof value === "boolean" : type === "object" ? !!value && typeof value === "object" && !Array.isArray(value) : true;
+  if (!valid) {
+    throw new McpProtocolError(-32602, `Invalid arguments for ${toolName}: ${key} must be ${type}`);
+  }
+  if (typeof value === "number" && typeof schema.minimum === "number" && value < schema.minimum) {
+    throw new McpProtocolError(
+      -32602,
+      `Invalid arguments for ${toolName}: ${key} must be >= ${schema.minimum}`
+    );
+  }
+  if (typeof value === "number" && typeof schema.maximum === "number" && value > schema.maximum) {
+    throw new McpProtocolError(
+      -32602,
+      `Invalid arguments for ${toolName}: ${key} must be <= ${schema.maximum}`
+    );
+  }
+}
 
-// src/scoring.ts
-var MINIMUM_SCORE_THRESHOLD = 5;
-var BLOCK_BOOST_PER_OCCURRENCE = 5;
-
-// src/search-config.ts
-var DEFAULT_SEARCH_CONFIG = {
-  synonyms: SYNONYM_MAP,
-  useCaseTokenCategories: USE_CASE_TOKEN_CATEGORIES,
-  minimumScoreThreshold: MINIMUM_SCORE_THRESHOLD,
-  blockBoostPerOccurrence: BLOCK_BOOST_PER_OCCURRENCE,
-  vectorSearchUrl: "https://combative-jay-834.convex.site/search",
-  vectorSearchTimeoutMs: 3e3
+// src/testing/fixtures.ts
+var fixturePrimitives = [
+  {
+    id: "button",
+    name: "Button",
+    primitiveName: "Button",
+    category: "Actions",
+    status: "ready",
+    description: "Primary action trigger.",
+    usageGuidance: "Use for explicit user actions.",
+    importPath: "@fixture/ui/button",
+    packageName: "@fixture/ui",
+    filePath: "src/components/Button.tsx",
+    sourceRepoFullName: "fixture/ui",
+    props: {
+      variant: {
+        type: '"primary" | "secondary"',
+        required: false,
+        description: "Visual emphasis."
+      }
+    }
+  }
+];
+var fixtureConformResult = {
+  conformed: 'import { Button } from "@fixture/ui";\n\n<Button variant="primary" style={{ padding: "var(--space-4)" }}>Send</Button>',
+  changed: true,
+  summary: "Swapped <button> to Button (@fixture/ui), mapped #2563eb to --brand-600 and 16px to --space-4, flagged a missing accessible name.",
+  designSystem: {
+    name: "Fixture UI",
+    importsAdded: ['import { Button } from "@fixture/ui";']
+  },
+  changes: [
+    {
+      kind: "swap-component",
+      ruleId: "components/preferred-component",
+      code: "FUI0410",
+      severity: "warning",
+      message: "Replaced native <button> with the design-system Button.",
+      before: "<button>",
+      after: '<Button variant="primary">',
+      canonical: "Button",
+      confidence: "high",
+      location: { line: 1, column: 1 }
+    },
+    {
+      kind: "replace-token",
+      ruleId: "styles/no-raw-color",
+      code: "FUI0601",
+      severity: "error",
+      message: "Replaced hardcoded color #2563eb with the matching design token.",
+      before: "#2563eb",
+      after: "var(--brand-600)",
+      confidence: "high",
+      location: { line: 1, column: 16 }
+    },
+    {
+      kind: "replace-token",
+      ruleId: "styles/no-raw-spacing",
+      code: "FUI0602",
+      severity: "warning",
+      message: "Replaced hardcoded 16px with the matching spacing token.",
+      before: "16px",
+      after: "var(--space-4)",
+      confidence: "high",
+      location: { line: 1, column: 38 }
+    }
+  ],
+  suggestions: [
+    {
+      kind: "review-low-confidence",
+      confidence: "medium",
+      message: 'Button has no accessible name beyond its text. Confirm "Send" is descriptive or add an aria-label.',
+      canonical: "Button",
+      location: { line: 1, column: 1 }
+    }
+  ],
+  unresolved: []
 };
-
-// src/index.ts
-import { BRAND } from "@fragments-sdk/core";
+function createFixtureProvider(args) {
+  const primitives = args?.primitives ?? fixturePrimitives;
+  const conformResult2 = args?.conform ?? fixtureConformResult;
+  return {
+    async listPrimitives() {
+      return primitives;
+    },
+    async conform() {
+      return conformResult2;
+    }
+  };
+}
 export {
-  AutoExtractionAdapter,
-  BRAND,
-  BUILTIN_TOOLS,
-  CORE_TOOLS,
-  CustomJsonAdapter,
-  DEFAULT_SEARCH_CONFIG,
-  FragmentsJsonAdapter,
-  INFRA_TOOLS,
-  ToolRegistry,
-  VIEWER_TOOLS,
-  createMcpServer,
-  createSandboxServer,
-  executeWithMiddleware,
-  generateRulesFiles,
-  loadConfigFile,
-  startMcpServer,
-  telemetryMiddleware
+  FragmentsMcpServer,
+  JSONRPC_VERSION,
+  LATEST_PROTOCOL_VERSION,
+  MCP_APP_RESOURCES,
+  MCP_TOOLS,
+  McpProtocolError,
+  MemoryTaskStore,
+  createFixtureProvider,
+  fixtureConformResult,
+  fixturePrimitives,
+  getResource,
+  getTool,
+  handleMcpHttpRequest,
+  handleMcpJsonRpc,
+  listResources,
+  listToolDescriptors
 };
 //# sourceMappingURL=index.js.map