@dryui/mcp 0.1.0

package/dist/spec-formatters.d.ts

@@ -0,0 +1,19 @@
+import type { ComponentDef, DataAttributeDef, ForwardedPropsDef, PartDef, PropDef } from './spec-types.js';
+export declare const DIR_OVERRIDES: Readonly<Record<string, string>>;
+export declare function componentDir(name: string): string;
+export declare function pad(str: string, width: number): string;
+export declare function indent(text: string, spaces: number): string;
+export declare function getSubpathImport(name: string, def: ComponentDef): string | null;
+export declare function findComponent(query: string, components: Record<string, ComponentDef>): {
+    name: string;
+    def: ComponentDef;
+} | null;
+export declare function formatProp(propName: string, propDef: PropDef, width: number): string;
+export declare function formatCssVars(cssVars: Record<string, string>): string[];
+export declare function formatDataAttributes(dataAttributes: DataAttributeDef[]): string[];
+export declare function formatA11yNotes(notes?: string[]): string[];
+export declare function formatForwardedProps(forwardedProps?: ForwardedPropsDef | null): string[];
+export declare function formatPart(name: string, partName: string, partDef: PartDef): string[];
+export declare function formatStructure(name: string, def: ComponentDef): string[];
+export declare function formatCompound(name: string, def: ComponentDef): string;
+export declare function formatSimple(name: string, def: ComponentDef): string;

package/dist/spec-formatters.js

@@ -0,0 +1,256 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+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/spec-formatters.ts
+var DIR_OVERRIDES = {
+  QRCode: "qr-code"
+};
+function componentDir(name) {
+  return DIR_OVERRIDES[name] ?? name.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function pad(str, width) {
+  return str.length >= width ? str : str + " ".repeat(width - str.length);
+}
+function indent(text, spaces) {
+  const prefix = " ".repeat(spaces);
+  return text.split(`
+`).map((line) => prefix + line).join(`
+`);
+}
+function getSubpathImport(name, def) {
+  if (def.import !== "@dryui/ui")
+    return null;
+  return `import { ${name} } from '${def.import}/${componentDir(name)}'`;
+}
+function findComponent(query, components) {
+  const exact = components[query];
+  if (exact)
+    return { name: query, def: exact };
+  const lower = query.toLowerCase();
+  for (const [name, def] of Object.entries(components)) {
+    if (name.toLowerCase() === lower)
+      return { name, def };
+  }
+  return null;
+}
+function formatProp(propName, propDef, width) {
+  const flags = [propDef.type];
+  if (propDef.description)
+    flags.push(`description: ${propDef.description}`);
+  if (propDef.acceptedValues?.length)
+    flags.push(`accepted: ${propDef.acceptedValues.join(", ")}`);
+  if (propDef.default !== undefined)
+    flags.push(`default: ${propDef.default}`);
+  if (propDef.required)
+    flags.push("required");
+  if (propDef.bindable)
+    flags.push("bindable");
+  if (propDef.note)
+    flags.push(`note: ${propDef.note}`);
+  return `  ${pad(propName, width + 2)}${flags.join(" | ")}`;
+}
+function formatCssVars(cssVars) {
+  const entries = Object.entries(cssVars);
+  if (entries.length === 0)
+    return ["  none"];
+  const maxLen = Math.max(...entries.map(([name]) => name.length));
+  return entries.map(([name, description]) => `  ${pad(name, maxLen + 2)}${description}`);
+}
+function formatDataAttributes(dataAttributes) {
+  if (dataAttributes.length === 0)
+    return ["  none"];
+  const width = Math.max(...dataAttributes.map((attr) => attr.name.length));
+  return dataAttributes.map((attr) => {
+    const meta = [
+      attr.description,
+      attr.values?.length ? `values: ${attr.values.join(", ")}` : null
+    ].filter(Boolean).join(" | ");
+    return meta ? `  ${pad(attr.name, width + 2)}${meta}` : `  ${attr.name}`;
+  });
+}
+function formatA11yNotes(notes) {
+  if (!notes?.length)
+    return ["  none"];
+  return notes.map((note) => `  - ${note}`);
+}
+function formatForwardedProps(forwardedProps) {
+  if (!forwardedProps)
+    return ["  none"];
+  const lines = [`  ${forwardedProps.note}`];
+  if (forwardedProps.examples?.length) {
+    lines.push(`  examples: ${forwardedProps.examples.join(", ")}`);
+  }
+  if (forwardedProps.omitted?.length) {
+    lines.push(`  omits: ${forwardedProps.omitted.join(", ")}`);
+  }
+  return lines;
+}
+function formatPart(name, partName, partDef) {
+  const lines = [`  ${name}.${partName}`];
+  const props = Object.entries(partDef.props ?? {});
+  if (props.length === 0) {
+    lines.push("    Props: none");
+  } else {
+    const maxLen = Math.max(...props.map(([propName]) => propName.length));
+    for (const [propName, propDef] of props) {
+      lines.push(`  ${formatProp(propName, propDef, maxLen).trimStart()}`);
+    }
+  }
+  if (partDef.forwardedProps) {
+    lines.push("    Native props:");
+    for (const detail of formatForwardedProps(partDef.forwardedProps)) {
+      lines.push(`  ${detail.trimStart()}`);
+    }
+  }
+  return lines;
+}
+function formatStructure(name, def) {
+  if (!def.structure?.tree.length) {
+    return ["  none"];
+  }
+  const lines = def.structure.tree.map((node) => `  ${node}`);
+  if (def.structure.note) {
+    lines.push(`  note: ${def.structure.note}`);
+  }
+  return lines;
+}
+function formatCompound(name, def) {
+  const lines = [];
+  lines.push(`${name} — ${def.description}`);
+  lines.push(`Category: ${def.category} | Tags: ${def.tags.join(", ")}`);
+  lines.push(`Root import: import { ${name} } from '${def.import}'`);
+  const subpath = getSubpathImport(name, def);
+  if (subpath)
+    lines.push(`Subpath import: ${subpath}`);
+  const hasRoot = Boolean(def.parts?.Root);
+  lines.push(hasRoot ? `Compound: yes (use ${name}.Root, not ${name})` : `Namespace: yes (parts are used directly; no ${name}.Root wrapper)`);
+  if (hasRoot) {
+    lines.push("");
+    lines.push("Required structure:");
+    lines.push(...formatStructure(name, def));
+  } else if (def.structure?.note) {
+    lines.push("");
+    lines.push(`Note: ${def.structure.note}`);
+  }
+  if (def.parts) {
+    lines.push("");
+    lines.push("Parts:");
+    for (const [partName, partDef] of Object.entries(def.parts)) {
+      lines.push(...formatPart(name, partName, partDef));
+    }
+  }
+  lines.push("");
+  lines.push("CSS Variables:");
+  lines.push(...formatCssVars(def.cssVars));
+  lines.push("");
+  lines.push("Data Attributes:");
+  lines.push(...formatDataAttributes(def.dataAttributes));
+  lines.push("");
+  lines.push("Accessibility:");
+  lines.push(...formatA11yNotes(def.a11y));
+  if (def.example) {
+    lines.push("");
+    lines.push("Example:");
+    lines.push(indent(def.example, 2));
+  }
+  return lines.join(`
+`);
+}
+function formatSimple(name, def) {
+  const lines = [];
+  lines.push(`${name} — ${def.description}`);
+  lines.push(`Category: ${def.category} | Tags: ${def.tags.join(", ")}`);
+  lines.push(`Root import: import { ${name} } from '${def.import}'`);
+  const subpath = getSubpathImport(name, def);
+  if (subpath)
+    lines.push(`Subpath import: ${subpath}`);
+  lines.push("");
+  lines.push("Props:");
+  if (def.props && Object.keys(def.props).length > 0) {
+    const propEntries = Object.entries(def.props);
+    const maxLen = Math.max(...propEntries.map(([p]) => p.length));
+    for (const [propName, propDef] of propEntries) {
+      lines.push(formatProp(propName, propDef, maxLen));
+    }
+  } else {
+    lines.push("  none");
+  }
+  lines.push("");
+  lines.push("Native props:");
+  lines.push(...formatForwardedProps(def.forwardedProps));
+  lines.push("");
+  lines.push("CSS Variables:");
+  lines.push(...formatCssVars(def.cssVars));
+  lines.push("");
+  lines.push("Data Attributes:");
+  lines.push(...formatDataAttributes(def.dataAttributes));
+  lines.push("");
+  lines.push("Accessibility:");
+  lines.push(...formatA11yNotes(def.a11y));
+  if (def.example) {
+    lines.push("");
+    lines.push("Example:");
+    lines.push(indent(def.example, 2));
+  }
+  return lines.join(`
+`);
+}
+export {
+  pad,
+  indent,
+  getSubpathImport,
+  formatStructure,
+  formatSimple,
+  formatProp,
+  formatPart,
+  formatForwardedProps,
+  formatDataAttributes,
+  formatCssVars,
+  formatCompound,
+  formatA11yNotes,
+  findComponent,
+  componentDir,
+  DIR_OVERRIDES
+};

package/dist/spec-types.d.ts

@@ -0,0 +1,83 @@
+export interface PropDef {
+    readonly type: string;
+    readonly required?: boolean;
+    readonly bindable?: boolean;
+    readonly default?: string;
+    readonly acceptedValues?: string[];
+    readonly description?: string;
+    readonly note?: string;
+}
+export interface DataAttributeDef {
+    readonly name: string;
+    readonly description?: string;
+    readonly values?: string[];
+}
+export interface ForwardedPropsDef {
+    readonly baseType: string;
+    readonly via: string;
+    readonly element?: string;
+    readonly examples?: string[];
+    readonly omitted?: string[];
+    readonly note: string;
+}
+export interface StructureDef {
+    readonly tree: string[];
+    readonly note?: string;
+}
+export interface PartDef {
+    readonly props: Record<string, PropDef>;
+    readonly forwardedProps?: ForwardedPropsDef | null;
+}
+export interface ComponentDef {
+    readonly import: string;
+    readonly description: string;
+    readonly category: string;
+    readonly tags: string[];
+    readonly compound: boolean;
+    readonly props?: Record<string, PropDef>;
+    readonly parts?: Record<string, PartDef>;
+    readonly forwardedProps?: ForwardedPropsDef | null;
+    readonly structure?: StructureDef | null;
+    readonly a11y?: string[];
+    readonly cssVars: Record<string, string>;
+    readonly dataAttributes: DataAttributeDef[];
+    readonly example: string;
+}
+export interface CompositionAlternativeDef {
+    readonly rank: number;
+    readonly component: string;
+    readonly useWhen: string;
+    readonly snippet: string;
+}
+export interface CompositionAntiPatternDef {
+    readonly pattern: string;
+    readonly reason: string;
+    readonly fix: string;
+}
+export interface CompositionComponentDef {
+    readonly component: string;
+    readonly useWhen: string;
+    readonly alternatives: readonly CompositionAlternativeDef[];
+    readonly antiPatterns: readonly CompositionAntiPatternDef[];
+    readonly combinesWith: readonly string[];
+}
+export interface CompositionRecipeDef {
+    readonly name: string;
+    readonly description: string;
+    readonly tags: readonly string[];
+    readonly components: readonly string[];
+    readonly snippet: string;
+}
+export interface Spec {
+    readonly version: string;
+    readonly package: string;
+    readonly themeImports: {
+        readonly default: string;
+        readonly dark: string;
+    };
+    readonly components: Record<string, ComponentDef>;
+    readonly composition?: {
+        readonly components: Record<string, CompositionComponentDef>;
+        readonly recipes: Record<string, CompositionRecipeDef>;
+    };
+}