@monoharada/wcf-mcp 0.6.0 → 0.7.0

package/core.mjs

@@ -1132,6 +1132,20 @@ export function serializeApi(decl, modulePath, prefix) {
   };
 }
 
+/**
+ * Generic fallback values for common attributes when CEM default is missing.
+ * Attribute-name-based (not component-specific). `type` is excluded to avoid
+ * conflicts between button (type="button") and input (type="text").
+ * `variant` is also excluded — its valid values differ per component,
+ * so the first enum value is used instead (see generateSnippet).
+ */
+const SNIPPET_FALLBACK_VALUES = {
+  label: 'ラベル',
+  name: 'field1',
+  value: 'サンプル値',
+  'support-text': '説明テキスト',
+};
+
 export function generateSnippet(api, prefix) {
   // Use custom snippet if injected by CEM plugin (e.g. data-* driven components)
   const customSnippet = api.custom?.usageSnippet;
@@ -1174,7 +1188,28 @@ export function generateSnippet(api, prefix) {
     if (isBoolean) {
       lines.push(`  ${name}`);
     } else {
-      const defaultVal = typeof a.default === 'string' ? a.default.replace(/^['"]|['"]$/g, '') : '';
+      let defaultVal;
+      if (typeof a.default === 'string') {
+        defaultVal = a.default.replace(/^['"]|['"]$/g, '');
+      } else if (SNIPPET_FALLBACK_VALUES[name] !== undefined) {
+        defaultVal = SNIPPET_FALLBACK_VALUES[name];
+      } else {
+        // For enum types, use the first enum value as fallback
+        const enumMatch = t.match(/^'([^']+)'/);
+        if (enumMatch) {
+          defaultVal = enumMatch[1];
+        } else {
+          // Fallback: extract first value from description pattern like "(solid | outlined | text)"
+          const desc = String(a.description ?? '');
+          const descEnum = desc.match(/\(([^)]+)\)/);
+          if (descEnum) {
+            const first = descEnum[1].split(/\s*[|｜]\s*/)[0]?.trim();
+            defaultVal = first || '';
+          } else {
+            defaultVal = '';
+          }
+        }
+      }
       lines.push(`  ${name}="${defaultVal}"`);
     }
     if (lines.length >= 4) break;
@@ -1264,7 +1299,36 @@ export function resolveComponentClosure({ installRegistry }, componentIds) {
   return [...out];
 }
 
-export function buildComponentSummaries(indexes, { category, query, limit, offset, prefix } = {}) {
+/**
+ * Build a frequency map: componentId → count of patterns that require it.
+ * Counts from pattern-registry.json `requires` arrays only.
+ */
+export function buildPatternFrequencyMap(patterns) {
+  const freq = new Map();
+  if (!patterns || typeof patterns !== 'object') return freq;
+  for (const pat of Object.values(patterns)) {
+    const requires = Array.isArray(pat?.requires) ? pat.requires : [];
+    for (const id of requires) {
+      const key = String(id ?? '').trim();
+      if (key) freq.set(key, (freq.get(key) ?? 0) + 1);
+    }
+  }
+  return freq;
+}
+
+/**
+ * Convert a tag from the current prefix to canonical prefix using string ops
+ * (no regex, safe for arbitrary prefix values).
+ */
+function toCanonicalTag(tag, currentPrefix) {
+  const cp = `${currentPrefix}-`;
+  if (tag.startsWith(cp)) {
+    return `${CANONICAL_PREFIX}-${tag.slice(cp.length)}`;
+  }
+  return tag;
+}
+
+export function buildComponentSummaries(indexes, { category, query, limit, offset, prefix, patternId, sort, patterns, installRegistry, patternFrequency } = {}) {
   const p = normalizePrefix(prefix);
   const q = typeof query === 'string' ? query.trim().toLowerCase() : '';
   const limitExplicit = Number.isInteger(limit);
@@ -1279,6 +1343,24 @@ export function buildComponentSummaries(indexes, { category, query, limit, offse
     modulePath,
   }));
 
+  // patternId filter: restrict to components required by a specific pattern
+  if (typeof patternId === 'string' && patternId.trim()) {
+    const pats = patterns && typeof patterns === 'object' ? patterns : {};
+    const pat = pats[patternId.trim()];
+    if (pat && Array.isArray(pat.requires)) {
+      const requiredIds = new Set(pat.requires.map((r) => String(r ?? '').trim()).filter(Boolean));
+      const tags = installRegistry?.tags && typeof installRegistry.tags === 'object' ? installRegistry.tags : {};
+      items = items.filter((item) => {
+        // Map tagName to componentId via install registry
+        const canonicalTag = toCanonicalTag(item.tagName, p);
+        const componentId = tags[canonicalTag];
+        return componentId && requiredIds.has(componentId);
+      });
+    } else {
+      items = [];
+    }
+  }
+
   if (category) {
     items = items.filter((item) => item.category === category);
   }
@@ -1296,6 +1378,18 @@ export function buildComponentSummaries(indexes, { category, query, limit, offse
     });
   }
 
+  // frequency sort: order by pattern usage count descending
+  if (sort === 'frequency') {
+    const freq = patternFrequency instanceof Map ? patternFrequency : new Map();
+    const tags = installRegistry?.tags && typeof installRegistry.tags === 'object' ? installRegistry.tags : {};
+    items = items.map((item) => {
+      const canonicalTag = toCanonicalTag(item.tagName, p);
+      const componentId = tags[canonicalTag] ?? '';
+      return { ...item, frequency: freq.get(componentId) ?? 0 };
+    });
+    items.sort((a, b) => b.frequency - a.frequency);
+  }
+
   const total = items.length;
   const paged = items.slice(pageOffset, pageOffset + pageSize);
 
@@ -1886,6 +1980,7 @@ export async function createMcpServer(loadJsonData, loadValidator, options = {})
   const patternRegistry = await loadJson('pattern-registry.json');
   const { patterns } = loadPatternRegistryShape(patternRegistry);
   const relatedComponentMap = buildRelatedComponentMap(installRegistry, patterns);
+  const patternFrequency = buildPatternFrequencyMap(patterns);
 
   // Load optional data files (design tokens, guidelines index)
   let designTokensData = null;
@@ -1916,7 +2011,7 @@ export async function createMcpServer(loadJsonData, loadValidator, options = {})
 
   const server = new McpServer({
     name: 'web-components-factory-design-system',
-    version: '0.6.0',
+    version: '0.7.0',
   });
 
   server.registerPrompt(
@@ -2066,7 +2161,7 @@ export async function createMcpServer(loadJsonData, loadValidator, options = {})
 
       const overview = {
         name: 'DADS Web Components (wcf)',
-        version: '0.6.0',
+        version: '0.7.0',
         prefix: detectedPrefix,
         totalComponents: indexes.decls.length,
         componentsByCategory: categoryCount,
@@ -2221,10 +2316,12 @@ export async function createMcpServer(loadJsonData, loadValidator, options = {})
         limit: z.number().int().min(1).max(200).optional().describe('Maximum items to return (default: 20; set 200 for all results)'),
         offset: z.number().int().min(0).optional().describe('Pagination offset (default: 0)'),
         prefix: z.string().optional(),
+        patternId: z.string().optional().describe('Filter to components required by this pattern'),
+        sort: z.enum(['default', 'frequency']).optional().describe('Sort order: "default" (CEM declaration order) or "frequency" (pattern usage count, descending)'),
       },
     },
-    async ({ category, query, limit, offset, prefix }) => {
-      const page = buildComponentSummaries(indexes, { category, query, limit, offset, prefix });
+    async ({ category, query, limit, offset, prefix, patternId, sort }) => {
+      const page = buildComponentSummaries(indexes, { category, query, limit, offset, prefix, patternId, sort, patterns, installRegistry, patternFrequency });
       const payload = {
         items: page.items,
         total: page.total,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoharada/wcf-mcp",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "MCP server for the web-components-factory design system. Provides component discovery, validation, and pattern-based UI composition without cloning the repository.",
   "type": "module",
   "bin": {

package/validator.mjs

@@ -676,9 +676,18 @@ const PARENT_CHILD_CONSTRAINTS = new Map([
   ['dads-menu-list-item', 'dads-menu-list'],
 ]);
 
+/**
+ * HTML void elements that never have a closing tag.
+ */
+const HTML_VOID_ELEMENTS = new Set([
+  'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input',
+  'link', 'meta', 'source', 'track', 'wbr',
+]);
+
 /**
  * Detect orphaned child components (child appears without expected parent).
- * Uses regex/text scan (DIG-13) — lower confidence, severity: warning.
+ * Uses a lightweight tag-stack approach: only prefix-matching tags (e.g. dads-*)
+ * are tracked on the stack; all other HTML elements are ignored.
  * @param {{
  *   filePath?: string;
  *   text: string;
@@ -697,7 +706,7 @@ export function detectOrphanedChildComponents({
   const p = prefix.toLowerCase();
   const canonicalPrefix = 'dads';
 
-  // Build prefix-aware constraint map
+  // Build prefix-aware constraint map (child → parent)
   const constraints = new Map();
   for (const [child, parent] of PARENT_CHILD_CONSTRAINTS.entries()) {
     const mappedChild = p !== canonicalPrefix ? child.replace(canonicalPrefix, p) : child;
@@ -705,36 +714,56 @@ export function detectOrphanedChildComponents({
     constraints.set(mappedChild, mappedParent);
   }
 
-  const textLower = text.toLowerCase();
+  const prefixDash = `${p}-`;
+  // Stack of currently open prefix-matching tags
+  const stack = [];
 
-  const tagRe = /<([a-z][a-z0-9-]*)\b([^<>]*?)>/gi;
+  // Regex matches opening tags, closing tags, and self-closing tags
+  const tagRe = /<\/?([a-z][a-z0-9-]*)\b[^<>]*?\/?>/gi;
   let m;
 
   while ((m = tagRe.exec(text))) {
+    const fullMatch = m[0];
     const tag = String(m[1] ?? '').toLowerCase();
-    const expectedParent = constraints.get(tag);
-    if (!expectedParent) continue;
-
-    // Check if the expected parent tag appears before this child in the text
-    const precedingText = textLower.slice(0, m.index);
-    const parentOpenPattern = `<${expectedParent}`;
-    const parentClosePattern = `</${expectedParent}`;
+    const isClosing = fullMatch.startsWith('</');
+    const isSelfClosing = fullMatch.endsWith('/>');
+
+    // Only track prefix-matching tags on the stack
+    if (!tag.startsWith(prefixDash)) continue;
+
+    if (isClosing) {
+      // Pop the matching opening tag from the stack (search from top)
+      for (let i = stack.length - 1; i >= 0; i--) {
+        if (stack[i] === tag) {
+          stack.splice(i, 1);
+          break;
+        }
+      }
+      continue;
+    }
 
-    const lastParentOpen = precedingText.lastIndexOf(parentOpenPattern);
-    const lastParentClose = precedingText.lastIndexOf(parentClosePattern);
+    // Check if this is a child that needs a parent
+    const expectedParent = constraints.get(tag);
+    if (expectedParent) {
+      const hasParent = stack.includes(expectedParent);
+      if (!hasParent) {
+        const tagOffset = m.index + 1;
+        const range = makeRange(lineStarts, tagOffset, tagOffset + tag.length);
+        diagnostics.push({
+          file: filePath,
+          range,
+          severity,
+          code: 'orphanedChildComponent',
+          message: `<${tag}> should be a child of <${expectedParent}>.`,
+          tagName: tag,
+          hint: `Wrap <${tag}> inside <${expectedParent}>...</${expectedParent}>.`,
+        });
+      }
+    }
 
-    if (lastParentOpen === -1 || lastParentClose > lastParentOpen) {
-      const tagOffset = m.index + 1;
-      const range = makeRange(lineStarts, tagOffset, tagOffset + tag.length);
-      diagnostics.push({
-        file: filePath,
-        range,
-        severity,
-        code: 'orphanedChildComponent',
-        message: `<${tag}> should be a child of <${expectedParent}>.`,
-        tagName: tag,
-        hint: `Wrap <${tag}> inside <${expectedParent}>...</${expectedParent}>.`,
-      });
+    // Push opening tag to stack (skip void elements and self-closing)
+    if (!isSelfClosing && !HTML_VOID_ELEMENTS.has(tag)) {
+      stack.push(tag);
     }
   }