@meissa_a/meissa 0.1.0

package/dist/server/index.d.ts

@@ -0,0 +1,4 @@
+export { MeissaServer } from "./server.js";
+export { toMarkdown } from "./markdown.js";
+export { validate } from "./validator.js";
+export type { ComponentType, LayoutType, AllComponentTypes, SchemaComponent, Schema, Data, RenderOptions, MeissaContentBlock, MeissaPatchContentBlock, PatchOperation, RenderResponse, PatchResponse, ValidationResult, } from "./types.js";

package/dist/server/markdown.d.ts

@@ -0,0 +1,9 @@
+import type { Schema, Data } from "./types.js";
+/**
+ * Convert a Meissa schema + data into a markdown string.
+ */
+export declare function schemaToMarkdown(schema: Schema, data: Data): string;
+/**
+ * Public toMarkdown function.
+ */
+export declare function toMarkdown(schema: Schema, data?: Data): string;

package/dist/server/server.d.ts

@@ -0,0 +1,39 @@
+import type { Schema, Data, RenderOptions, RenderResponse, PatchResponse, PatchOperation, ValidationResult } from "./types.js";
+/**
+ * MeissaServer provides methods for MCP server developers to return
+ * Meissa UI content from their tools.
+ */
+export declare class MeissaServer {
+    /**
+     * Render a Meissa UI schema with data into an MCP content response.
+     *
+     * @param schema - Array of Meissa UI components
+     * @param data - Data object for binding resolution
+     * @param opts - Optional render options (fallback override, theme)
+     * @returns MCP content response with type "meissa"
+     */
+    render(schema: Schema, data?: Data, opts?: RenderOptions): RenderResponse;
+    /**
+     * Create a patch response targeting a previous tool call.
+     *
+     * @param target - The tool_call_id to patch
+     * @param patches - Array of JSON Patch (RFC 6902) operations
+     * @returns MCP content response with type "meissa/patch"
+     */
+    patch(target: string, patches: PatchOperation[]): PatchResponse;
+    /**
+     * Convert a Meissa schema + data to a markdown string.
+     *
+     * @param schema - Array of Meissa UI components
+     * @param data - Data object for binding resolution
+     * @returns Markdown string representation
+     */
+    toMarkdown(schema: Schema, data?: Data): string;
+    /**
+     * Validate a Meissa schema.
+     *
+     * @param schema - The schema to validate
+     * @returns Validation result with valid flag and any errors
+     */
+    validate(schema: unknown): ValidationResult;
+}

package/dist/server/types.d.ts

@@ -0,0 +1,56 @@
+/** Allowed UI component types */
+export type ComponentType = "heading" | "text" | "btn" | "table" | "chart" | "stat" | "list" | "img" | "divider" | "badge" | "code" | "alert" | "progress" | "toggle" | "input" | "select" | "tabs" | "accordion";
+/** Allowed layout component types */
+export type LayoutType = "row" | "col" | "grid" | "split";
+/** All allowed component/layout types */
+export type AllComponentTypes = ComponentType | LayoutType;
+/** A single schema component */
+export interface SchemaComponent {
+    type: AllComponentTypes;
+    [key: string]: unknown;
+    children?: SchemaComponent[];
+}
+/** Schema is an array of components */
+export type Schema = SchemaComponent[];
+/** Data object used to resolve bindings */
+export type Data = Record<string, unknown>;
+/** Options for render() */
+export interface RenderOptions {
+    /** Override auto-generated markdown fallback */
+    fallback?: string;
+    /** Theme object to include in the content block */
+    theme?: Record<string, unknown>;
+}
+/** A Meissa content block */
+export interface MeissaContentBlock {
+    type: "meissa";
+    schema: Schema;
+    data: Data;
+    fallback: string;
+    theme?: Record<string, unknown>;
+}
+/** A Meissa patch content block */
+export interface MeissaPatchContentBlock {
+    type: "meissa/patch";
+    target: string;
+    patches: PatchOperation[];
+}
+/** JSON Patch (RFC 6902) operation */
+export interface PatchOperation {
+    op: "replace" | "add" | "remove";
+    path: string;
+    value?: unknown;
+}
+/** MCP content response for render() */
+export interface RenderResponse {
+    content: [MeissaContentBlock];
+}
+/** MCP content response for patch() */
+export interface PatchResponse {
+    content: [MeissaPatchContentBlock];
+}
+/** Validation result */
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+}

package/dist/server/validator.d.ts

@@ -0,0 +1,5 @@
+import type { ValidationResult } from "./types.js";
+/**
+ * Validate a Meissa schema.
+ */
+export declare function validate(schema: unknown): ValidationResult;

package/dist/server.cjs

@@ -0,0 +1,345 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/server/index.ts
+var exports_server = {};
+__export(exports_server, {
+  validate: () => validate,
+  toMarkdown: () => toMarkdown,
+  MeissaServer: () => MeissaServer
+});
+module.exports = __toCommonJS(exports_server);
+
+// src/server/markdown.ts
+function resolvePath(data, path) {
+  const parts = path.split(".");
+  let current = data;
+  for (const part of parts) {
+    if (current === null || current === undefined)
+      return;
+    if (typeof current === "object") {
+      current = current[part];
+    } else {
+      return;
+    }
+  }
+  return current;
+}
+function resolveBindings(text, data) {
+  return text.replace(/\{\{([^}]+)\}\}/g, (_, path) => {
+    const value = resolvePath(data, path.trim());
+    if (value === undefined || value === null)
+      return "";
+    return String(value);
+  });
+}
+function componentToMarkdown(component, data) {
+  const type = component.type;
+  switch (type) {
+    case "heading": {
+      const level = typeof component.level === "number" ? component.level : 2;
+      const text = resolveBindings(String(component.text ?? ""), data);
+      return `${"#".repeat(level)} ${text}`;
+    }
+    case "text": {
+      const content = resolveBindings(String(component.content ?? component.text ?? ""), data);
+      return content;
+    }
+    case "table": {
+      const columns = component.columns;
+      const rows = component.rows;
+      const dataKey = component.data;
+      const resolvedRows = rows ?? (dataKey ? resolvePath(data, dataKey) : []) ?? [];
+      if (!columns || !Array.isArray(columns) || columns.length === 0) {
+        return "";
+      }
+      const headers = columns.map((col) => col.header ?? col.key ?? "");
+      const keys = columns.map((col) => col.key ?? col.header ?? "");
+      const headerRow = `| ${headers.join(" | ")} |`;
+      const separator = `| ${headers.map(() => "---").join(" | ")} |`;
+      const dataRows = Array.isArray(resolvedRows) ? resolvedRows.map((row) => {
+        const cells = keys.map((key) => {
+          const val = row[key];
+          return val !== undefined && val !== null ? String(val) : "";
+        });
+        return `| ${cells.join(" | ")} |`;
+      }) : [];
+      return [headerRow, separator, ...dataRows].join(`
+`);
+    }
+    case "stat": {
+      const label = resolveBindings(String(component.label ?? ""), data);
+      const value = resolveBindings(String(component.value ?? ""), data);
+      const trend = component.trend ? ` (${resolveBindings(String(component.trend), data)})` : "";
+      return `**${label}**: ${value}${trend}`;
+    }
+    case "list": {
+      const items = component.items;
+      const dataKey = component.data;
+      const ordered = component.ordered === true;
+      const resolvedItems = items ?? (dataKey ? resolvePath(data, dataKey) : []) ?? [];
+      if (!Array.isArray(resolvedItems))
+        return "";
+      return resolvedItems.map((item, i) => {
+        const text = typeof item === "string" ? item : item?.text ?? "";
+        const resolved = resolveBindings(text, data);
+        return ordered ? `${i + 1}. ${resolved}` : `- ${resolved}`;
+      }).join(`
+`);
+    }
+    case "btn": {
+      const label = resolveBindings(String(component.label ?? component.text ?? ""), data);
+      const action = String(component.action ?? component.tool ?? "");
+      return `[${label}](action:${action})`;
+    }
+    case "chart": {
+      const chartType = String(component.chartType ?? component.variant ?? "unknown");
+      const title = component.title ? resolveBindings(String(component.title), data) : "";
+      const titlePart = title ? ` — ${title}` : "";
+      return `(Chart: ${chartType}${titlePart})`;
+    }
+    case "code": {
+      const language = String(component.language ?? component.lang ?? "");
+      const content = resolveBindings(String(component.content ?? component.code ?? ""), data);
+      return `\`\`\`${language}
+${content}
+\`\`\``;
+    }
+    case "img": {
+      const alt = resolveBindings(String(component.alt ?? ""), data);
+      const src = resolveBindings(String(component.src ?? component.url ?? ""), data);
+      return `![${alt}](${src})`;
+    }
+    case "divider": {
+      return "---";
+    }
+    case "alert": {
+      const variant = String(component.variant ?? "info");
+      const content = resolveBindings(String(component.content ?? component.text ?? ""), data);
+      const emojiMap = {
+        info: "ℹ️",
+        warning: "⚠️",
+        error: "❌",
+        success: "✅"
+      };
+      const emoji = emojiMap[variant] ?? emojiMap["info"];
+      return `> ${emoji} ${content}`;
+    }
+    case "badge": {
+      const text = resolveBindings(String(component.text ?? component.label ?? ""), data);
+      return `\`${text}\``;
+    }
+    case "progress": {
+      const value = component.value ?? 0;
+      const label = component.label ? resolveBindings(String(component.label), data) : "";
+      return label ? `${label}: ${value}%` : `${value}%`;
+    }
+    case "toggle":
+    case "input":
+    case "select": {
+      const label = resolveBindings(String(component.label ?? ""), data);
+      return label ? `[${label}]` : "";
+    }
+    case "tabs": {
+      const tabItems = component.tabs;
+      if (!Array.isArray(tabItems))
+        return "";
+      return tabItems.map((tab) => {
+        const label = resolveBindings(String(tab.label ?? ""), data);
+        const content = tab.content ? schemaToMarkdown(tab.content, data) : "";
+        return `### ${label}
+
+${content}`;
+      }).join(`
+
+`);
+    }
+    case "accordion": {
+      const items = component.items;
+      if (!Array.isArray(items))
+        return "";
+      return items.map((item) => {
+        const title = resolveBindings(String(item.title ?? ""), data);
+        const content = item.content ? schemaToMarkdown(item.content, data) : "";
+        return `**${title}**
+
+${content}`;
+      }).join(`
+
+`);
+    }
+    case "row":
+    case "col":
+    case "grid":
+    case "split": {
+      const children = component.children;
+      if (!Array.isArray(children))
+        return "";
+      return schemaToMarkdown(children, data);
+    }
+    default:
+      return "";
+  }
+}
+function schemaToMarkdown(schema, data) {
+  return schema.map((component) => componentToMarkdown(component, data)).filter((line) => line !== "").join(`
+
+`);
+}
+function toMarkdown(schema, data = {}) {
+  return schemaToMarkdown(schema, data);
+}
+
+// src/server/validator.ts
+var ALLOWED_COMPONENT_TYPES = new Set([
+  "heading",
+  "text",
+  "btn",
+  "table",
+  "chart",
+  "stat",
+  "list",
+  "img",
+  "divider",
+  "badge",
+  "code",
+  "alert",
+  "progress",
+  "toggle",
+  "input",
+  "select",
+  "tabs",
+  "accordion",
+  "row",
+  "col",
+  "grid",
+  "split"
+]);
+var MAX_NESTING_DEPTH = 10;
+var MAX_COMPONENT_COUNT = 500;
+var MAX_SCHEMA_SIZE_BYTES = 64 * 1024;
+function countComponents(schema, depth, errors) {
+  if (depth > MAX_NESTING_DEPTH) {
+    errors.push(`Nesting depth exceeds maximum of ${MAX_NESTING_DEPTH}`);
+    return 0;
+  }
+  let count = 0;
+  for (const component of schema) {
+    count++;
+    if (!component.type || typeof component.type !== "string") {
+      errors.push(`Component missing valid "type" field`);
+      continue;
+    }
+    if (!ALLOWED_COMPONENT_TYPES.has(component.type)) {
+      errors.push(`Unknown component type: "${component.type}"`);
+    }
+    if (component.children && Array.isArray(component.children)) {
+      count += countComponents(component.children, depth + 1, errors);
+    }
+    if (component.type === "tabs" && Array.isArray(component.tabs)) {
+      for (const tab of component.tabs) {
+        if (tab.content && Array.isArray(tab.content)) {
+          count += countComponents(tab.content, depth + 1, errors);
+        }
+      }
+    }
+    if (component.type === "accordion" && Array.isArray(component.items)) {
+      for (const item of component.items) {
+        if (item.content && Array.isArray(item.content)) {
+          count += countComponents(item.content, depth + 1, errors);
+        }
+      }
+    }
+  }
+  return count;
+}
+function validate(schema) {
+  const errors = [];
+  if (!Array.isArray(schema)) {
+    errors.push("Schema must be an array");
+    return { valid: false, errors };
+  }
+  const serialized = JSON.stringify(schema);
+  if (serialized.length > MAX_SCHEMA_SIZE_BYTES) {
+    errors.push(`Schema size (${serialized.length} bytes) exceeds maximum of ${MAX_SCHEMA_SIZE_BYTES} bytes (64KB)`);
+  }
+  const totalCount = countComponents(schema, 1, errors);
+  if (totalCount > MAX_COMPONENT_COUNT) {
+    errors.push(`Total component count (${totalCount}) exceeds maximum of ${MAX_COMPONENT_COUNT}`);
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+// src/server/server.ts
+class MeissaServer {
+  render(schema, data = {}, opts) {
+    const fallback = opts?.fallback ?? toMarkdown(schema, data);
+    const contentBlock = {
+      type: "meissa",
+      schema,
+      data,
+      fallback
+    };
+    if (opts?.theme) {
+      contentBlock.theme = opts.theme;
+    }
+    return {
+      content: [contentBlock]
+    };
+  }
+  patch(target, patches) {
+    return {
+      content: [
+        {
+          type: "meissa/patch",
+          target,
+          patches
+        }
+      ]
+    };
+  }
+  toMarkdown(schema, data = {}) {
+    return toMarkdown(schema, data);
+  }
+  validate(schema) {
+    return validate(schema);
+  }
+}