@dryui/mcp 0.1.4 → 0.2.1

package/dist/architecture.d.ts

@@ -83,7 +83,6 @@ export interface DolphinSummary {
 }
 export interface DolphinGraph {
     schema: 'DolphinGraph';
-    generatedAt: string;
     packageVersion: string;
     summary: DolphinSummary;
     nodes: DolphinNode[];

package/dist/architecture.js

@@ -5871,8 +5871,6 @@ function buildArchitectureReport(graph) {
   return [
     "# DryUI Architecture Audit",
     "",
-    `Generated from \`DolphinGraph\` on ${graph.generatedAt}.`,
-    "",
     "## Metrics",
     "",
     "| Metric | Count |",
@@ -6228,7 +6226,6 @@ async function buildDolphinGraph() {
   };
   return {
     schema: "DolphinGraph",
-    generatedAt: new Date().toISOString(),
     packageVersion: spec.version,
     summary,
     nodes: sortedNodes,

package/dist/architecture.json

@@ -1,7 +1,6 @@
 {
   "schema": "DolphinGraph",
-  "generatedAt": "2026-04-07T22:06:54.170Z",
-  "packageVersion": "0.1.5",
+  "packageVersion": "0.1.8",
   "summary": {
     "componentNodes": 292,
     "partNodes": 662,
@@ -15,12 +14,12 @@
     "subpathOnlyComponents": 1,
     "compoundComponents": 135,
     "wrapEdges": 130,
-    "composeEdges": 10,
+    "composeEdges": 11,
     "docsEdges": 0,
     "relatedEdges": 303,
     "mismatches": 23,
     "primitivePartComponents": 0,
-    "thinWrappers": 65
+    "thinWrappers": 64
   },
   "nodes": [
     {
@@ -15677,7 +15676,7 @@
       "parts": [],
       "sourceFileCount": 2,
       "primitivePartUsageCount": 0,
-      "componentImportCount": 0
+      "componentImportCount": 1
     },
     {
       "id": "ui:Timeline",
@@ -16551,10 +16550,10 @@
       "to": "primitives:TimeInput"
     },
     {
-      "id": "composes:ui:DateTimeInput:ui:DateField:",
+      "id": "composes:ui:DateTimeInput:ui:DatePicker:",
       "type": "composes",
       "from": "ui:DateTimeInput",
-      "to": "ui:DateField"
+      "to": "ui:DatePicker"
     },
     {
       "id": "composes:ui:DateTimeInput:ui:TimeInput:",
@@ -16592,6 +16591,12 @@
       "from": "ui:Tag",
       "to": "ui:Badge"
     },
+    {
+      "id": "composes:ui:TimeInput:ui:Select:",
+      "type": "composes",
+      "from": "ui:TimeInput",
+      "to": "ui:Select"
+    },
     {
       "id": "composes:ui:Transfer:ui:Checkbox:",
       "type": "composes",
@@ -24360,7 +24365,6 @@
       "Spotlight",
       "Svg",
       "Textarea",
-      "TimeInput",
       "Toggle",
       "Tour",
       "VideoEmbed",

package/dist/composition-search.d.ts

@@ -0,0 +1,15 @@
+import type { CompositionComponentDef, CompositionRecipeDef, Spec } from './spec-types.js';
+export interface CompositionSearchResult {
+    readonly componentMatches: readonly CompositionComponentDef[];
+    readonly recipeMatches: readonly CompositionRecipeDef[];
+}
+/**
+ * Search composition data for components and recipes matching a query.
+ * Uses exact substring matching first, then falls back to token-based scoring.
+ */
+export declare function searchComposition(composition: NonNullable<Spec['composition']>, query: string): CompositionSearchResult;
+/**
+ * Format composition search results as human-readable text.
+ * Used by MCP prompts and CLI text mode.
+ */
+export declare function formatCompositionResult(results: CompositionSearchResult): string;

package/dist/composition-search.js

@@ -0,0 +1,202 @@
+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/composition-search.ts
+var STOP_WORDS = new Set([
+  "a",
+  "an",
+  "the",
+  "and",
+  "or",
+  "but",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "by",
+  "from",
+  "is",
+  "it",
+  "that",
+  "this",
+  "as",
+  "be",
+  "are",
+  "was",
+  "were",
+  "been",
+  "has",
+  "have",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "can",
+  "i",
+  "me",
+  "my",
+  "we",
+  "our",
+  "you",
+  "your",
+  "need",
+  "want",
+  "like",
+  "create",
+  "make",
+  "build",
+  "add",
+  "using",
+  "use",
+  "show",
+  "display"
+]);
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, " ").split(/\s+/).filter((w) => w.length > 1 && !STOP_WORDS.has(w));
+}
+function scoreText(tokens, text) {
+  const lower = text.toLowerCase();
+  return tokens.reduce((score, t) => score + (lower.includes(t) ? 1 : 0), 0);
+}
+function searchComposition(composition, query) {
+  const q = query.toLowerCase();
+  const tokens = tokenize(query);
+  const exactComponentMatches = [];
+  const exactRecipeMatches = [];
+  for (const comp of Object.values(composition.components)) {
+    if (comp.component.toLowerCase().includes(q) || comp.useWhen.toLowerCase().includes(q) || comp.alternatives.some((a) => a.component.toLowerCase().includes(q) || a.useWhen.toLowerCase().includes(q)) || comp.antiPatterns.some((ap) => ap.pattern.toLowerCase().includes(q))) {
+      exactComponentMatches.push(comp);
+    }
+  }
+  for (const recipe of Object.values(composition.recipes)) {
+    if (recipe.name.toLowerCase().includes(q) || recipe.description.toLowerCase().includes(q) || recipe.tags.some((t) => t.toLowerCase().includes(q)) || recipe.components.some((c) => c.toLowerCase().includes(q))) {
+      exactRecipeMatches.push(recipe);
+    }
+  }
+  if (exactComponentMatches.length || exactRecipeMatches.length) {
+    return { componentMatches: exactComponentMatches, recipeMatches: exactRecipeMatches };
+  }
+  if (!tokens.length) {
+    return { componentMatches: [], recipeMatches: [] };
+  }
+  const scoredComponents = [];
+  for (const comp of Object.values(composition.components)) {
+    const corpus = [
+      comp.component,
+      comp.useWhen,
+      ...comp.alternatives.flatMap((a) => [a.component, a.useWhen]),
+      ...comp.antiPatterns.map((ap) => ap.pattern),
+      ...comp.combinesWith
+    ].join(" ");
+    const score = scoreText(tokens, corpus);
+    if (score > 0)
+      scoredComponents.push({ comp, score });
+  }
+  const scoredRecipes = [];
+  for (const recipe of Object.values(composition.recipes)) {
+    const corpus = [recipe.name, recipe.description, ...recipe.tags, ...recipe.components].join(" ");
+    const score = scoreText(tokens, corpus);
+    if (score > 0)
+      scoredRecipes.push({ recipe, score });
+  }
+  scoredComponents.sort((a, b) => b.score - a.score);
+  scoredRecipes.sort((a, b) => b.score - a.score);
+  const minScore = Math.max(1, Math.floor(tokens.length * 0.3));
+  return {
+    componentMatches: scoredComponents.filter((s) => s.score >= minScore).slice(0, 10).map((s) => s.comp),
+    recipeMatches: scoredRecipes.filter((s) => s.score >= minScore).slice(0, 5).map((s) => s.recipe)
+  };
+}
+function formatCompositionResult(results) {
+  const lines = [];
+  for (const comp of results.componentMatches) {
+    lines.push(`── ${comp.component} ──────────────────────────────`);
+    lines.push(`[DEV GUIDANCE — do not render as page content]`);
+    lines.push(`Use: ${comp.component} — ${comp.useWhen}`);
+    lines.push("");
+    for (const alt of comp.alternatives) {
+      lines.push(`  ${alt.rank}. ${alt.component} (${alt.useWhen})`);
+      lines.push(alt.snippet.split(`
+`).map((l) => `     ${l}`).join(`
+`));
+      lines.push("");
+    }
+    for (const ap of comp.antiPatterns) {
+      lines.push(`⚠ Anti-pattern: ${ap.pattern}`);
+      lines.push(`  Why: ${ap.reason}`);
+      lines.push(`  Use ${ap.fix} instead`);
+      lines.push("");
+    }
+    if (comp.combinesWith.length) {
+      lines.push(`Combines with: ${comp.combinesWith.join(", ")}`);
+    }
+    lines.push("");
+  }
+  for (const recipe of results.recipeMatches) {
+    lines.push(`── Recipe: ${recipe.name} ──────────────────────────────`);
+    lines.push(`[DEV GUIDANCE — do not render as page content]`);
+    lines.push(recipe.description);
+    lines.push(`Components: ${recipe.components.join(", ")}`);
+    lines.push("");
+    lines.push(`[CODE — use this in your Svelte file]`);
+    lines.push(recipe.snippet);
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+export {
+  searchComposition,
+  formatCompositionResult
+};

package/dist/contract.v1.json

@@ -3,7 +3,7 @@
   "version": 1,
   "package": {
     "name": "@dryui/ui",
-    "version": "0.1.5"
+    "version": "0.1.8"
   },
   "counts": {
     "components": 144,
@@ -10962,6 +10962,26 @@
           "type": "number",
           "required": false,
           "description": "Step interval used when incrementing numeric values."
+        },
+        "size": {
+          "type": "'sm' | 'md' | 'lg'",
+          "required": false,
+          "acceptedValues": [
+            "sm",
+            "md",
+            "lg"
+          ],
+          "description": "Size preset affecting density, spacing, or typography.",
+          "default": "'md'"
+        },
+        "name": {
+          "type": "string",
+          "required": false,
+          "description": "Field name used during native form submission."
+        },
+        "class": {
+          "type": "string",
+          "required": false
         }
       },
       "forwardedProps": {
@@ -10975,25 +10995,23 @@
         ],
         "note": "Forwards <input> attributes via rest props."
       },
-      "cssVars": {
-        "--dry-time-input-bg": "Input Bg",
-        "--dry-time-input-border": "Input Border",
-        "--dry-time-input-color": "Input Color",
-        "--dry-time-input-font-size": "Input Font Size",
-        "--dry-time-input-padding-x": "Input Padding X",
-        "--dry-time-input-padding-y": "Input Padding Y",
-        "--dry-time-input-radius": "Input Radius"
-      },
+      "cssVars": {},
       "dataAttributes": [
         {
           "name": "data-disabled",
           "description": "Present when the component or part is disabled."
         },
         {
-          "name": "data-time-input"
+          "name": "data-placeholder"
+        },
+        {
+          "name": "data-time-display"
         },
         {
           "name": "data-time-input-wrapper"
+        },
+        {
+          "name": "data-time-separator"
         }
       ],
       "example": "<TimeInput>Content</TimeInput>"