@monoharada/wcf-mcp 0.8.0 → 0.9.0

package/README.md

@@ -78,7 +78,7 @@ claude mcp add wcf -- npx @monoharada/wcf-mcp
 }
 ```
 
-## 提供機能（19 tools + 1 prompt + 4 resources）
+## 提供機能（16 tools + 1 prompt + 5 resources）
 
 ### ガードレール
 
@@ -145,17 +145,6 @@ claude mcp add wcf -- npx @monoharada/wcf-mcp
 | `get_accessibility_docs` | component/topic/wcagLevel で A11y チェックリストとガイドライン要点を検索（`topic=all` では両ソースを混在返却） |
 | `search_guidelines` | ガイドライン（topic/query）をスコア付きで検索 |
 
-### スキル管理（リポジトリ内専用）
-
-| ツール | 説明 |
-|--------|------|
-| `list_skills` | 登録済みデザインシステムスキル一覧を取得 |
-| `get_skill_manifest` | スキルの SKILL.md マニフェストを取得 |
-| `check_drift` | スキルレジストリとリポジトリの整合性を検証 |
-
-> **注意**: これらのツールはリポジトリ内でのみ有効です。npx 実行時は `SKILLS_REGISTRY_UNAVAILABLE` エラーを返します。
-> 有効化には `wcf-mcp.config.json` で `design-system-skills` プラグインを設定してください（下記参照）。
-
 #### `get_design_tokens` の使用例
 
 **リクエスト:**
@@ -253,6 +242,7 @@ claude mcp add wcf -- npx @monoharada/wcf-mcp
 | `wcf://tokens` | トークン summary（type/category/themes/sample） |
 | `wcf://guidelines/{topic}` | topic 別ガイドライン要約（`accessibility`,`css`,`patterns`,`all`） |
 | `wcf://llms-full` | `llms-full.txt` の全文 |
+| `wcf://skills` | 登録済み Claude Code / Cursor / Codex スキルカタログ（skills-registry.json ベース） |
 
 ### Figma MCP との併用
 
@@ -339,7 +329,7 @@ npx @monoharada/wcf-mcp --transport=http --port=3100
 ※ `./plugins/custom-validation-plugin.mjs` は利用側プロジェクトに配置してください。  
 このリポジトリには参照用として `packages/mcp-server/examples/plugins/custom-validation-plugin.mjs` を同梱しています。
 
-### plugin 契約（v1.1）
+### plugin 契約（v1）
 
 詳細仕様: [docs/plugin-contract-v1.md](../../docs/plugin-contract-v1.md)
 
@@ -392,21 +382,6 @@ Claude Desktop 設定例:
 prefix: "myui" → dads-button → myui-button
 ```
 
-## v0.8.0 新機能
-
-### 新ツール（スキル管理）
-- **`list_skills`** — 登録済みデザインシステムスキルの一覧を取得
-- **`get_skill_manifest`** — スキルの SKILL.md マニフェスト内容を取得
-- **`check_drift`** — スキルレジストリとリポジトリの整合性を検証（ドリフト検出）
-
-### 改善
-- **Plugin 契約 v1.1** — module plugin の `dataSources` パス解決をモジュールディレクトリ基準に統一
-- **Skills Registry plugin** — `plugins/design-system-skills/` として同梱。`wcf-mcp.config.json` で有効化
-
-> スキル管理ツールはリポジトリ内でのみ動作します。npx 実行時は graceful に `SKILLS_REGISTRY_UNAVAILABLE` を返します。
-
----
-
 ## v0.4.0 新機能
 
 ### 新ツール
@@ -668,8 +643,6 @@ packages/mcp-server/
 ├── server.mjs       # MCP サーバー本体
 ├── validator.mjs    # HTML バリデーター
 ├── package.json     # npm パッケージ定義
-├── plugins/         # 同梱プラグイン
-│   └── design-system-skills/  # スキル管理ツール (list_skills, get_skill_manifest, check_drift)
 └── data/            # バンドルデータ (npm run mcp:build で生成)
     ├── custom-elements.json
     ├── install-registry.json

package/core.mjs

@@ -152,8 +152,24 @@ export const WCF_RESOURCE_URIS = Object.freeze({
   tokens: 'wcf://tokens',
   guidelinesTemplate: 'wcf://guidelines/{topic}',
   llmsFull: 'wcf://llms-full',
+  skills: 'wcf://skills',
 });
 
+/** Normalize a skill entry to summary fields (omit compat/manifest for wcf://skills). */
+function normalizeSkillSummary(s) {
+  return {
+    name: s.name,
+    description: s.description ?? '',
+    status: s.status ?? 'active',
+    path: s.path ?? '',
+    entry: s.entry ?? 'SKILL.md',
+    clients: Array.isArray(s.clients) ? s.clients : [],
+    tags: Array.isArray(s.tags) ? s.tags : [],
+    version: typeof s.version === 'string' ? s.version : '0.0.0',
+    dependencies: Array.isArray(s.dependencies) ? s.dependencies : [],
+  };
+}
+
 // Unidirectional synonym table: key → expands to include these terms (DIG-09)
 // Searching "keyboard" also matches "focus", "tab" etc. but NOT reverse.
 const SYNONYM_TABLE = new Map([
@@ -2154,6 +2170,33 @@ export async function createMcpServer(loadJsonData, loadValidator, options = {})
     },
   );
 
+  // -----------------------------------------------------------------------
+  // Resource: wcf://skills
+  // -----------------------------------------------------------------------
+  server.registerResource(
+    'wcf_skills',
+    WCF_RESOURCE_URIS.skills,
+    {
+      title: 'WCF Skills Catalog',
+      description: 'Registered Claude Code / Cursor / Codex skills from skills-registry.json.',
+      mimeType: 'application/json',
+    },
+    async () => {
+      const registry = await loadJsonData('skills-registry.json');
+      if (!registry || !Array.isArray(registry.skills)) {
+        throw new Error('SKILLS_REGISTRY_UNAVAILABLE: skills-registry.json is not available.');
+      }
+      const skills = registry.skills.map(normalizeSkillSummary);
+      return {
+        contents: [{
+          uri: WCF_RESOURCE_URIS.skills,
+          mimeType: 'application/json',
+          text: JSON.stringify({ schemaVersion: registry.schemaVersion ?? 2, total: skills.length, skills }, null, 2),
+        }],
+      };
+    },
+  );
+
   // -----------------------------------------------------------------------
   // Tool: get_design_system_overview
   // -----------------------------------------------------------------------
@@ -2249,6 +2292,10 @@ export async function createMcpServer(loadJsonData, loadValidator, options = {})
             uri: WCF_RESOURCE_URIS.llmsFull,
             purpose: 'Full LLM reference text for WCF',
           },
+          {
+            uri: WCF_RESOURCE_URIS.skills,
+            purpose: 'Skills catalog snapshot',
+          },
         ],
         availableTools: [
           { name: 'get_design_system_overview', purpose: 'This overview (start here)' },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoharada/wcf-mcp",
-  "version": "0.8.0",
+  "version": "0.9.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": {
@@ -13,7 +13,6 @@
     "validator.mjs",
     "data/",
     "examples/",
-    "plugins/",
     "wcf-mcp.config.example.json"
   ],
   "keywords": [

package/server.mjs

@@ -25,6 +25,7 @@ const REPO_FILE_MAP = {
   'design-tokens.json': 'design-tokens.json',
   'guidelines-index.json': 'guidelines-index.json',
   'llms-full.txt': 'llms-full.txt',
+  'skills-registry.json': 'registry/skills-registry.json',
 };
 export const DEFAULT_WCF_MCP_CONFIG = 'wcf-mcp.config.json';
 

package/wcf-mcp.config.example.json

@@ -3,9 +3,6 @@
     "guidelines-index.json": "./packages/mcp-server/data/guidelines-index.json"
   },
   "plugins": [
-    {
-      "module": "./packages/mcp-server/plugins/design-system-skills/index.mjs"
-    },
     {
       "module": "./packages/mcp-server/examples/plugins/custom-validation-plugin.mjs"
     },

package/plugins/design-system-skills/check-drift.mjs

@@ -1,685 +0,0 @@
-/**
- * check_drift plugin tool for wcf-mcp.
- * Checks consistency across 4 data sources (CEM, install-registry,
- * skills-registry, pattern-registry) and detects drift (divergence).
- * Phase 1: JSON comparison only (no SKILL.md content analysis).
- * Plugin Contract v1.0+
- */
-
-import { access } from 'node:fs/promises';
-import { resolve } from 'node:path';
-import { REPO_ROOT, loadRegistry } from './shared.mjs';
-
-// ---------------------------------------------------------------------------
-// Helper utilities
-// ---------------------------------------------------------------------------
-
-/**
- * Simple string hash for generating drift IDs.
- * @param {string} str
- * @returns {string} 8-char hex string
- */
-function hashId(str) {
-  let hash = 0;
-  for (let i = 0; i < str.length; i++) {
-    const char = str.charCodeAt(i);
-    hash = ((hash << 5) - hash) + char;
-    hash |= 0;
-  }
-  return Math.abs(hash).toString(16).padStart(8, '0').slice(0, 8);
-}
-
-/**
- * Generate a unique drift ID from rule + detail string.
- * @param {string} ruleId
- * @param {string} detail
- * @returns {string}
- */
-function driftId(ruleId, detail) {
-  return `DRIFT-${ruleId}-${hashId(detail)}`;
-}
-
-/**
- * Create a drift report entry.
- * @param {string} ruleId
- * @param {string} severity  HIGH | MEDIUM | LOW
- * @param {string} source    Data source name
- * @param {string} target    Target data source name
- * @param {string} message   Human-readable description
- * @param {object} [details] Additional context
- * @returns {object}
- */
-function createDrift(ruleId, severity, source, target, message, details = {}) {
-  return {
-    id: driftId(ruleId, message),
-    ruleId,
-    severity,
-    source,
-    target,
-    message,
-    details,
-  };
-}
-
-/**
- * Create a suggestion entry tied to a drift.
- * @param {string} id        The drift ID this suggestion relates to
- * @param {string} action    add | remove | update | document | investigate
- * @param {string} description  Human-readable suggestion
- * @param {string} target    File or data source to act on
- * @param {string} [priority]   recommended | optional
- * @returns {object}
- */
-function createSuggestion(id, action, description, target, priority = 'recommended') {
-  return { driftId: id, action, description, target, priority };
-}
-
-// ---------------------------------------------------------------------------
-// Data extraction helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Extract custom-element-definition tags from CEM.
- * @param {object|null} cem
- * @returns {Map<string, string>} tagName -> modulePath
- */
-function extractCemTags(cem) {
-  const tags = new Map();
-  if (!cem?.modules) return tags;
-  for (const mod of cem.modules) {
-    if (!Array.isArray(mod.exports)) continue;
-    for (const exp of mod.exports) {
-      if (exp.kind === 'custom-element-definition' && exp.name) {
-        tags.set(exp.name, mod.path);
-      }
-    }
-  }
-  return tags;
-}
-
-/**
- * Extract dads-* tag names from an HTML string.
- * @param {string} html
- * @returns {string[]} Unique sorted tag names
- */
-function extractDadsTags(html) {
-  const matches = [...String(html).matchAll(/<(dads-[a-z][a-z0-9-]*)/g)];
-  return [...new Set(matches.map((m) => m[1]))].sort();
-}
-
-// ---------------------------------------------------------------------------
-// Rule implementations
-// Each returns { drifts: DriftReport[], suggestions: DriftSuggestion[] }
-// ---------------------------------------------------------------------------
-
-/**
- * CIR01 - CEM component missing from install-registry.
- * For each CEM dads-* tag, verify it exists in install-registry tags.
- */
-function ruleCIR01(cemTags, irTags) {
-  const drifts = [];
-  const suggestions = [];
-  for (const [tag] of cemTags) {
-    if (!tag.startsWith('dads-')) continue;
-    if (!(tag in irTags)) {
-      const d = createDrift(
-        'CIR01',
-        'HIGH',
-        'custom-elements.json',
-        'install-registry.json',
-        `CEM tag "${tag}" is missing from install-registry tags`,
-        { tag },
-      );
-      drifts.push(d);
-      suggestions.push(
-        createSuggestion(d.id, 'add', `Add "${tag}" to install-registry tags section`, 'registry/install-registry.json'),
-      );
-    }
-  }
-  return { drifts, suggestions };
-}
-
-/**
- * CIR02 - Non-standard tags in CEM.
- * CEM exports with kind=custom-element-definition where name does NOT match dads-*.
- */
-function ruleCIR02(cemTags) {
-  const drifts = [];
-  const suggestions = [];
-  for (const [tag, modulePath] of cemTags) {
-    if (!tag.startsWith('dads-')) {
-      const d = createDrift(
-        'CIR02',
-        'LOW',
-        'custom-elements.json',
-        'custom-elements.json',
-        `CEM tag "${tag}" does not follow the dads-* naming convention`,
-        { tag, modulePath },
-      );
-      drifts.push(d);
-      suggestions.push(
-        createSuggestion(d.id, 'investigate', `Verify if "${tag}" should follow the dads-* naming convention`, 'custom-elements.json', 'optional'),
-      );
-    }
-  }
-  return { drifts, suggestions };
-}
-
-/**
- * CIT01 - install-registry tag missing from CEM.
- * For each install-registry tags key, verify it exists in CEM exports.
- */
-function ruleCIT01(cemTags, irTags) {
-  const drifts = [];
-  const suggestions = [];
-  for (const tag of Object.keys(irTags)) {
-    if (!cemTags.has(tag)) {
-      const d = createDrift(
-        'CIT01',
-        'HIGH',
-        'install-registry.json',
-        'custom-elements.json',
-        `install-registry tag "${tag}" is not defined in CEM`,
-        { tag, componentId: irTags[tag] },
-      );
-      drifts.push(d);
-      suggestions.push(
-        createSuggestion(d.id, 'remove', `Remove "${tag}" from install-registry or add its CEM definition`, 'registry/install-registry.json'),
-      );
-    }
-  }
-  return { drifts, suggestions };
-}
-
-/**
- * CIT02 - install-registry component tags mismatch with CEM.
- * For each install-registry component, compare its tags array with CEM-derived
- * tags for that component (by checking which CEM tags map to install-registry component IDs).
- */
-function ruleCIT02(cemTags, irTags, irComponents) {
-  const drifts = [];
-  const suggestions = [];
-
-  // Build reverse map: componentId -> Set<tag> from irTags
-  const tagsByComponent = {};
-  for (const [tag, compId] of Object.entries(irTags)) {
-    if (!tagsByComponent[compId]) tagsByComponent[compId] = new Set();
-    tagsByComponent[compId].add(tag);
-  }
-
-  for (const [compId, comp] of Object.entries(irComponents)) {
-    if (!Array.isArray(comp.tags)) continue;
-    const declaredTags = new Set(comp.tags);
-    const registeredTags = tagsByComponent[compId] ?? new Set();
-
-    // Check tags in component.tags that are not in the tags section
-    for (const tag of declaredTags) {
-      if (!registeredTags.has(tag)) {
-        const d = createDrift(
-          'CIT02',
-          'MEDIUM',
-          'install-registry.json',
-          'install-registry.json',
-          `Component "${compId}" declares tag "${tag}" but it is not in the tags section`,
-          { componentId: compId, tag },
-        );
-        drifts.push(d);
-        suggestions.push(
-          createSuggestion(d.id, 'update', `Add "${tag}" to install-registry tags section mapping to "${compId}"`, 'registry/install-registry.json'),
-        );
-      }
-    }
-
-    // Check tags in tags section that are not in component.tags
-    for (const tag of registeredTags) {
-      if (!declaredTags.has(tag)) {
-        const d = createDrift(
-          'CIT02',
-          'MEDIUM',
-          'install-registry.json',
-          'install-registry.json',
-          `Tag "${tag}" maps to "${compId}" in tags section but is not in component.tags`,
-          { componentId: compId, tag },
-        );
-        drifts.push(d);
-        suggestions.push(
-          createSuggestion(d.id, 'update', `Add "${tag}" to component "${compId}" tags array`, 'registry/install-registry.json'),
-        );
-      }
-    }
-  }
-  return { drifts, suggestions };
-}
-
-/**
- * IRD01 - Broken internal dependency in install-registry.
- * For each component's deps[], verify dep ID exists in components.
- */
-function ruleIRD01(irComponents) {
-  const drifts = [];
-  const suggestions = [];
-  const componentIds = new Set(Object.keys(irComponents));
-
-  for (const [compId, comp] of Object.entries(irComponents)) {
-    if (!Array.isArray(comp.deps)) continue;
-    for (const dep of comp.deps) {
-      if (!componentIds.has(dep)) {
-        const d = createDrift(
-          'IRD01',
-          'HIGH',
-          'install-registry.json',
-          'install-registry.json',
-          `Component "${compId}" depends on "${dep}" which does not exist in components`,
-          { componentId: compId, dependency: dep },
-        );
-        drifts.push(d);
-        suggestions.push(
-          createSuggestion(d.id, 'update', `Fix dependency "${dep}" in component "${compId}" or add the missing component`, 'registry/install-registry.json'),
-        );
-      }
-    }
-  }
-  return { drifts, suggestions };
-}
-
-/**
- * IRT01 - install-registry tags/components inconsistency.
- * tags keys must map to valid component IDs, and component tags must be in tags section.
- */
-function ruleIRT01(irTags, irComponents) {
-  const drifts = [];
-  const suggestions = [];
-  const componentIds = new Set(Object.keys(irComponents));
-
-  // Check tags section: each value must be a valid component ID
-  for (const [tag, compId] of Object.entries(irTags)) {
-    if (!componentIds.has(compId)) {
-      const d = createDrift(
-        'IRT01',
-        'HIGH',
-        'install-registry.json',
-        'install-registry.json',
-        `Tag "${tag}" maps to component "${compId}" which does not exist`,
-        { tag, componentId: compId },
-      );
-      drifts.push(d);
-      suggestions.push(
-        createSuggestion(d.id, 'update', `Fix tag "${tag}" mapping or add component "${compId}"`, 'registry/install-registry.json'),
-      );
-    }
-  }
-
-  // Check components section: each tag must be in tags section
-  for (const [compId, comp] of Object.entries(irComponents)) {
-    if (!Array.isArray(comp.tags)) continue;
-    for (const tag of comp.tags) {
-      if (!(tag in irTags)) {
-        const d = createDrift(
-          'IRT01',
-          'HIGH',
-          'install-registry.json',
-          'install-registry.json',
-          `Component "${compId}" tag "${tag}" is missing from tags section`,
-          { componentId: compId, tag },
-        );
-        drifts.push(d);
-        suggestions.push(
-          createSuggestion(d.id, 'add', `Add "${tag}": "${compId}" to install-registry tags section`, 'registry/install-registry.json'),
-        );
-      }
-    }
-  }
-  return { drifts, suggestions };
-}
-
-/**
- * CPR01 - pattern requires references missing component.
- * pattern.requires[] components must exist in install-registry components.
- */
-function ruleCPR01(patterns, irComponents) {
-  const drifts = [];
-  const suggestions = [];
-  const componentIds = new Set(Object.keys(irComponents));
-
-  for (const [patId, pat] of Object.entries(patterns)) {
-    if (!Array.isArray(pat.requires)) continue;
-    for (const req of pat.requires) {
-      if (!componentIds.has(req)) {
-        const d = createDrift(
-          'CPR01',
-          'HIGH',
-          'pattern-registry.json',
-          'install-registry.json',
-          `Pattern "${patId}" requires component "${req}" which is not in install-registry`,
-          { patternId: patId, requirement: req },
-        );
-        drifts.push(d);
-        suggestions.push(
-          createSuggestion(d.id, 'add', `Add component "${req}" to install-registry or remove it from pattern "${patId}" requires`, 'registry/install-registry.json'),
-        );
-      }
-    }
-  }
-  return { drifts, suggestions };
-}
-
-/**
- * CPT01 - pattern HTML contains unknown CEM tags.
- * Extract dads-* tags from pattern HTML, verify each exists in CEM.
- */
-function ruleCPT01(patterns, cemTags) {
-  const drifts = [];
-  const suggestions = [];
-
-  for (const [patId, pat] of Object.entries(patterns)) {
-    if (!pat.html) continue;
-    const tags = extractDadsTags(pat.html);
-    for (const tag of tags) {
-      if (!cemTags.has(tag)) {
-        const d = createDrift(
-          'CPT01',
-          'HIGH',
-          'pattern-registry.json',
-          'custom-elements.json',
-          `Pattern "${patId}" HTML uses tag "${tag}" which is not defined in CEM`,
-          { patternId: patId, tag },
-        );
-        drifts.push(d);
-        suggestions.push(
-          createSuggestion(d.id, 'investigate', `Verify tag "${tag}" in pattern "${patId}" HTML or add its CEM definition`, 'registry/pattern-registry.json'),
-        );
-      }
-    }
-  }
-  return { drifts, suggestions };
-}
-
-/**
- * CPT02 - pattern HTML uses tags not declared in requires.
- * dads-* tags in pattern HTML -> reverse lookup to component ID -> must be in pattern.requires.
- */
-function ruleCPT02(patterns, irTags) {
-  const drifts = [];
-  const suggestions = [];
-
-  for (const [patId, pat] of Object.entries(patterns)) {
-    if (!pat.html || !Array.isArray(pat.requires)) continue;
-    const tags = extractDadsTags(pat.html);
-    const requiresSet = new Set(pat.requires);
-
-    for (const tag of tags) {
-      const compId = irTags[tag];
-      if (compId && !requiresSet.has(compId)) {
-        const d = createDrift(
-          'CPT02',
-          'MEDIUM',
-          'pattern-registry.json',
-          'pattern-registry.json',
-          `Pattern "${patId}" HTML uses tag "${tag}" (component "${compId}") but "${compId}" is not in requires`,
-          { patternId: patId, tag, componentId: compId },
-        );
-        drifts.push(d);
-        suggestions.push(
-          createSuggestion(d.id, 'add', `Add "${compId}" to pattern "${patId}" requires array`, 'registry/pattern-registry.json'),
-        );
-      }
-    }
-  }
-  return { drifts, suggestions };
-}
-
-/**
- * CPC01 - Pattern coverage of components.
- * Count how many install-registry components are referenced by at least one pattern's requires.
- */
-function ruleCPC01(patterns, irComponents) {
-  const drifts = [];
-  const suggestions = [];
-  const componentIds = Object.keys(irComponents);
-  if (componentIds.length === 0) return { drifts, suggestions };
-
-  // Collect all component IDs referenced by any pattern
-  const coveredComponents = new Set();
-  for (const pat of Object.values(patterns)) {
-    if (!Array.isArray(pat.requires)) continue;
-    for (const req of pat.requires) {
-      coveredComponents.add(req);
-    }
-  }
-
-  const totalComponents = componentIds.length;
-  const uncoveredIds = [];
-  for (const id of componentIds) {
-    if (!coveredComponents.has(id)) uncoveredIds.push(id);
-  }
-  const coveredCount = totalComponents - uncoveredIds.length;
-  const coveragePercent = Math.round((coveredCount / totalComponents) * 100);
-  const severity = coveragePercent < 50 ? 'MEDIUM' : 'LOW';
-
-  if (uncoveredIds.length > 0) {
-    const d = createDrift(
-      'CPC01',
-      severity,
-      'pattern-registry.json',
-      'install-registry.json',
-      `Pattern coverage: ${coveredCount}/${totalComponents} components (${coveragePercent}%). ${uncoveredIds.length} components not used in any pattern.`,
-      {
-        coverage: coveragePercent,
-        coveredCount,
-        totalComponents,
-        uncoveredComponents: uncoveredIds,
-      },
-    );
-    drifts.push(d);
-    suggestions.push(
-      createSuggestion(d.id, 'document', `Consider adding patterns for uncovered components: ${uncoveredIds.slice(0, 5).join(', ')}${uncoveredIds.length > 5 ? '...' : ''}`, 'registry/pattern-registry.json', 'optional'),
-    );
-  }
-  return { drifts, suggestions };
-}
-
-/**
- * SIR01 - skills-registry path existence.
- * For each skill, verify skill.path + '/' + skill.entry file exists on disk.
- */
-async function ruleSIR01(skillsRegistry) {
-  const drifts = [];
-  const suggestions = [];
-  if (!skillsRegistry?.skills) return { drifts, suggestions };
-
-  for (const skill of skillsRegistry.skills) {
-    const entry = skill.entry ?? 'SKILL.md';
-    const fullPath = resolve(REPO_ROOT, skill.path, entry);
-    try {
-      await access(fullPath);
-    } catch {
-      const d = createDrift(
-        'SIR01',
-        'HIGH',
-        'skills-registry.json',
-        'filesystem',
-        `Skill "${skill.name}" entry file not found at "${skill.path}/${entry}"`,
-        { skillName: skill.name, path: skill.path, entry, expected: fullPath },
-      );
-      drifts.push(d);
-      suggestions.push(
-        createSuggestion(d.id, 'add', `Create "${entry}" at "${skill.path}/" or update the skill registry path`, 'registry/skills-registry.json'),
-      );
-    }
-  }
-  return { drifts, suggestions };
-}
-
-/**
- * SID01 - Skills dependency existence (v2 only).
- * Each skill.dependencies[] name must exist as another skill.name in the registry.
- */
-function ruleSID01(skillsRegistry) {
-  const drifts = [];
-  const suggestions = [];
-  if (!skillsRegistry?.skills) return { drifts, suggestions };
-
-  const skillNames = new Set(skillsRegistry.skills.map((s) => s.name));
-
-  for (const skill of skillsRegistry.skills) {
-    if (!Array.isArray(skill.dependencies)) continue;
-    for (const dep of skill.dependencies) {
-      const depName = typeof dep === 'string' ? dep : dep?.name;
-      if (depName && !skillNames.has(depName)) {
-        const d = createDrift(
-          'SID01',
-          'HIGH',
-          'skills-registry.json',
-          'skills-registry.json',
-          `Skill "${skill.name}" depends on "${depName}" which does not exist in the registry`,
-          { skillName: skill.name, dependency: depName },
-        );
-        drifts.push(d);
-        suggestions.push(
-          createSuggestion(d.id, 'add', `Add skill "${depName}" to the registry or remove the dependency from "${skill.name}"`, 'registry/skills-registry.json'),
-        );
-      }
-    }
-  }
-  return { drifts, suggestions };
-}
-
-// ---------------------------------------------------------------------------
-// Scope mapping
-// ---------------------------------------------------------------------------
-
-const SCOPE_RULES = {
-  all: ['CIR01', 'CIR02', 'CIT01', 'CIT02', 'IRD01', 'IRT01', 'CPR01', 'CPT01', 'CPT02', 'CPC01', 'SIR01', 'SID01'],
-  cem: ['CIR01', 'CIR02', 'CIT01', 'CIT02', 'IRD01', 'IRT01'],
-  skills: ['SIR01', 'SID01'],
-  tokens: [], // Reserved for future Phase 2
-  patterns: ['CPR01', 'CPT01', 'CPT02', 'CPC01'],
-};
-
-// ---------------------------------------------------------------------------
-// Main handler
-// ---------------------------------------------------------------------------
-
-/**
- * @param {object} args
- * @param {{ helpers: { loadJsonData: Function, buildJsonToolResponse: Function } }} ctx
- */
-async function checkDriftHandler(args, { helpers }) {
-  const scope = args?.scope ?? 'all';
-  const activeRules = new Set(SCOPE_RULES[scope] ?? SCOPE_RULES.all);
-  const drifts = [];
-  const suggestions = [];
-  const rulesExecuted = [];
-
-  // -----------------------------------------------------------------------
-  // Load data sources
-  // -----------------------------------------------------------------------
-  const [cem, ir, pr, sr] = await Promise.all([
-    helpers.loadJsonData('custom-elements.json'),
-    helpers.loadJsonData('install-registry.json'),
-    helpers.loadJsonData('pattern-registry.json'),
-    loadRegistry(),
-  ]);
-
-  // -----------------------------------------------------------------------
-  // Extract commonly used data
-  // -----------------------------------------------------------------------
-  const cemTags = extractCemTags(cem);
-  const irTags = ir?.tags ?? {};
-  const irComponents = ir?.components ?? {};
-  const patterns = pr?.patterns ?? {};
-
-  // -----------------------------------------------------------------------
-  // Execute rules based on scope
-  // -----------------------------------------------------------------------
-
-  /** Collect results from a synchronous rule function */
-  function runSync(ruleId, fn) {
-    if (!activeRules.has(ruleId)) return;
-    rulesExecuted.push(ruleId);
-    const result = fn();
-    drifts.push(...result.drifts);
-    suggestions.push(...result.suggestions);
-  }
-
-  /** Collect results from an async rule function */
-  async function runAsync(ruleId, fn) {
-    if (!activeRules.has(ruleId)) return;
-    rulesExecuted.push(ruleId);
-    const result = await fn();
-    drifts.push(...result.drifts);
-    suggestions.push(...result.suggestions);
-  }
-
-  // CEM <-> install-registry rules
-  runSync('CIR01', () => ruleCIR01(cemTags, irTags));
-  runSync('CIR02', () => ruleCIR02(cemTags));
-  runSync('CIT01', () => ruleCIT01(cemTags, irTags));
-  runSync('CIT02', () => ruleCIT02(cemTags, irTags, irComponents));
-  runSync('IRD01', () => ruleIRD01(irComponents));
-  runSync('IRT01', () => ruleIRT01(irTags, irComponents));
-
-  // Pattern rules
-  runSync('CPR01', () => ruleCPR01(patterns, irComponents));
-  runSync('CPT01', () => ruleCPT01(patterns, cemTags));
-  runSync('CPT02', () => ruleCPT02(patterns, irTags));
-  runSync('CPC01', () => ruleCPC01(patterns, irComponents));
-
-  // Skills rules — require skills-registry for scopes that include skill rules
-  const hasSkillRules = ['SIR01', 'SID01'].some((id) => activeRules.has(id));
-  if (hasSkillRules && !sr) {
-    const d = createDrift(
-      'SIR01',
-      'HIGH',
-      'skills-registry.json',
-      'filesystem',
-      'skills-registry.json is missing or corrupted — all skill rules skipped',
-      {},
-    );
-    drifts.push(d);
-    suggestions.push(
-      createSuggestion(d.id, 'add', 'Create or restore registry/skills-registry.json', 'registry/skills-registry.json'),
-    );
-    rulesExecuted.push(...['SIR01', 'SID01'].filter((id) => activeRules.has(id)));
-  } else {
-    await runAsync('SIR01', () => ruleSIR01(sr));
-    runSync('SID01', () => ruleSID01(sr));
-  }
-
-  // -----------------------------------------------------------------------
-  // Build output
-  // -----------------------------------------------------------------------
-  const summary = { total: drifts.length, high: 0, medium: 0, low: 0, ignored: 0 };
-  for (const d of drifts) {
-    if (d.severity === 'HIGH') summary.high++;
-    else if (d.severity === 'MEDIUM') summary.medium++;
-    else if (d.severity === 'LOW') summary.low++;
-  }
-
-  const meta = {
-    phase: 1,
-    scope,
-    rulesExecuted,
-    timestamp: new Date().toISOString(),
-  };
-
-  return helpers.buildJsonToolResponse({ drifts, suggestions, summary, meta });
-}
-
-// ---------------------------------------------------------------------------
-// Plugin export
-// ---------------------------------------------------------------------------
-
-export default {
-  name: 'design-system-skills-drift',
-  version: '1.0.0',
-  tools: [
-    {
-      name: 'check_drift',
-      description:
-        'Check consistency across CEM, install-registry, skills-registry, and pattern-registry. Detects drift (divergence) between data sources. When: before PR, after registry updates, periodic audits. Returns: {drifts[], suggestions[], summary{total,high,medium,low,ignored}, meta{phase,scope,rulesExecuted,timestamp}}. Args: scope? (all|cem|skills|tokens|patterns, default: all). Phase 1: 12 JSON comparison rules.',
-      inputSchema: {},
-      handler: checkDriftHandler,
-    },
-  ],
-};

package/plugins/design-system-skills/get-skill-manifest.mjs

@@ -1,193 +0,0 @@
-/**
- * get_skill_manifest plugin tool for wcf-mcp.
- * Returns skill metadata (manifest) from skills-registry v2.
- * Supports metadata-only, full content, and section extraction modes.
- * Plugin Contract v1.0+ (content modes require v1.1+)
- */
-
-import { readFile } from 'node:fs/promises';
-import { resolve } from 'node:path';
-import {
-  REPO_ROOT,
-  loadRegistry,
-  normalizeSkillEntry,
-  buildErrorResponse,
-} from './shared.mjs';
-
-/** Maximum safe response size in bytes (95KB) */
-const MAX_SAFE_RESPONSE = 95 * 1024;
-
-/**
- * Normalize a heading text to a slug for section matching.
- * @param {string} text
- * @returns {string}
- */
-function normalizeHeading(text) {
-  return text
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9\s_]/g, '')
-    .replace(/\s+/g, '_');
-}
-
-/**
- * Detect sections (H1/H2 headings) from markdown content.
- * @param {string} content
- * @returns {{ sections: Array<{level: number, text: string, normalized: string, line: number}>, lines: string[] }}
- */
-function parseMarkdownSections(content) {
-  const lines = content.split('\n');
-  const sections = [];
-  for (let i = 0; i < lines.length; i++) {
-    const match = lines[i].match(/^(#{1,2})\s+(.+)/);
-    if (match) {
-      sections.push({
-        level: match[1].length,
-        text: match[2].trim(),
-        normalized: normalizeHeading(match[2]),
-        line: i,
-      });
-    }
-  }
-  return { sections, lines };
-}
-
-/**
- * Extract a specific section from parsed markdown by normalized heading name.
- * @param {{ sections: Array<{level: number, normalized: string, line: number}>, lines: string[] }} parsed
- * @param {string} sectionName
- * @returns {string|null}
- */
-function extractSection(parsed, sectionName) {
-  const idx = parsed.sections.findIndex((s) =>
-    s.normalized === sectionName,
-  );
-  if (idx === -1) return null;
-
-  const startLine = parsed.sections[idx].line;
-  const startLevel = parsed.sections[idx].level;
-  const nextSection = parsed.sections
-    .slice(idx + 1)
-    .find((s) => s.level <= startLevel);
-  const endLine = nextSection ? nextSection.line : parsed.lines.length;
-
-  return parsed.lines.slice(startLine, endLine).join('\n').trim();
-}
-
-export default {
-  name: 'design-system-skills-manifest',
-  version: '1.0.0',
-  tools: [
-    {
-      name: 'get_skill_manifest',
-      description:
-        'Return skill metadata (manifest) from skills-registry v2. When: retrieving full skill details, reading SKILL.md content, extracting specific sections. Returns: {manifest, content?, section_content?, content_size?, available_sections?, truncated?}. After: use skill content to guide implementation. Args: skill_id (required, e.g. "css-writing-rules"), include_content? (boolean, requires Contract v1.1+), section? (overview|workflow|do_dont|references|quick_reference|token_architecture|error_contract|procedure).',
-      inputSchema: {},
-      async handler(args, { helpers }) {
-        // 1. Load registry
-        const registry = await loadRegistry();
-        if (!registry || !Array.isArray(registry.skills)) {
-          return buildErrorResponse(
-            'SKILLS_REGISTRY_UNAVAILABLE',
-            'Skills registry data not available.',
-          );
-        }
-
-        // 2. Find skill by name
-        const { skill_id, include_content, section } = args;
-        const skill = registry.skills.find((s) => s.name === skill_id);
-        if (!skill) {
-          return buildErrorResponse(
-            'SKILL_NOT_FOUND',
-            `Skill '${skill_id}' not found in registry.`,
-          );
-        }
-
-        // 3. Build manifest with v2 defaults
-        const manifest = normalizeSkillEntry(skill);
-
-        // 4. Mode 1: Metadata Only
-        const wantsContent = include_content === true;
-        const wantsSection = typeof section === 'string' && section.length > 0;
-
-        if (!wantsContent && !wantsSection) {
-          return helpers.buildJsonToolResponse({ manifest });
-        }
-
-        // 5. Modes 2 & 3 require loadTextData (Contract v1.1+)
-        if (typeof helpers.loadTextData !== 'function') {
-          return buildErrorResponse(
-            'CONTRACT_VERSION_ERROR',
-            'Content retrieval requires Contract v1.1+. loadTextData helper is not available.',
-          );
-        }
-
-        // 6. Read SKILL.md from disk
-        const skillFilePath = resolve(REPO_ROOT, skill.path ?? '', skill.entry ?? 'SKILL.md');
-        let fileContent;
-        try {
-          fileContent = await readFile(skillFilePath, 'utf-8');
-        } catch {
-          const relPath = `${skill.path ?? ''}/${skill.entry ?? 'SKILL.md'}`;
-          return buildErrorResponse(
-            'SKILL_CONTENT_NOT_FOUND',
-            `SKILL.md not found at ${relPath}`,
-          );
-        }
-
-        // 7. Parse sections once (reused for detection and extraction)
-        const parsed = parseMarkdownSections(fileContent);
-        const available_sections = parsed.sections.map((s) => s.normalized);
-
-        // 8. Build response payload
-        const payload = { manifest };
-        let totalContentSize = 0;
-
-        // Mode 2: Full content
-        if (wantsContent) {
-          const contentBytes = Buffer.byteLength(fileContent, 'utf8');
-          totalContentSize += contentBytes;
-          payload.content = fileContent;
-          payload.content_size = contentBytes;
-        }
-
-        // Mode 3: Section extraction
-        if (wantsSection) {
-          const sectionContent = extractSection(parsed, section);
-          if (sectionContent === null) {
-            return buildErrorResponse(
-              'SECTION_NOT_FOUND',
-              `Section '${section}' not found in ${skill_id} SKILL.md. Available: [${available_sections.join(', ')}]`,
-            );
-          }
-          const sectionBytes = Buffer.byteLength(sectionContent, 'utf8');
-          totalContentSize += sectionBytes;
-          payload.section_content = sectionContent;
-          payload.content_size = payload.content_size ?? sectionBytes;
-        }
-
-        payload.available_sections = available_sections;
-
-        // 9. Truncation check
-        const responseJson = JSON.stringify(payload);
-        const responseBytes = Buffer.byteLength(responseJson, 'utf8');
-        if (responseBytes > MAX_SAFE_RESPONSE) {
-          if (payload.content) {
-            const overhead = responseBytes - totalContentSize;
-            const availableBytes = MAX_SAFE_RESPONSE - overhead - 200;
-            // Estimate char limit from byte ratio
-            const ratio = Math.max(0, availableBytes) / Buffer.byteLength(payload.content, 'utf8');
-            const charLimit = Math.floor(payload.content.length * Math.min(1, ratio));
-            payload.content = payload.content.slice(0, charLimit);
-            payload.content_size = Buffer.byteLength(payload.content, 'utf8');
-          }
-          payload.truncated = true;
-        } else {
-          payload.truncated = false;
-        }
-
-        return helpers.buildJsonToolResponse(payload);
-      },
-    },
-  ],
-};

package/plugins/design-system-skills/index.mjs

@@ -1,20 +0,0 @@
-/**
- * Design System Skills plugin bundle for wcf-mcp.
- * Aggregates list_skills, get_skill_manifest, and check_drift tools.
- */
-
-import listSkillsPlugin from './list-skills.mjs';
-import getSkillManifestPlugin from './get-skill-manifest.mjs';
-import checkDriftPlugin from './check-drift.mjs';
-
-const allTools = [
-  ...listSkillsPlugin.tools,
-  ...getSkillManifestPlugin.tools,
-  ...checkDriftPlugin.tools,
-];
-
-export default {
-  name: 'design-system-skills',
-  version: '1.0.0',
-  tools: allTools,
-};

package/plugins/design-system-skills/list-skills.mjs

@@ -1,78 +0,0 @@
-/**
- * list_skills plugin tool for wcf-mcp.
- * Lists registered skills from skills-registry.json with filtering support.
- * Plugin Contract v1.0+
- */
-
-import { loadRegistry, normalizeSkillEntry, buildErrorResponse } from './shared.mjs';
-
-/**
- * Project a full skill entry to a lightweight summary (excludes compat/manifest).
- */
-function toSummary(skill) {
-  const { compat, manifest, ...summary } = normalizeSkillEntry(skill);
-  return summary;
-}
-
-export default {
-  name: 'design-system-skills-list',
-  version: '1.0.0',
-  tools: [
-    {
-      name: 'list_skills',
-      description:
-        'List registered Claude Code / Cursor / Codex skills from skills-registry.json. When: discovering available skills, checking skill metadata, filtering skills by client/tags. Returns: {total, skills[]} where each skill has name, description, status, clients, tags, version, dependencies, path, entry. After: use get_skill_manifest for full content. Args: client? (claude_code|cursor|codex), tags? (spec|token|audit|drift|workflow, AND logic), status? (active|deprecated|experimental), query? (free-text substring search).',
-      inputSchema: {},
-      async handler(args = {}, { helpers }) {
-        const registry = await loadRegistry();
-        if (!registry || !Array.isArray(registry.skills)) {
-          return buildErrorResponse(
-            'SKILLS_REGISTRY_UNAVAILABLE',
-            'Skills registry data not available.',
-          );
-        }
-
-        const { client, tags, status, query } = args;
-        let matched = registry.skills;
-
-        // Filter by status
-        if (status) {
-          matched = matched.filter(
-            (s) => String(s.status ?? 'active') === status,
-          );
-        }
-
-        // Filter by client
-        if (client) {
-          matched = matched.filter(
-            (s) => Array.isArray(s.clients) && s.clients.includes(client),
-          );
-        }
-
-        // Filter by tags (AND logic)
-        if (Array.isArray(tags) && tags.length > 0) {
-          matched = matched.filter((s) => {
-            const skillTags = Array.isArray(s.tags) ? s.tags : [];
-            return tags.every((t) => skillTags.includes(t));
-          });
-        }
-
-        // Filter by free-text query
-        if (typeof query === 'string' && query.trim() !== '') {
-          const q = query.toLowerCase();
-          matched = matched.filter((s) => {
-            const name = String(s.name ?? '').toLowerCase();
-            const desc = String(s.description ?? '').toLowerCase();
-            return name.includes(q) || desc.includes(q);
-          });
-        }
-
-        const skills = matched.map(toSummary);
-        return helpers.buildJsonToolResponse({
-          total: skills.length,
-          skills,
-        });
-      },
-    },
-  ],
-};

package/plugins/design-system-skills/shared.mjs

@@ -1,75 +0,0 @@
-/**
- * Shared utilities for design-system-skills plugin.
- * Single source of truth for registry loading, defaults, and error responses.
- */
-
-import { readFile } from 'node:fs/promises';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-export const REPO_ROOT = resolve(__dirname, '..', '..', '..', '..');
-export const REGISTRY_PATH = resolve(REPO_ROOT, 'registry', 'skills-registry.json');
-
-/** v2 defaults for v1 skill entries */
-export const V2_DEFAULTS = {
-  tags: [],
-  version: '0.0.0',
-  dependencies: [],
-  compat: {},
-  manifest: {},
-};
-
-/**
- * Load skills registry from disk.
- * @returns {Promise<object|null>}
- */
-export async function loadRegistry() {
-  try {
-    const raw = await readFile(REGISTRY_PATH, 'utf-8');
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Normalize a raw skill entry from the registry, applying v2 defaults.
- * @param {object} skill - Raw skill entry
- * @returns {object} Normalized skill fields
- */
-export function normalizeSkillEntry(skill) {
-  return {
-    name: skill.name,
-    description: skill.description ?? '',
-    status: skill.status ?? 'active',
-    path: skill.path ?? '',
-    entry: skill.entry ?? 'SKILL.md',
-    clients: Array.isArray(skill.clients) ? skill.clients : [],
-    tags: Array.isArray(skill.tags) ? skill.tags : V2_DEFAULTS.tags,
-    version: typeof skill.version === 'string' ? skill.version : V2_DEFAULTS.version,
-    dependencies: Array.isArray(skill.dependencies) ? skill.dependencies : V2_DEFAULTS.dependencies,
-    compat: skill.compat ?? V2_DEFAULTS.compat,
-    manifest: skill.manifest ?? V2_DEFAULTS.manifest,
-  };
-}
-
-/**
- * Build an MCP error response.
- * @param {string} code
- * @param {string} message
- * @returns {object}
- */
-export function buildErrorResponse(code, message) {
-  return {
-    content: [
-      {
-        type: 'text',
-        text: JSON.stringify({ error: { code, message } }, null, 2),
-      },
-    ],
-    isError: true,
-  };
-}