@monoharada/wcf-mcp 0.1.2 → 0.5.0

package/examples/plugins/custom-validation-plugin.mjs

@@ -0,0 +1,70 @@
+/**
+ * Sample plugin for wcf-mcp (Plugin Contract v1).
+ * Demonstrates:
+ *  - Custom tool with handler
+ *  - Custom tool using handler context (helpers.loadJsonData)
+ *  - dataSources override for guidelines-index.json
+ */
+
+function detectSkippedHeadingLevel(html = '') {
+  const headingMatches = [...String(html).matchAll(/<h([1-6])\b/gi)];
+  const levels = headingMatches.map((match) => Number(match[1]));
+  const diagnostics = [];
+  for (let index = 1; index < levels.length; index += 1) {
+    const prev = levels[index - 1];
+    const curr = levels[index];
+    if (curr > prev + 1) {
+      diagnostics.push({
+        code: 'skippedHeadingLevel',
+        message: `Heading level jumps from h${prev} to h${curr}.`,
+        index,
+      });
+    }
+  }
+  return diagnostics;
+}
+
+export default {
+  name: 'custom-validation-plugin',
+  version: '0.2.0',
+  dataSources: [
+    {
+      fileName: 'guidelines-index.json',
+      path: './custom-guidelines.json',
+    },
+  ],
+  tools: [
+    {
+      name: 'validate_heading_structure',
+      description:
+        'Validate heading order in HTML. When: reviewing content hierarchy. Returns: diagnostics for skipped heading levels. After: fix heading structure before publication.',
+      inputSchema: {},
+      async handler(args = {}) {
+        const html = String(args?.html ?? '');
+        const diagnostics = detectSkippedHeadingLevel(html);
+        return {
+          diagnostics,
+          total: diagnostics.length,
+          ok: diagnostics.length === 0,
+        };
+      },
+    },
+    {
+      name: 'list_custom_guidelines',
+      description:
+        'List custom organization guidelines. When: discovering org-specific guidelines. Returns: guideline document titles and topics.',
+      async handler(_args, { helpers }) {
+        const data = await helpers.loadJsonData('guidelines-index.json');
+        const documents = Array.isArray(data?.documents) ? data.documents : [];
+        return {
+          total: documents.length,
+          documents: documents.map((doc) => ({
+            id: doc.id,
+            title: doc.title,
+            topic: doc.topic,
+          })),
+        };
+      },
+    },
+  ],
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoharada/wcf-mcp",
-  "version": "0.1.2",
+  "version": "0.5.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": {
@@ -11,7 +11,9 @@
     "core.mjs",
     "server.mjs",
     "validator.mjs",
-    "data/"
+    "data/",
+    "examples/",
+    "wcf-mcp.config.example.json"
   ],
   "keywords": [
     "mcp",

package/server.mjs

@@ -7,7 +7,7 @@
 
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { createMcpServer } from './core.mjs';
 
@@ -23,7 +23,9 @@ const REPO_FILE_MAP = {
   'pattern-registry.json': 'registry/pattern-registry.json',
   'design-tokens.json': 'design-tokens.json',
   'guidelines-index.json': 'guidelines-index.json',
+  'llms-full.txt': 'llms-full.txt',
 };
+export const DEFAULT_WCF_MCP_CONFIG = 'wcf-mcp.config.json';
 
 function resolveDataPath(fileName) {
   const bundled = path.join(__dirname, 'data', fileName);
@@ -47,20 +49,196 @@ async function loadJsonData(fileName) {
   throw new Error(`データファイルが見つかりません: ${fileName}`);
 }
 
+async function loadTextData(fileName) {
+  const { bundled, repo } = resolveDataPath(fileName);
+  for (const p of [bundled, repo]) {
+    if (!p) continue;
+    try {
+      return await fs.readFile(p, 'utf8');
+    } catch {
+      // Try next path
+    }
+  }
+  throw new Error(`テキストデータファイルが見つかりません: ${fileName}`);
+}
+
 async function loadValidator() {
   return import('./validator.mjs');
 }
 
+function isPlainObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function resolveFromBase(baseDir, maybeRelativePath) {
+  if (path.isAbsolute(maybeRelativePath)) return maybeRelativePath;
+  return path.resolve(baseDir, maybeRelativePath);
+}
+
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function normalizeDataSourcesInput(raw, baseDir, ownerLabel) {
+  if (!raw) return [];
+  const out = [];
+  if (Array.isArray(raw)) {
+    for (const item of raw) {
+      if (!isPlainObject(item)) {
+        throw new Error(`Invalid ${ownerLabel}.dataSources entry: expected object`);
+      }
+      const fileName = String(item.fileName ?? '').trim();
+      const sourcePath = String(item.path ?? '').trim();
+      if (!fileName || !sourcePath) {
+        throw new Error(`Invalid ${ownerLabel}.dataSources entry: fileName and path are required`);
+      }
+      out.push({ fileName, path: resolveFromBase(baseDir, sourcePath) });
+    }
+    return out;
+  }
+  if (isPlainObject(raw)) {
+    for (const [fileName, sourcePath] of Object.entries(raw)) {
+      const source = String(sourcePath ?? '').trim();
+      if (!fileName || !source) continue;
+      out.push({ fileName, path: resolveFromBase(baseDir, source) });
+    }
+    return out;
+  }
+  throw new Error(`Invalid ${ownerLabel}.dataSources: expected array or object map`);
+}
+
+async function loadModulePlugin(modulePath, baseDir) {
+  const absPath = resolveFromBase(baseDir, modulePath);
+  const loaded = await import(pathToFileURL(absPath).href);
+  const candidate = loaded?.default ?? loaded?.plugin ?? loaded;
+  const plugin = typeof candidate === 'function' ? await candidate() : candidate;
+  if (!isPlainObject(plugin)) {
+    throw new Error(`Invalid plugin module: ${modulePath} (expected plugin object export)`);
+  }
+  return {
+    plugin,
+    moduleDir: path.dirname(absPath),
+  };
+}
+
+function normalizeStaticTools(staticTools, ownerLabel) {
+  if (!Array.isArray(staticTools)) return [];
+  const out = [];
+  for (const entry of staticTools) {
+    if (!isPlainObject(entry)) {
+      throw new Error(`Invalid ${ownerLabel}.staticTools entry: expected object`);
+    }
+    const name = String(entry.name ?? '').trim();
+    if (!name) throw new Error(`Invalid ${ownerLabel}.staticTools entry: name is required`);
+    const description = String(entry.description ?? '').trim() || `Static plugin tool (${ownerLabel})`;
+    out.push({
+      name,
+      description,
+      inputSchema: {},
+      staticPayload: Object.prototype.hasOwnProperty.call(entry, 'payload')
+        ? entry.payload
+        : { message: `Static tool response from ${name}` },
+    });
+  }
+  return out;
+}
+
+export async function loadWcfMcpRuntimeConfig({ cwd = process.cwd(), configPath } = {}) {
+  const resolvedConfigPath = configPath
+    ? resolveFromBase(cwd, configPath)
+    : path.join(cwd, DEFAULT_WCF_MCP_CONFIG);
+  const exists = await pathExists(resolvedConfigPath);
+  if (!exists) {
+    if (configPath) {
+      throw new Error(`Config file not found: ${resolvedConfigPath}`);
+    }
+    return { configPath: resolvedConfigPath, plugins: [] };
+  }
+
+  const text = await fs.readFile(resolvedConfigPath, 'utf8');
+  const rawConfig = JSON.parse(text);
+  if (!isPlainObject(rawConfig)) {
+    throw new Error(`Invalid config: ${resolvedConfigPath} must contain a JSON object`);
+  }
+
+  const configDir = path.dirname(resolvedConfigPath);
+  const plugins = [];
+  const rootDataSources = normalizeDataSourcesInput(rawConfig.dataSources, configDir, 'config');
+  if (rootDataSources.length > 0) {
+    plugins.push({
+      name: 'config-data-sources',
+      version: '0.0.1',
+      dataSources: rootDataSources,
+      tools: [],
+    });
+  }
+
+  const rawPlugins = Array.isArray(rawConfig.plugins) ? rawConfig.plugins : [];
+  for (const item of rawPlugins) {
+    if (!isPlainObject(item)) {
+      throw new Error('Invalid config.plugins entry: expected object');
+    }
+    if (typeof item.module === 'string' && item.module.trim() !== '') {
+      const { plugin: loadedPlugin, moduleDir } = await loadModulePlugin(item.module, configDir);
+      const moduleDataSources = normalizeDataSourcesInput(
+        loadedPlugin.dataSources,
+        moduleDir,
+        `plugin(${item.module})`,
+      );
+      plugins.push({
+        ...loadedPlugin,
+        dataSources: moduleDataSources,
+      });
+      continue;
+    }
+
+    const name = String(item.name ?? '').trim();
+    const version = String(item.version ?? '').trim();
+    if (!name || !version) {
+      throw new Error('Invalid config.plugins static entry: name and version are required');
+    }
+    plugins.push({
+      name,
+      version,
+      dataSources: normalizeDataSourcesInput(item.dataSources, configDir, `plugin(${name})`),
+      tools: normalizeStaticTools(item.staticTools, `plugin(${name})`),
+    });
+  }
+
+  return {
+    configPath: resolvedConfigPath,
+    plugins,
+  };
+}
+
+export async function loadJsonDataFromPath(sourcePath) {
+  const text = await fs.readFile(sourcePath, 'utf8');
+  return JSON.parse(text);
+}
+
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
 
-export async function createServer() {
-  return createMcpServer(loadJsonData, loadValidator);
+export async function createServer(options = {}) {
+  const runtimeConfig = await loadWcfMcpRuntimeConfig({
+    cwd: options.cwd ?? process.cwd(),
+    configPath: options.configPath,
+  });
+  return createMcpServer(loadJsonData, loadValidator, {
+    plugins: runtimeConfig.plugins,
+    loadJsonDataFromPath,
+    loadTextData,
+  });
 }
 
-export async function startServer() {
-  const { server } = await createServer();
+export async function startServer(options = {}) {
+  const { server } = await createServer(options);
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }