specifian 0.1.0-beta.0

package/dist/cli/index.js

@@ -0,0 +1,1757 @@
+#!/usr/bin/env node
+import {
+  lintContent,
+  loadCategorySchema,
+  validateSpecs
+} from "../chunk-774NFJLC.js";
+import {
+  WIKILINK_PATTERN,
+  guardPath,
+  loadSpec,
+  loadSpecs,
+  parseSpecId,
+  resolveSpecPathAny,
+  toSpecId
+} from "../chunk-JY5QLNZ4.js";
+
+// src/cli/index.ts
+import fs11 from "fs";
+import path13 from "path";
+import { program } from "commander";
+
+// src/server/app.ts
+import http from "http";
+import fs8 from "fs";
+import path10 from "path";
+import { fileURLToPath } from "url";
+import express from "express";
+import { WebSocketServer } from "ws";
+
+// src/server/routes/specs.ts
+import { Router } from "express";
+import fs2 from "fs/promises";
+import path2 from "path";
+import matter from "gray-matter";
+
+// src/server/specOps.ts
+import fs from "fs/promises";
+import path from "path";
+var SpecOpsError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "SpecOpsError";
+  }
+  status;
+};
+function resolveSpecPath(specsDir, category, slug) {
+  const parts = category === "" ? [] : category.split("/");
+  const filePath = path.join(specsDir, ...parts, `${slug}.mdx`);
+  if (!guardPath(specsDir, filePath)) {
+    throw new SpecOpsError(400, "\u30D1\u30B9\u30C8\u30E9\u30D0\u30FC\u30B5\u30EB\u306F\u8A31\u53EF\u3055\u308C\u3066\u3044\u307E\u305B\u3093");
+  }
+  return filePath;
+}
+function buildProtectedRanges(src) {
+  const ranges = [];
+  const fenceRe = /(`{3,}|~{3,})[^\n]*\n[\s\S]*?\1/g;
+  let m;
+  while ((m = fenceRe.exec(src)) !== null) {
+    ranges.push([m.index, m.index + m[0].length]);
+  }
+  const inlineRe = /`[^`\n]*`/g;
+  while ((m = inlineRe.exec(src)) !== null) {
+    ranges.push([m.index, m.index + m[0].length]);
+  }
+  return ranges;
+}
+function isProtected(pos, ranges) {
+  for (const [s, e] of ranges) {
+    if (pos >= s && pos < e) return true;
+  }
+  return false;
+}
+function rewriteLinks(src, from, to) {
+  if (!src.includes(`[[${from}]]`) && !src.includes(`[[${from}|`)) {
+    return src;
+  }
+  const protected_ = buildProtectedRanges(src);
+  const re = new RegExp(WIKILINK_PATTERN.source, WIKILINK_PATTERN.flags);
+  let result = "";
+  let lastIndex = 0;
+  let match;
+  while ((match = re.exec(src)) !== null) {
+    const target = match[1].trim();
+    if (target !== from) continue;
+    if (isProtected(match.index, protected_)) continue;
+    result += src.slice(lastIndex, match.index);
+    const label = match[2];
+    if (label !== void 0) {
+      result += `[[${to}|${label}]]`;
+    } else {
+      result += `[[${to}]]`;
+    }
+    lastIndex = match.index + match[0].length;
+  }
+  result += src.slice(lastIndex);
+  return result;
+}
+async function findRefs(specsDir, id) {
+  const specs = await loadSpecs(specsDir);
+  const refs = specs.filter((s) => s.id !== id && s.links.includes(id)).map((s) => s.id).sort();
+  return refs;
+}
+async function renameSpec(specsDir, from, to) {
+  const parsedFrom = parseSpecId(from);
+  if (!parsedFrom) {
+    throw new SpecOpsError(400, `\u7121\u52B9\u306A\u30B9\u30DA\u30C3\u30AF ID: ${from}`);
+  }
+  const parsedTo = parseSpecId(to);
+  if (!parsedTo) {
+    throw new SpecOpsError(400, `\u7121\u52B9\u306A\u30B9\u30DA\u30C3\u30AF ID: ${to}`);
+  }
+  if (parsedFrom.slug === "_" || parsedFrom.slug === "_template") {
+    throw new SpecOpsError(400, "\u30A4\u30F3\u30C7\u30C3\u30AF\u30B9/\u30C6\u30F3\u30D7\u30EC\u30FC\u30C8\u306F\u30EA\u30CD\u30FC\u30E0\u3067\u304D\u307E\u305B\u3093");
+  }
+  if (parsedTo.slug === "_" || parsedTo.slug === "_template") {
+    throw new SpecOpsError(400, "\u30EA\u30CD\u30FC\u30E0\u5148\u306E slug \u306B\u30A4\u30F3\u30C7\u30C3\u30AF\u30B9/\u30C6\u30F3\u30D7\u30EC\u30FC\u30C8\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093");
+  }
+  const fromPath = resolveSpecPath(specsDir, parsedFrom.category, parsedFrom.slug);
+  const toPath = resolveSpecPath(specsDir, parsedTo.category, parsedTo.slug);
+  const specs = await loadSpecs(specsDir);
+  const fromMeta = specs.find((s) => s.id === from);
+  if (!fromMeta) {
+    throw new SpecOpsError(404, `\u30B9\u30DA\u30C3\u30AF\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${from}`);
+  }
+  const toExists = specs.some((s) => s.id === to);
+  if (toExists) {
+    throw new SpecOpsError(409, `\u30EA\u30CD\u30FC\u30E0\u5148\u306F\u65E2\u306B\u5B58\u5728\u3057\u307E\u3059: ${to}`);
+  }
+  const toCategoryDir = path.dirname(toPath);
+  try {
+    await fs.access(toCategoryDir);
+  } catch {
+    const relCategoryDir = path.relative(specsDir, toCategoryDir).split(path.sep).join("/");
+    throw new SpecOpsError(400, `\u30EA\u30CD\u30FC\u30E0\u5148\u306E\u30AB\u30C6\u30B4\u30EA\u30FC\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u30FC\u304C\u5B58\u5728\u3057\u307E\u305B\u3093: ${relCategoryDir}`);
+  }
+  await fs.rename(fromPath, toPath);
+  const specsAfter = await loadSpecs(specsDir);
+  const rewrittenIds = [];
+  await Promise.all(
+    specsAfter.map(async (spec) => {
+      const parts = spec.category === "" ? [] : spec.category.split("/");
+      const filePath = path.join(specsDir, ...parts, `${spec.slug}.mdx`);
+      let content;
+      try {
+        content = await fs.readFile(filePath, "utf-8");
+      } catch {
+        return;
+      }
+      const rewritten = rewriteLinks(content, from, to);
+      if (rewritten === content) return;
+      await fs.writeFile(filePath, rewritten, "utf-8");
+      rewrittenIds.push(spec.id);
+    })
+  );
+  rewrittenIds.sort();
+  const { loadSpec: loadSpec2 } = await import("../store-WLSSJHFW.js");
+  const result = await loadSpec2(specsDir, toPath);
+  if (!result) {
+    throw new SpecOpsError(500, "\u30EA\u30CD\u30FC\u30E0\u5F8C\u306E\u30B9\u30DA\u30C3\u30AF\u8AAD\u307F\u8FBC\u307F\u306B\u5931\u6557\u3057\u307E\u3057\u305F");
+  }
+  return { meta: result.meta, rewrittenFiles: rewrittenIds };
+}
+async function deleteSpec(specsDir, id) {
+  const parsed = parseSpecId(id);
+  if (!parsed) {
+    throw new SpecOpsError(400, `\u7121\u52B9\u306A\u30B9\u30DA\u30C3\u30AF ID: ${id}`);
+  }
+  const filePath = resolveSpecPath(specsDir, parsed.category, parsed.slug);
+  const specs = await loadSpecs(specsDir);
+  const exists = specs.some((s) => s.id === id);
+  if (!exists) {
+    throw new SpecOpsError(404, `\u30B9\u30DA\u30C3\u30AF\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${id}`);
+  }
+  await fs.unlink(filePath);
+}
+
+// src/server/routes/specs.ts
+function specsRouter(specsDir) {
+  const router = Router();
+  router.get("/", async (_req, res) => {
+    try {
+      const specs = await loadSpecs(specsDir);
+      const filtered = specs.filter((s) => s.slug !== "_template");
+      res.json(filtered);
+    } catch (err) {
+      res.status(500).json({ error: String(err) });
+    }
+  });
+  router.post("/", async (req, res) => {
+    const body = req.body;
+    if (!body.slug) {
+      res.status(400).json({ error: "slug \u306F\u5FC5\u9808\u3067\u3059" });
+      return;
+    }
+    const category = body.category ?? "";
+    const slug = body.slug;
+    const title = body.title ?? slug;
+    const categoryParts = category === "" ? [] : category.split("/");
+    const newFilePath = path2.join(specsDir, ...categoryParts, `${slug}.mdx`);
+    if (!guardPath(specsDir, newFilePath)) {
+      res.status(400).json({ error: "\u30D1\u30B9\u30C8\u30E9\u30D0\u30FC\u30B5\u30EB\u304C\u691C\u51FA\u3055\u308C\u307E\u3057\u305F" });
+      return;
+    }
+    try {
+      await fs2.access(newFilePath);
+      res.status(409).json({ error: `"${slug}" \u306F\u65E2\u306B\u5B58\u5728\u3057\u307E\u3059` });
+      return;
+    } catch {
+    }
+    let content;
+    if (slug === "_") {
+      const indexTitle = body.title ?? (category || "\u30DB\u30FC\u30E0");
+      content = `---
+title: ${indexTitle}
+---
+
+# ${indexTitle}
+
+<SpecList />
+`;
+    } else {
+      const templatePath = path2.join(specsDir, ...categoryParts, "_template.mdx");
+      try {
+        await fs2.access(templatePath);
+        const templateContent = await fs2.readFile(templatePath, "utf-8");
+        const parsed = matter(templateContent);
+        parsed.data["title"] = title;
+        content = matter.stringify(parsed.content, parsed.data);
+      } catch {
+        content = `---
+title: ${title}
+---
+
+# ${title}
+`;
+      }
+    }
+    try {
+      await fs2.mkdir(path2.dirname(newFilePath), { recursive: true });
+      await fs2.writeFile(newFilePath, content, "utf-8");
+      const result = await loadSpec(specsDir, newFilePath);
+      if (!result) {
+        res.status(500).json({ error: "\u4F5C\u6210\u5F8C\u306E\u8AAD\u307F\u8FBC\u307F\u306B\u5931\u6557\u3057\u307E\u3057\u305F" });
+        return;
+      }
+      res.status(201).json({ meta: result.meta });
+    } catch (err) {
+      res.status(500).json({ error: String(err) });
+    }
+  });
+  router.get("/*", async (req, res) => {
+    const paramPath = req.params[0] ?? "";
+    if (!paramPath) {
+      res.status(400).json({ error: "\u30D1\u30B9\u304C\u6307\u5B9A\u3055\u308C\u3066\u3044\u307E\u305B\u3093" });
+      return;
+    }
+    const segments = paramPath.split("/").filter(Boolean);
+    if (segments.length === 0) {
+      res.status(400).json({ error: "\u30D1\u30B9\u304C\u6307\u5B9A\u3055\u308C\u3066\u3044\u307E\u305B\u3093" });
+      return;
+    }
+    const slug = segments[segments.length - 1];
+    const category = segments.length > 1 ? segments.slice(0, -1).join("/") : "";
+    const candidates = resolveSpecPathAny(specsDir, category, slug);
+    for (const candidate of candidates) {
+      if (!guardPath(specsDir, candidate)) {
+        res.status(400).json({ error: "\u30D1\u30B9\u30C8\u30E9\u30D0\u30FC\u30B5\u30EB\u304C\u691C\u51FA\u3055\u308C\u307E\u3057\u305F" });
+        return;
+      }
+      const result = await loadSpec(specsDir, candidate);
+      if (result) {
+        res.json(result);
+        return;
+      }
+    }
+    res.status(404).json({ error: `\u30B9\u30DA\u30C3\u30AF\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${paramPath}` });
+  });
+  router.put("/*", async (req, res) => {
+    const paramPath = req.params[0] ?? "";
+    if (!paramPath) {
+      res.status(400).json({ error: "\u30D1\u30B9\u304C\u6307\u5B9A\u3055\u308C\u3066\u3044\u307E\u305B\u3093" });
+      return;
+    }
+    const body = req.body;
+    if (typeof body.content !== "string") {
+      res.status(400).json({ error: "content \u306F\u5FC5\u9808\u3067\u3059" });
+      return;
+    }
+    const segments = paramPath.split("/").filter(Boolean);
+    if (segments.length === 0) {
+      res.status(400).json({ error: "\u30D1\u30B9\u304C\u6307\u5B9A\u3055\u308C\u3066\u3044\u307E\u305B\u3093" });
+      return;
+    }
+    const slug = segments[segments.length - 1];
+    const category = segments.length > 1 ? segments.slice(0, -1).join("/") : "";
+    const candidates = resolveSpecPathAny(specsDir, category, slug);
+    let foundCandidate = null;
+    for (const candidate of candidates) {
+      if (!guardPath(specsDir, candidate)) {
+        res.status(400).json({ error: "\u30D1\u30B9\u30C8\u30E9\u30D0\u30FC\u30B5\u30EB\u304C\u691C\u51FA\u3055\u308C\u307E\u3057\u305F" });
+        return;
+      }
+      try {
+        await fs2.access(candidate);
+        foundCandidate = candidate;
+        break;
+      } catch {
+      }
+    }
+    if (!foundCandidate) {
+      res.status(404).json({ error: `\u30B9\u30DA\u30C3\u30AF\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${paramPath}` });
+      return;
+    }
+    try {
+      await fs2.writeFile(foundCandidate, body.content, "utf-8");
+      const result = await loadSpec(specsDir, foundCandidate);
+      if (!result) {
+        res.status(500).json({ error: "\u4FDD\u5B58\u5F8C\u306E\u8AAD\u307F\u8FBC\u307F\u306B\u5931\u6557\u3057\u307E\u3057\u305F" });
+        return;
+      }
+      let issues = [];
+      try {
+        const { lintContent: lintContent2 } = await import("../lintCore-E4ZG4DFJ.js");
+        issues = await lintContent2(specsDir, {
+          content: body.content,
+          category,
+          slug
+        });
+      } catch (lintErr) {
+        console.error("[specs] lintContent \u5931\u6557 (\u7121\u8996):", lintErr);
+      }
+      res.json({ meta: result.meta, issues });
+    } catch (err) {
+      res.status(500).json({ error: String(err) });
+    }
+  });
+  router.delete("/*", async (req, res) => {
+    const paramPath = req.params[0] ?? "";
+    if (!paramPath) {
+      res.status(400).json({ error: "\u30D1\u30B9\u304C\u6307\u5B9A\u3055\u308C\u3066\u3044\u307E\u305B\u3093" });
+      return;
+    }
+    const segments = paramPath.split("/").filter(Boolean);
+    if (segments.length === 0) {
+      res.status(400).json({ error: "\u30D1\u30B9\u304C\u6307\u5B9A\u3055\u308C\u3066\u3044\u307E\u305B\u3093" });
+      return;
+    }
+    const slug = segments[segments.length - 1];
+    const category = segments.length > 1 ? segments.slice(0, -1).join("/") : "";
+    const id = toSpecId(category, slug);
+    try {
+      await deleteSpec(specsDir, id);
+      res.json({ ok: true });
+    } catch (err) {
+      if (err instanceof SpecOpsError) {
+        res.status(err.status).json({ error: err.message });
+        return;
+      }
+      res.status(500).json({ error: String(err) });
+    }
+  });
+  return router;
+}
+
+// src/server/routes/categories.ts
+import { Router as Router2 } from "express";
+import fs3 from "fs/promises";
+import path3 from "path";
+var DEFAULT_INDEX_CONTENT = (categoryPath) => `---
+title: ${categoryPath}
+---
+
+# ${categoryPath}
+
+<SpecList />
+`;
+var DEFAULT_TEMPLATE_CONTENT = (categoryPath) => `---
+title: \u65B0\u3057\u3044\u30B9\u30DA\u30C3\u30AF
+description: ''
+---
+
+# \u65B0\u3057\u3044\u30B9\u30DA\u30C3\u30AF
+
+\u30B9\u30DA\u30C3\u30AF\u306E\u8AAC\u660E\u3092\u3053\u3053\u306B\u8A18\u8FF0\u3057\u307E\u3059\u3002
+`;
+function categoriesRouter(specsDir) {
+  const router = Router2();
+  router.post("/", async (req, res) => {
+    const body = req.body;
+    if (!body.path) {
+      res.status(400).json({ error: "path \u306F\u5FC5\u9808\u3067\u3059" });
+      return;
+    }
+    const categoryPath = body.path.replace(/\\/g, "/").replace(/^\/|\/$/g, "");
+    const parts = categoryPath.split("/");
+    const newDir = path3.join(specsDir, ...parts);
+    if (!guardPath(specsDir, newDir)) {
+      res.status(400).json({ error: "\u30D1\u30B9\u30C8\u30E9\u30D0\u30FC\u30B5\u30EB\u304C\u691C\u51FA\u3055\u308C\u307E\u3057\u305F" });
+      return;
+    }
+    try {
+      await fs3.access(newDir);
+      res.status(409).json({ error: `\u30AB\u30C6\u30B4\u30EA\u30FC "${categoryPath}" \u306F\u65E2\u306B\u5B58\u5728\u3057\u307E\u3059` });
+      return;
+    } catch {
+    }
+    try {
+      await fs3.mkdir(newDir, { recursive: true });
+      const indexPath = path3.join(newDir, "_.mdx");
+      await fs3.writeFile(indexPath, DEFAULT_INDEX_CONTENT(categoryPath), "utf-8");
+      const templatePath = path3.join(newDir, "_template.mdx");
+      await fs3.writeFile(templatePath, DEFAULT_TEMPLATE_CONTENT(categoryPath), "utf-8");
+      res.status(201).json({ path: categoryPath });
+    } catch (err) {
+      res.status(500).json({ error: String(err) });
+    }
+  });
+  return router;
+}
+
+// src/server/routes/data.ts
+import { Router as Router3 } from "express";
+function dataRouter(specsDir) {
+  const router = Router3();
+  router.get("/", async (_req, res) => {
+    try {
+      const specs = await loadSpecs(specsDir);
+      const filtered = specs.filter((s) => s.slug !== "_template");
+      const result = {};
+      for (const spec of filtered) {
+        const cat = spec.category;
+        if (!result[cat]) result[cat] = {};
+        result[cat][spec.slug] = spec.data;
+      }
+      res.json(result);
+    } catch (err) {
+      res.status(500).json({ error: String(err) });
+    }
+  });
+  router.get("/*", async (req, res) => {
+    const categoryPath = (req.params[0] ?? "").split("/").filter(Boolean).join("/");
+    try {
+      const specs = await loadSpecs(specsDir);
+      const filtered = specs.filter(
+        (s) => s.category === categoryPath && s.slug !== "_template"
+      );
+      const result = {};
+      for (const spec of filtered) {
+        result[spec.slug] = spec.data;
+      }
+      res.json(result);
+    } catch (err) {
+      res.status(500).json({ error: String(err) });
+    }
+  });
+  return router;
+}
+
+// src/server/routes/graph.ts
+import { Router as Router4 } from "express";
+function graphRouter(specsDir) {
+  const router = Router4();
+  router.get("/", async (_req, res) => {
+    try {
+      const specs = await loadSpecs(specsDir);
+      const filtered = specs.filter((s) => s.slug !== "_template");
+      const existingIds = new Set(filtered.map((s) => s.id));
+      const nodes = filtered.map((s) => ({
+        id: s.id,
+        title: s.title,
+        category: s.category
+      }));
+      const edges = [];
+      const missingIds = /* @__PURE__ */ new Set();
+      for (const spec of filtered) {
+        for (const linkTarget of spec.links) {
+          edges.push({ source: spec.id, target: linkTarget });
+          if (!existingIds.has(linkTarget)) {
+            missingIds.add(linkTarget);
+          }
+        }
+      }
+      for (const missingId of missingIds) {
+        const lastColon = missingId.lastIndexOf(":");
+        const title = lastColon >= 0 ? missingId.slice(lastColon + 1) : missingId;
+        const category = lastColon >= 0 ? missingId.slice(0, lastColon) : "";
+        nodes.push({ id: missingId, title, category, missing: true });
+      }
+      const graph = { nodes, edges };
+      res.json(graph);
+    } catch (err) {
+      res.status(500).json({ error: String(err) });
+    }
+  });
+  return router;
+}
+
+// src/server/routes/generators.ts
+import { Router as Router5 } from "express";
+
+// src/server/generate.ts
+import fs4 from "fs/promises";
+import path4 from "path";
+import matter2 from "gray-matter";
+import { render, createContext, defineHelper } from "@scaffdog/engine";
+function normalizePath(p) {
+  return p.split(path4.sep).join("/");
+}
+function specMetaToVariable(spec) {
+  return {
+    id: spec.id,
+    category: spec.category,
+    slug: spec.slug,
+    path: spec.path,
+    title: spec.title,
+    description: spec.description ?? "",
+    data: spec.data,
+    links: spec.links,
+    isIndex: spec.isIndex
+  };
+}
+function specsToVariable(specs) {
+  return specs.map(specMetaToVariable);
+}
+function buildHelpers() {
+  const helpers = /* @__PURE__ */ new Map();
+  defineHelper(helpers, "pascal", (_ctx, value) => {
+    if (typeof value !== "string") return String(value);
+    return value.replace(/[-_\s]+(.)/g, (_, c) => c.toUpperCase()).replace(/^(.)/, (c) => c.toUpperCase());
+  });
+  defineHelper(helpers, "camel", (_ctx, value) => {
+    if (typeof value !== "string") return String(value);
+    const pascal = value.replace(/[-_\s]+(.)/g, (_, c) => c.toUpperCase()).replace(/^(.)/, (c) => c.toUpperCase());
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+  });
+  defineHelper(helpers, "upper", (_ctx, value) => {
+    if (typeof value !== "string") return String(value);
+    return value.toUpperCase();
+  });
+  defineHelper(helpers, "lower", (_ctx, value) => {
+    if (typeof value !== "string") return String(value);
+    return value.toLowerCase();
+  });
+  defineHelper(helpers, "snake", (_ctx, value) => {
+    if (typeof value !== "string") return String(value);
+    return value.replace(/([A-Z])/g, "_$1").replace(/[-\s]+/g, "_").replace(/^_/, "").toLowerCase();
+  });
+  defineHelper(helpers, "optionalMark", (_ctx, value) => {
+    if (value && typeof value === "object" && value.nullable === true) {
+      return "?";
+    }
+    return "";
+  });
+  defineHelper(helpers, "tsType", (_ctx, value) => {
+    if (typeof value !== "string") return "unknown";
+    const v = value.toLowerCase().trim();
+    if (v.startsWith("bigint") || v.startsWith("int") || v.startsWith("smallint") || v.startsWith("tinyint") || v.startsWith("numeric") || v.startsWith("decimal") || v.startsWith("float") || v.startsWith("double") || v.startsWith("real")) return "number";
+    if (v.startsWith("bool")) return "boolean";
+    if (v.startsWith("json") || v.startsWith("jsonb")) return "Record<string, unknown>";
+    if (v.startsWith("timestamp") || v.startsWith("date") || v.startsWith("time")) return "string";
+    return "string";
+  });
+  return helpers;
+}
+function parseGeneratorDoc(content) {
+  const parsed = matter2(content);
+  const body = parsed.content;
+  const sections = [];
+  const headingPattern = /^#\s+`([^`]+)`\s*$/gm;
+  const marks = [];
+  let m;
+  while ((m = headingPattern.exec(body)) !== null) {
+    marks.push({ filename: m[1].trim(), headStart: m.index, bodyStart: m.index + m[0].length });
+  }
+  marks.forEach((mark, i) => {
+    const end = i + 1 < marks.length ? marks[i + 1].headStart : body.length;
+    const segment = body.slice(mark.bodyStart, end);
+    const fenceMatch = /^```[^\n]*\n([\s\S]*?)^```/m.exec(segment);
+    if (fenceMatch) {
+      sections.push({ filename: mark.filename, template: fenceMatch[1] });
+    }
+  });
+  return sections;
+}
+async function listGenerators(specsDir) {
+  const generatorsDir = path4.join(specsDir, "_generators");
+  try {
+    const entries = await fs4.readdir(generatorsDir, { withFileTypes: true });
+    return entries.filter((e) => e.isFile() && /\.md$/.test(e.name)).map((e) => e.name.replace(/\.md$/, ""));
+  } catch {
+    return [];
+  }
+}
+async function runGenerator(specsDir, generator, allSpecs, specId, outDir) {
+  const generatorPath = path4.join(specsDir, "_generators", `${generator}.md`);
+  let generatorContent;
+  try {
+    generatorContent = await fs4.readFile(generatorPath, "utf-8");
+  } catch {
+    throw new Error(`\u30B8\u30A7\u30CD\u30EC\u30FC\u30BF\u30FC "${generator}" \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${generatorPath}`);
+  }
+  const sections = parseGeneratorDoc(generatorContent);
+  if (sections.length === 0) {
+    throw new Error(`\u30B8\u30A7\u30CD\u30EC\u30FC\u30BF\u30FC "${generator}" \u306B\u30C6\u30F3\u30D7\u30EC\u30FC\u30C8\u30BB\u30AF\u30B7\u30E7\u30F3\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093`);
+  }
+  const targetSpecs = specId != null ? allSpecs.filter((s) => s.id === specId) : allSpecs.filter((s) => !s.isIndex && s.slug !== "_template");
+  if (specId != null && targetSpecs.length === 0) {
+    throw new Error(`\u30B9\u30DA\u30C3\u30AF "${specId}" \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093`);
+  }
+  const helpers = buildHelpers();
+  const allSpecsVar = specsToVariable(allSpecs);
+  const files = [];
+  for (const spec of targetSpecs) {
+    const specVar = specMetaToVariable(spec);
+    const variables = /* @__PURE__ */ new Map([
+      ["spec", specVar],
+      ["specs", allSpecsVar]
+    ]);
+    const context = createContext({ variables, helpers });
+    for (const section of sections) {
+      const renderedFilename = render(section.filename, context);
+      const renderedContent = render(section.template, context);
+      const filePath = normalizePath(renderedFilename);
+      if (outDir != null) {
+        const absOut = path4.resolve(outDir, renderedFilename);
+        await fs4.mkdir(path4.dirname(absOut), { recursive: true });
+        await fs4.writeFile(absOut, renderedContent, "utf-8");
+      }
+      files.push({ path: filePath, content: renderedContent });
+    }
+  }
+  return files;
+}
+
+// src/server/routes/generators.ts
+function generatorsRouter(specsDir) {
+  const router = Router5();
+  router.get("/", async (_req, res) => {
+    try {
+      const names = await listGenerators(specsDir);
+      res.json(names);
+    } catch (err) {
+      res.status(500).json({ error: String(err) });
+    }
+  });
+  return router;
+}
+function generateRouter(specsDir) {
+  const router = Router5();
+  router.post("/", async (req, res) => {
+    const body = req.body;
+    if (!body.generator) {
+      res.status(400).json({ error: "generator \u306F\u5FC5\u9808\u3067\u3059" });
+      return;
+    }
+    try {
+      const allSpecs = await loadSpecs(specsDir);
+      const files = await runGenerator(
+        specsDir,
+        body.generator,
+        allSpecs,
+        body.specId,
+        body.out
+      );
+      res.json({ files });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      res.status(400).json({ error: message });
+    }
+  });
+  return router;
+}
+
+// src/server/routes/search.ts
+import { Router as Router6 } from "express";
+
+// src/server/searchCore.ts
+import fs5 from "fs/promises";
+import path5 from "path";
+import matter3 from "gray-matter";
+var FIELD_RANK = {
+  title: 0,
+  description: 1,
+  data: 2,
+  body: 3
+};
+var SNIPPET_CONTEXT = 40;
+function makeSnippet(text, query) {
+  const normalized = text.replace(/\s+/g, " ").trim();
+  const lower = normalized.toLowerCase();
+  const lowerQ = query.toLowerCase();
+  const idx = lower.indexOf(lowerQ);
+  if (idx === -1) return normalized.slice(0, SNIPPET_CONTEXT * 2);
+  const start = Math.max(0, idx - SNIPPET_CONTEXT);
+  const end = Math.min(normalized.length, idx + lowerQ.length + SNIPPET_CONTEXT);
+  const prefix = start > 0 ? "\u2026" : "";
+  const suffix = end < normalized.length ? "\u2026" : "";
+  return prefix + normalized.slice(start, end) + suffix;
+}
+function firstBodyLine(body) {
+  for (const line of body.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed) return trimmed.slice(0, SNIPPET_CONTEXT * 2);
+  }
+  return "";
+}
+async function searchSpecs(specsDir, q, limit) {
+  if (!q) return [];
+  const allSpecs = await loadSpecs(specsDir);
+  const specs = allSpecs.filter((s) => s.slug !== "_template");
+  const lowerQ = q.toLowerCase();
+  const results = [];
+  for (const spec of specs) {
+    if (spec.title.toLowerCase().includes(lowerQ)) {
+      let snippet = "";
+      if (spec.description) {
+        snippet = makeSnippet(spec.description, q);
+      } else {
+        const absPath2 = path5.join(specsDir, ...spec.path.split("/"));
+        try {
+          const raw = await fs5.readFile(absPath2, "utf-8");
+          const parsed = matter3(raw);
+          snippet = firstBodyLine(parsed.content);
+        } catch {
+          snippet = spec.title;
+        }
+      }
+      results.push({
+        id: spec.id,
+        title: spec.title,
+        category: spec.category,
+        slug: spec.slug,
+        snippet,
+        field: "title"
+      });
+      continue;
+    }
+    if (spec.description && spec.description.toLowerCase().includes(lowerQ)) {
+      results.push({
+        id: spec.id,
+        title: spec.title,
+        category: spec.category,
+        slug: spec.slug,
+        snippet: makeSnippet(spec.description, q),
+        field: "description"
+      });
+      continue;
+    }
+    const dataStr = JSON.stringify(spec.data);
+    if (dataStr.toLowerCase().includes(lowerQ)) {
+      results.push({
+        id: spec.id,
+        title: spec.title,
+        category: spec.category,
+        slug: spec.slug,
+        snippet: makeSnippet(dataStr, q),
+        field: "data"
+      });
+      continue;
+    }
+    const absPath = path5.join(specsDir, ...spec.path.split("/"));
+    try {
+      const raw = await fs5.readFile(absPath, "utf-8");
+      const parsed = matter3(raw);
+      const body = parsed.content;
+      if (body.toLowerCase().includes(lowerQ)) {
+        results.push({
+          id: spec.id,
+          title: spec.title,
+          category: spec.category,
+          slug: spec.slug,
+          snippet: makeSnippet(body, q),
+          field: "body"
+        });
+      }
+    } catch {
+    }
+  }
+  results.sort((a, b) => {
+    const rankDiff = FIELD_RANK[a.field] - FIELD_RANK[b.field];
+    if (rankDiff !== 0) return rankDiff;
+    return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+  });
+  return results.slice(0, limit);
+}
+
+// src/server/routes/search.ts
+function searchRouter(specsDir) {
+  const router = Router6();
+  router.get("/", async (req, res) => {
+    try {
+      const rawQ = typeof req.query["q"] === "string" ? req.query["q"] : "";
+      const q = rawQ.trim();
+      if (!q) {
+        res.json([]);
+        return;
+      }
+      const rawLimit = parseInt(
+        typeof req.query["limit"] === "string" ? req.query["limit"] : "20",
+        10
+      );
+      const limit = isNaN(rawLimit) ? 20 : Math.min(100, Math.max(1, rawLimit));
+      const results = await searchSpecs(specsDir, q, limit);
+      res.json(results);
+    } catch (err) {
+      res.status(500).json({ error: String(err) });
+    }
+  });
+  return router;
+}
+
+// src/server/routes/components.ts
+import { Router as Router7 } from "express";
+import fs6 from "fs/promises";
+import path6 from "path";
+function normalizePath2(p) {
+  return p.split(path6.sep).join("/");
+}
+function componentsRouter(specsDir) {
+  const router = Router7();
+  router.get("/", async (_req, res) => {
+    const dir = path6.join(specsDir, "_components");
+    try {
+      const entries = await fs6.readdir(dir, { withFileTypes: true }).catch((err) => {
+        if (err.code === "ENOENT") return null;
+        throw err;
+      });
+      if (entries === null) {
+        res.json([]);
+        return;
+      }
+      const files = [];
+      for (const entry of entries) {
+        if (!entry.isFile()) continue;
+        if (!/\.(tsx|jsx)$/.test(entry.name)) continue;
+        const abs = path6.join(dir, entry.name);
+        const source = await fs6.readFile(abs, "utf-8");
+        files.push({
+          path: normalizePath2(path6.relative(specsDir, abs)),
+          source
+        });
+      }
+      files.sort((a, b) => a.path.localeCompare(b.path));
+      res.json(files);
+    } catch (err) {
+      res.status(500).json({ error: String(err) });
+    }
+  });
+  return router;
+}
+
+// src/server/routes/validation.ts
+import { Router as Router8 } from "express";
+function validationRouter(specsDir) {
+  const router = Router8();
+  router.get("/", async (_req, res) => {
+    try {
+      const report = await validateSpecs(specsDir);
+      res.json(report);
+    } catch (err) {
+      res.status(500).json({ error: String(err) });
+    }
+  });
+  return router;
+}
+
+// src/server/routes/schema.ts
+import path7 from "path";
+import { Router as Router9 } from "express";
+function schemaRouter(specsDir) {
+  const router = Router9();
+  router.get(/^(\/.*)?$/, async (req, res) => {
+    const rawPath = req.path;
+    let decoded;
+    try {
+      decoded = decodeURIComponent(rawPath);
+    } catch {
+      res.status(400).json({ error: "URL\u306E\u30C7\u30B3\u30FC\u30C9\u306B\u5931\u6557\u3057\u307E\u3057\u305F" });
+      return;
+    }
+    const category = decoded.replace(/^\//, "");
+    const resolvedSpecsDir = path7.resolve(specsDir);
+    const segments = category === "" ? [] : category.split("/");
+    const resolvedTarget = path7.resolve(specsDir, ...segments);
+    if (!resolvedTarget.startsWith(resolvedSpecsDir + path7.sep) && resolvedTarget !== resolvedSpecsDir) {
+      res.status(400).json({ error: "\u30D1\u30B9\u30C8\u30E9\u30D0\u30FC\u30B5\u30EB\u306F\u8A31\u53EF\u3055\u308C\u3066\u3044\u307E\u305B\u3093" });
+      return;
+    }
+    const result = await loadCategorySchema(specsDir, category);
+    if (result.error !== void 0) {
+      res.status(500).json({ error: result.error });
+      return;
+    }
+    const body = { schema: result.schema };
+    res.json(body);
+  });
+  return router;
+}
+
+// src/server/routes/drawings.ts
+import path8 from "path";
+import fs7 from "fs/promises";
+import { Router as Router10, json } from "express";
+function normalizePath3(p) {
+  return p.split(path8.sep).join("/");
+}
+function resolveGuarded(specsDir, relPath) {
+  const resolvedSpecsDir = path8.resolve(specsDir);
+  const resolvedTarget = path8.resolve(specsDir, ...relPath.split("/"));
+  if (resolvedTarget !== resolvedSpecsDir && !resolvedTarget.startsWith(resolvedSpecsDir + path8.sep)) {
+    return null;
+  }
+  return resolvedTarget;
+}
+async function scanExcalidraw(specsDir, dir) {
+  let entries;
+  try {
+    entries = await fs7.readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const results = [];
+  for (const entry of entries) {
+    if (entry.name.startsWith(".")) continue;
+    if (entry.name === "node_modules") continue;
+    const abs = path8.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const children = await scanExcalidraw(specsDir, abs);
+      results.push(...children);
+    } else if (entry.isFile() && entry.name.endsWith(".excalidraw")) {
+      results.push({
+        path: normalizePath3(path8.relative(specsDir, abs))
+      });
+    }
+  }
+  return results;
+}
+function drawingsRouter(specsDir) {
+  const router = Router10();
+  router.use(json({ limit: "20mb" }));
+  router.get("/", async (_req, res) => {
+    try {
+      const drawings = await scanExcalidraw(specsDir, specsDir);
+      drawings.sort((a, b) => a.path.localeCompare(b.path));
+      res.json(drawings);
+    } catch (err) {
+      res.status(500).json({ error: String(err) });
+    }
+  });
+  router.get(/^\/.+$/, async (req, res) => {
+    let decoded;
+    try {
+      decoded = decodeURIComponent(req.path);
+    } catch {
+      res.status(400).json({ error: "URL\u306E\u30C7\u30B3\u30FC\u30C9\u306B\u5931\u6557\u3057\u307E\u3057\u305F" });
+      return;
+    }
+    const relPath = decoded.replace(/^\//, "");
+    if (!relPath) {
+      res.status(400).json({ error: "\u30D1\u30B9\u304C\u7A7A\u3067\u3059" });
+      return;
+    }
+    const resolved = resolveGuarded(specsDir, relPath);
+    if (resolved === null) {
+      res.status(400).json({ error: "\u30D1\u30B9\u30C8\u30E9\u30D0\u30FC\u30B5\u30EB\u306F\u8A31\u53EF\u3055\u308C\u3066\u3044\u307E\u305B\u3093" });
+      return;
+    }
+    const filePath = resolved + ".excalidraw";
+    let raw;
+    try {
+      raw = await fs7.readFile(filePath, "utf-8");
+    } catch (err) {
+      const e = err;
+      if (e.code === "ENOENT") {
+        res.status(404).json({ error: "\u56F3\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093" });
+        return;
+      }
+      res.status(500).json({ error: String(err) });
+      return;
+    }
+    res.type("application/json").send(raw);
+  });
+  router.put(/^\/.+$/, async (req, res) => {
+    let decoded;
+    try {
+      decoded = decodeURIComponent(req.path);
+    } catch {
+      res.status(400).json({ error: "URL\u306E\u30C7\u30B3\u30FC\u30C9\u306B\u5931\u6557\u3057\u307E\u3057\u305F" });
+      return;
+    }
+    const relPath = decoded.replace(/^\//, "");
+    if (!relPath) {
+      res.status(400).json({ error: "\u30D1\u30B9\u304C\u7A7A\u3067\u3059" });
+      return;
+    }
+    const resolved = resolveGuarded(specsDir, relPath);
+    if (resolved === null) {
+      res.status(400).json({ error: "\u30D1\u30B9\u30C8\u30E9\u30D0\u30FC\u30B5\u30EB\u306F\u8A31\u53EF\u3055\u308C\u3066\u3044\u307E\u305B\u3093" });
+      return;
+    }
+    const body = req.body;
+    if (body === null || typeof body !== "object" || Array.isArray(body)) {
+      res.status(400).json({ error: "\u30EA\u30AF\u30A8\u30B9\u30C8\u30DC\u30C7\u30A3\u306F JSON \u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" });
+      return;
+    }
+    const filePath = resolved + ".excalidraw";
+    const parentDir = path8.dirname(filePath);
+    try {
+      await fs7.access(parentDir);
+    } catch {
+      res.status(400).json({ error: `\u89AA\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u30FC\u304C\u5B58\u5728\u3057\u307E\u305B\u3093: ${normalizePath3(path8.relative(specsDir, parentDir))}` });
+      return;
+    }
+    try {
+      const content = JSON.stringify(body, null, 2) + "\n";
+      await fs7.writeFile(filePath, content, { encoding: "utf-8" });
+    } catch (err) {
+      res.status(500).json({ error: String(err) });
+      return;
+    }
+    const meta = {
+      path: normalizePath3(path8.relative(specsDir, filePath))
+    };
+    res.json(meta);
+  });
+  return router;
+}
+
+// src/server/routes/lint.ts
+import { Router as Router11 } from "express";
+function lintRouter(specsDir) {
+  const router = Router11();
+  router.post("/", async (req, res) => {
+    try {
+      const body = req.body;
+      if (typeof body.content !== "string") {
+        res.status(400).json({ error: "content \u306F string \u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" });
+        return;
+      }
+      const issues = await lintContent(specsDir, {
+        content: body.content,
+        category: typeof body.category === "string" ? body.category : void 0,
+        slug: typeof body.slug === "string" ? body.slug : void 0
+      });
+      res.json({ issues });
+    } catch (err) {
+      res.status(500).json({ error: String(err) });
+    }
+  });
+  return router;
+}
+
+// src/server/routes/rename.ts
+import { Router as Router12 } from "express";
+function renameRouter(specsDir) {
+  const router = Router12();
+  router.post("/", async (req, res) => {
+    const body = req.body;
+    if (typeof body.from !== "string" || !body.from) {
+      res.status(400).json({ error: "from \u306F\u5FC5\u9808\u3067\u3059" });
+      return;
+    }
+    if (typeof body.to !== "string" || !body.to) {
+      res.status(400).json({ error: "to \u306F\u5FC5\u9808\u3067\u3059" });
+      return;
+    }
+    try {
+      const result = await renameSpec(specsDir, body.from, body.to);
+      const response = {
+        meta: result.meta,
+        rewrittenFiles: result.rewrittenFiles
+      };
+      res.json(response);
+    } catch (err) {
+      if (err instanceof SpecOpsError) {
+        res.status(err.status).json({ error: err.message });
+        return;
+      }
+      res.status(500).json({ error: String(err) });
+    }
+  });
+  return router;
+}
+function refsRouter(specsDir) {
+  const router = Router12();
+  router.get("/", async (req, res) => {
+    const id = req.query["id"];
+    if (typeof id !== "string" || !id) {
+      res.status(400).json({ error: "id \u30AF\u30A8\u30EA\u30D1\u30E9\u30E1\u30FC\u30BF\u30FC\u306F\u5FC5\u9808\u3067\u3059" });
+      return;
+    }
+    try {
+      const refs = await findRefs(specsDir, id);
+      const response = { refs };
+      res.json(response);
+    } catch (err) {
+      if (err instanceof SpecOpsError) {
+        res.status(err.status).json({ error: err.message });
+        return;
+      }
+      res.status(500).json({ error: String(err) });
+    }
+  });
+  return router;
+}
+
+// src/server/watcher.ts
+import chokidar from "chokidar";
+import path9 from "path";
+function normalizePath4(p) {
+  return p.split(path9.sep).join("/");
+}
+function pathToSpecId(specsDir, filePath) {
+  const rel = normalizePath4(path9.relative(specsDir, filePath));
+  if (rel.startsWith("_generators/")) return null;
+  if (!/\.mdx?$/.test(rel)) return null;
+  const parts = rel.split("/");
+  const filename = parts[parts.length - 1];
+  const slug = filename.replace(/\.mdx?$/, "");
+  const category = parts.length > 1 ? parts.slice(0, -1).join("/") : "";
+  return category === "" ? slug : `${category}:${slug}`;
+}
+function broadcast(wss, message) {
+  const data = JSON.stringify(message);
+  wss.clients.forEach((client) => {
+    if (client.readyState === 1) {
+      client.send(data);
+    }
+  });
+}
+function startWatcher(specsDir, wss) {
+  const watcher = chokidar.watch(specsDir, {
+    ignoreInitial: true,
+    ignored: /(^|[/\\])\../,
+    awaitWriteFinish: {
+      stabilityThreshold: 150,
+      pollInterval: 50
+    }
+  });
+  function handler(event) {
+    return (filePath) => {
+      const rel = normalizePath4(path9.relative(specsDir, filePath));
+      const isUserComponent = rel.startsWith("_components/") && /\.(tsx|jsx)$/.test(rel);
+      const isExcalidraw = rel.endsWith(".excalidraw");
+      if (!/\.mdx?$/.test(rel) && !isUserComponent && !isExcalidraw) return;
+      const specId = isUserComponent || isExcalidraw ? null : pathToSpecId(specsDir, filePath);
+      const msg = {
+        type: "fs",
+        event,
+        specId,
+        path: rel
+      };
+      broadcast(wss, msg);
+    };
+  }
+  watcher.on("add", handler("add"));
+  watcher.on("change", handler("change"));
+  watcher.on("unlink", handler("unlink"));
+  return () => {
+    watcher.close();
+  };
+}
+
+// src/server/app.ts
+function createServer(options) {
+  const { specsDir } = options;
+  const app = express();
+  app.use(express.json());
+  app.use("/api/specs", specsRouter(specsDir));
+  app.use("/api/categories", categoriesRouter(specsDir));
+  app.use("/api/data", dataRouter(specsDir));
+  app.use("/api/graph", graphRouter(specsDir));
+  app.use("/api/generators", generatorsRouter(specsDir));
+  app.use("/api/generate", generateRouter(specsDir));
+  app.use("/api/search", searchRouter(specsDir));
+  app.use("/api/components", componentsRouter(specsDir));
+  app.use("/api/validation", validationRouter(specsDir));
+  app.use("/api/schema", schemaRouter(specsDir));
+  app.use("/api/drawings", drawingsRouter(specsDir));
+  app.use("/api/lint", lintRouter(specsDir));
+  app.use("/api/rename", renameRouter(specsDir));
+  app.use("/api/refs", refsRouter(specsDir));
+  const clientDir = fileURLToPath(new URL("../client", import.meta.url));
+  const indexHtml = path10.join(clientDir, "index.html");
+  const clientExists = fs8.existsSync(clientDir);
+  if (clientExists) {
+    app.use(express.static(clientDir));
+  }
+  app.get(/^(?!\/api|\/ws).*/, (_req, res) => {
+    if (fs8.existsSync(indexHtml)) {
+      res.sendFile(indexHtml);
+    } else {
+      res.status(503).send(
+        "\u30AF\u30E9\u30A4\u30A2\u30F3\u30C8\u306E\u30D3\u30EB\u30C9\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002npm run build \u3092\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+      );
+    }
+  });
+  const server = http.createServer(app);
+  const wss = new WebSocketServer({ server, path: "/ws" });
+  const stopWatcher = startWatcher(specsDir, wss);
+  const close = () => {
+    stopWatcher();
+    wss.close();
+    server.close();
+  };
+  return { server, close };
+}
+function startServer(options) {
+  return new Promise((resolve, reject) => {
+    let srv;
+    try {
+      srv = createServer(options);
+    } catch (err) {
+      reject(err);
+      return;
+    }
+    srv.server.listen(options.port, () => {
+      resolve(srv);
+    });
+    srv.server.on("error", reject);
+  });
+}
+
+// src/server/init.ts
+import fs9 from "fs/promises";
+import path11 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+async function copyDir(src, dest) {
+  await fs9.mkdir(dest, { recursive: true });
+  const entries = await fs9.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path11.join(src, entry.name);
+    const destPath = path11.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      await copyDir(srcPath, destPath);
+    } else if (entry.isFile()) {
+      await fs9.copyFile(srcPath, destPath);
+    }
+  }
+}
+async function isDirEmpty(dir) {
+  try {
+    const entries = await fs9.readdir(dir);
+    return entries.length === 0;
+  } catch {
+    return true;
+  }
+}
+async function dirExists(dir) {
+  try {
+    const stat = await fs9.stat(dir);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function initSpecs(targetDir) {
+  if (await dirExists(targetDir)) {
+    const empty = await isDirEmpty(targetDir);
+    if (!empty) {
+      throw new Error(
+        `"${targetDir}" \u306F\u65E2\u306B\u5B58\u5728\u3057\u3001\u7A7A\u3067\u306F\u3042\u308A\u307E\u305B\u3093\u3002
+\u5225\u306E\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u30FC\u3092\u6307\u5B9A\u3059\u308B\u304B\u3001\u624B\u52D5\u3067\u524A\u9664\u3057\u3066\u304F\u3060\u3055\u3044\u3002`
+      );
+    }
+  }
+  const examplesDir = fileURLToPath2(new URL("../../examples/specs", import.meta.url));
+  try {
+    await fs9.access(examplesDir);
+  } catch {
+    throw new Error(
+      `\u30B5\u30F3\u30D7\u30EB\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u30FC\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${examplesDir}
+\u30D3\u30EB\u30C9\u304C\u5B8C\u4E86\u3057\u3066\u3044\u308B\u304B\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044\u3002`
+    );
+  }
+  await copyDir(examplesDir, targetDir);
+}
+
+// src/server/mcp.ts
+import fs10 from "fs/promises";
+import path12 from "path";
+import matter4 from "gray-matter";
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+function ok(result) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+  };
+}
+function fail(message) {
+  return {
+    content: [{ type: "text", text: message }],
+    isError: true
+  };
+}
+function errMessage(err) {
+  if (err instanceof SpecOpsError) return err.message;
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+function resolveMdxPath(specsDir, category, slug) {
+  const parts = category === "" ? [] : category.split("/");
+  const target = path12.join(specsDir, ...parts, `${slug}.mdx`);
+  if (!guardPath(specsDir, target)) return null;
+  return target;
+}
+async function findMeta(specsDir, id) {
+  const specs = await loadSpecs(specsDir);
+  return specs.find((s) => s.id === id) ?? null;
+}
+async function startMcpServer(specsDir) {
+  const server = new McpServer({ name: "specifian", version: "0.1.0" });
+  server.registerTool(
+    "list_specs",
+    {
+      description: 'specs \u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u30FC\u5185\u306E\u5168\u30B9\u30DA\u30C3\u30AF\u306E\u30E1\u30BF\u60C5\u5831 (SpecMeta[]) \u3092\u8FD4\u3057\u307E\u3059\u3002\u5404\u8981\u7D20\u306B\u306F id ("category:slug" \u5F62\u5F0F)\u3001category\u3001slug\u3001path\u3001title\u3001description\u3001front-matter \u5168\u4F53 (data)\u3001\u672C\u6587\u4E2D\u306E wiki \u30EA\u30F3\u30AF\u5148 ID (links)\u3001isIndex \u304C\u542B\u307E\u308C\u307E\u3059\u3002_template \u306F\u9664\u5916\u3055\u308C\u307E\u3059\u3002',
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const specs = await loadSpecs(specsDir);
+        return ok(specs.filter((s) => s.slug !== "_template"));
+      } catch (err) {
+        return fail(errMessage(err));
+      }
+    }
+  );
+  server.registerTool(
+    "read_spec",
+    {
+      description: '\u6307\u5B9A\u3057\u305F\u30B9\u30DA\u30C3\u30AF\u306E meta \u3068 content \u3092\u8FD4\u3057\u307E\u3059\u3002id \u306F "category:slug" \u5F62\u5F0F (\u4F8B: "tables:users"\u3001\u30A4\u30F3\u30C7\u30C3\u30AF\u30B9\u306F "tables:_")\u3002content \u306F front-matter \u3092\u542B\u3080\u751F\u306E MDX \u5168\u6587\u3067\u3059\u3002\u5B58\u5728\u3057\u306A\u3044\u5834\u5408\u306F\u30A8\u30E9\u30FC\u306B\u306A\u308A\u307E\u3059\u3002',
+      inputSchema: {
+        id: z.string().describe('\u30B9\u30DA\u30C3\u30AF ID\u3002"category:slug" \u5F62\u5F0F (\u4F8B: "tables:users")')
+      }
+    },
+    async ({ id }) => {
+      const parsed = parseSpecId(id);
+      if (!parsed) return fail(`\u7121\u52B9\u306A\u30B9\u30DA\u30C3\u30AF ID: ${id}`);
+      const target = resolveMdxPath(specsDir, parsed.category, parsed.slug);
+      if (!target) return fail("\u30D1\u30B9\u30C8\u30E9\u30D0\u30FC\u30B5\u30EB\u306F\u8A31\u53EF\u3055\u308C\u3066\u3044\u307E\u305B\u3093");
+      const result = await loadSpec(specsDir, target);
+      if (!result) return fail(`\u30B9\u30DA\u30C3\u30AF\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${id}`);
+      return ok(result);
+    }
+  );
+  server.registerTool(
+    "write_spec",
+    {
+      description: '\u65E2\u5B58\u30B9\u30DA\u30C3\u30AF\u306E\u5185\u5BB9\u3092\u4E0A\u66F8\u304D\u4FDD\u5B58\u3057\u307E\u3059\u3002id \u306F "category:slug" \u5F62\u5F0F\u3002content \u306F front-matter \u3092\u542B\u3080 MDX \u5168\u6587\u3002\u5BFE\u8C61\u304C\u5B58\u5728\u3057\u306A\u3044\u5834\u5408\u306F\u30A8\u30E9\u30FC\u306B\u306A\u308A\u307E\u3059 (\u65B0\u898F\u4F5C\u6210\u306F create_spec \u3092\u4F7F\u3063\u3066\u304F\u3060\u3055\u3044)\u3002\u4FDD\u5B58\u5F8C\u306B lint \u3092\u5B9F\u884C\u3057\u3001{ meta, issues } \u3092\u8FD4\u3057\u307E\u3059 (issues \u306F\u60C5\u5831\u63D0\u4F9B\u3067\u3042\u308A\u3001\u4FDD\u5B58\u81EA\u4F53\u306F\u5E38\u306B\u5B9F\u884C\u3055\u308C\u307E\u3059)\u3002',
+      inputSchema: {
+        id: z.string().describe('\u4E0A\u66F8\u304D\u3059\u308B\u65E2\u5B58\u30B9\u30DA\u30C3\u30AF\u306E ID\u3002"category:slug" \u5F62\u5F0F'),
+        content: z.string().describe("front-matter \u3092\u542B\u3080 MDX \u5168\u6587 (\u30D5\u30A1\u30A4\u30EB\u5168\u4F53\u3092\u7F6E\u304D\u63DB\u3048\u307E\u3059)")
+      }
+    },
+    async ({ id, content }) => {
+      const parsed = parseSpecId(id);
+      if (!parsed) return fail(`\u7121\u52B9\u306A\u30B9\u30DA\u30C3\u30AF ID: ${id}`);
+      const target = resolveMdxPath(specsDir, parsed.category, parsed.slug);
+      if (!target) return fail("\u30D1\u30B9\u30C8\u30E9\u30D0\u30FC\u30B5\u30EB\u306F\u8A31\u53EF\u3055\u308C\u3066\u3044\u307E\u305B\u3093");
+      try {
+        await fs10.access(target);
+      } catch {
+        return fail(
+          `\u30B9\u30DA\u30C3\u30AF\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${id}\u3002\u65B0\u898F\u4F5C\u6210\u306F create_spec \u3092\u4F7F\u3063\u3066\u304F\u3060\u3055\u3044\u3002`
+        );
+      }
+      try {
+        await fs10.writeFile(target, content, "utf-8");
+      } catch (err) {
+        return fail(`\u4FDD\u5B58\u306B\u5931\u6557\u3057\u307E\u3057\u305F: ${errMessage(err)}`);
+      }
+      const meta = await findMeta(specsDir, id);
+      let issues;
+      try {
+        issues = await lintContent(specsDir, {
+          content,
+          category: parsed.category,
+          slug: parsed.slug
+        });
+      } catch (lintErr) {
+        console.error("[mcp] lintContent \u5931\u6557 (\u7121\u8996):", lintErr);
+        issues = [];
+      }
+      return ok({ meta, issues });
+    }
+  );
+  server.registerTool(
+    "create_spec",
+    {
+      description: '\u65B0\u898F\u30B9\u30DA\u30C3\u30AF\u3092\u4F5C\u6210\u3057\u307E\u3059 (POST /api/specs \u3068\u540C\u3058\u610F\u5473\u8AD6)\u3002category \u306F\u30AB\u30C6\u30B4\u30EA\u30FC\u30D1\u30B9 ("/" \u533A\u5207\u308A\u3001\u4F8B: "tables" \u3084 "api/v1")\u3001slug \u306F\u30D5\u30A1\u30A4\u30EB\u540D (\u62E1\u5F35\u5B50\u306A\u3057)\u3002\u30AB\u30C6\u30B4\u30EA\u30FC\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u30FC\u306F\u4E8B\u524D\u306B\u5B58\u5728\u3057\u3066\u3044\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002\u540C\u540D\u30B9\u30DA\u30C3\u30AF\u304C\u65E2\u306B\u5B58\u5728\u3059\u308B\u5834\u5408\u306F\u30A8\u30E9\u30FC\u306B\u306A\u308A\u307E\u3059\u3002\u30AB\u30C6\u30B4\u30EA\u30FC\u5185\u306B _template.mdx \u304C\u3042\u308C\u3070\u305D\u308C\u3092\u30B3\u30D4\u30FC\u3057 front-matter \u306E title \u3092\u7F6E\u304D\u63DB\u3048\u307E\u3059\u3002\u7121\u3051\u308C\u3070\u6700\u5C0F\u30C6\u30F3\u30D7\u30EC\u30FC\u30C8 (title + \u898B\u51FA\u3057) \u3092\u751F\u6210\u3057\u307E\u3059\u3002\u623B\u308A\u5024\u306F { meta }\u3002',
+      inputSchema: {
+        category: z.string().describe('\u30AB\u30C6\u30B4\u30EA\u30FC\u30D1\u30B9 ("/" \u533A\u5207\u308A\u3002\u30EB\u30FC\u30C8\u76F4\u4E0B\u306F\u7A7A\u6587\u5B57)\u3002\u4F8B: "tables"'),
+        slug: z.string().describe('\u30B9\u30DA\u30C3\u30AF\u306E\u30D5\u30A1\u30A4\u30EB\u540D (\u62E1\u5F35\u5B50\u306A\u3057)\u3002\u4F8B: "users"'),
+        title: z.string().optional().describe("front-matter \u306E title\u3002\u7701\u7565\u6642\u306F slug \u304C\u4F7F\u308F\u308C\u307E\u3059")
+      }
+    },
+    async ({ category, slug, title }) => {
+      if (!slug) return fail("slug \u306F\u5FC5\u9808\u3067\u3059");
+      const cat = category ?? "";
+      const effectiveTitle = title ?? slug;
+      const target = resolveMdxPath(specsDir, cat, slug);
+      if (!target) return fail("\u30D1\u30B9\u30C8\u30E9\u30D0\u30FC\u30B5\u30EB\u306F\u8A31\u53EF\u3055\u308C\u3066\u3044\u307E\u305B\u3093");
+      const categoryParts = cat === "" ? [] : cat.split("/");
+      const categoryDir = path12.join(specsDir, ...categoryParts);
+      try {
+        const stat = await fs10.stat(categoryDir);
+        if (!stat.isDirectory()) {
+          return fail(`\u30AB\u30C6\u30B4\u30EA\u30FC\u304C\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u30FC\u3067\u306F\u3042\u308A\u307E\u305B\u3093: ${cat}`);
+        }
+      } catch {
+        return fail(`\u30AB\u30C6\u30B4\u30EA\u30FC\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u30FC\u304C\u5B58\u5728\u3057\u307E\u305B\u3093: ${cat || "(\u30EB\u30FC\u30C8)"}`);
+      }
+      try {
+        await fs10.access(target);
+        return fail(`"${slug}" \u306F\u65E2\u306B\u5B58\u5728\u3057\u307E\u3059`);
+      } catch {
+      }
+      let content;
+      const templatePath = path12.join(categoryDir, "_template.mdx");
+      try {
+        const templateContent = await fs10.readFile(templatePath, "utf-8");
+        const parsed = matter4(templateContent);
+        parsed.data["title"] = effectiveTitle;
+        content = matter4.stringify(parsed.content, parsed.data);
+      } catch {
+        content = `---
+title: ${effectiveTitle}
+---
+
+# ${effectiveTitle}
+`;
+      }
+      try {
+        await fs10.writeFile(target, content, "utf-8");
+      } catch (err) {
+        return fail(`\u4F5C\u6210\u306B\u5931\u6557\u3057\u307E\u3057\u305F: ${errMessage(err)}`);
+      }
+      const id = toSpecId(cat, slug);
+      const meta = await findMeta(specsDir, id);
+      if (!meta) return fail("\u4F5C\u6210\u5F8C\u306E\u30B9\u30DA\u30C3\u30AF\u8AAD\u307F\u8FBC\u307F\u306B\u5931\u6557\u3057\u307E\u3057\u305F");
+      return ok({ meta });
+    }
+  );
+  server.registerTool(
+    "rename_spec",
+    {
+      description: '\u30B9\u30DA\u30C3\u30AF\u306E\u30D5\u30A1\u30A4\u30EB\u540D\u3092\u5909\u66F4\u3057\u3001\u4ED6\u306E\u5168\u30B9\u30DA\u30C3\u30AF\u306E wiki \u30EA\u30F3\u30AF [[from]] / [[from|\u30E9\u30D9\u30EB]] \u3092\u4E00\u62EC\u3067 [[to]] \u3078\u66F8\u304D\u63DB\u3048\u307E\u3059 (\u30B3\u30FC\u30C9\u30D5\u30A7\u30F3\u30B9\u30FB\u30A4\u30F3\u30E9\u30A4\u30F3\u30B3\u30FC\u30C9\u5185\u306F\u5909\u66F4\u3057\u307E\u305B\u3093)\u3002from / to \u306F\u3068\u3082\u306B "category:slug" \u5F62\u5F0F\u306E\u30B9\u30DA\u30C3\u30AF ID\u3002to \u306E\u30AB\u30C6\u30B4\u30EA\u30FC\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u30FC\u306F\u5B58\u5728\u3057\u3066\u3044\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002\u30A4\u30F3\u30C7\u30C3\u30AF\u30B9 (slug "_") / \u30C6\u30F3\u30D7\u30EC\u30FC\u30C8 (slug "_template") \u306F\u30EA\u30CD\u30FC\u30E0\u3067\u304D\u307E\u305B\u3093\u3002\u623B\u308A\u5024\u306F { meta, rewrittenFiles } (rewrittenFiles \u306F\u5B9F\u969B\u306B\u30EA\u30F3\u30AF\u3092\u66F8\u304D\u63DB\u3048\u305F\u30B9\u30DA\u30C3\u30AF ID \u4E00\u89A7)\u3002',
+      inputSchema: {
+        from: z.string().describe('\u5909\u66F4\u5143\u30B9\u30DA\u30C3\u30AF ID\u3002"category:slug" \u5F62\u5F0F'),
+        to: z.string().describe('\u5909\u66F4\u5148\u30B9\u30DA\u30C3\u30AF ID\u3002"category:slug" \u5F62\u5F0F')
+      }
+    },
+    async ({ from, to }) => {
+      try {
+        const result = await renameSpec(specsDir, from, to);
+        return ok(result);
+      } catch (err) {
+        return fail(errMessage(err));
+      }
+    }
+  );
+  server.registerTool(
+    "delete_spec",
+    {
+      description: '\u30B9\u30DA\u30C3\u30AF\u3092\u524A\u9664\u3057\u307E\u3059\u3002id \u306F "category:slug" \u5F62\u5F0F\u3002\u524A\u9664\u524D\u306B\u53C2\u7167\u5143 (\u3053\u306E ID \u3092 wiki \u30EA\u30F3\u30AF\u3057\u3066\u3044\u308B\u30B9\u30DA\u30C3\u30AF) \u3092\u8ABF\u3079\u3001\u623B\u308A\u5024 { ok: true, brokenRefs } \u3067\u300C\u58CA\u308C\u305F\u53C2\u7167\u300D\u3092\u901A\u77E5\u3057\u307E\u3059\u3002brokenRefs \u304C\u975E\u7A7A\u306E\u5834\u5408\u3001\u305D\u308C\u3089\u306E\u30B9\u30DA\u30C3\u30AF\u306F\u672A\u89E3\u6C7A\u30EA\u30F3\u30AF\u3092\u62B1\u3048\u308B\u3053\u3068\u306B\u306A\u308A\u307E\u3059\u3002\u30A4\u30F3\u30C7\u30C3\u30AF\u30B9 (slug "_") \u3084\u30C6\u30F3\u30D7\u30EC\u30FC\u30C8\u3082\u524A\u9664\u53EF\u80FD\u3067\u3059\u3002',
+      inputSchema: {
+        id: z.string().describe('\u524A\u9664\u3059\u308B\u30B9\u30DA\u30C3\u30AF ID\u3002"category:slug" \u5F62\u5F0F')
+      }
+    },
+    async ({ id }) => {
+      try {
+        const refs = await findRefs(specsDir, id);
+        await deleteSpec(specsDir, id);
+        return ok({ ok: true, brokenRefs: refs });
+      } catch (err) {
+        return fail(errMessage(err));
+      }
+    }
+  );
+  server.registerTool(
+    "get_refs",
+    {
+      description: '\u6307\u5B9A ID \u3092 wiki \u30EA\u30F3\u30AF\u3067\u53C2\u7167\u3057\u3066\u3044\u308B\u30B9\u30DA\u30C3\u30AF ID \u4E00\u89A7 ({ refs }) \u3092\u8FD4\u3057\u307E\u3059\u3002id \u306F "category:slug" \u5F62\u5F0F\u3002\u30D0\u30C3\u30AF\u30EA\u30F3\u30AF\u78BA\u8A8D\u3084\u524A\u9664\u5F71\u97FF\u7BC4\u56F2\u306E\u8ABF\u67FB\u306B\u4F7F\u3044\u307E\u3059\u3002',
+      inputSchema: {
+        id: z.string().describe('\u53C2\u7167\u5143\u3092\u8ABF\u3079\u305F\u3044\u30B9\u30DA\u30C3\u30AF ID\u3002"category:slug" \u5F62\u5F0F')
+      }
+    },
+    async ({ id }) => {
+      try {
+        const refs = await findRefs(specsDir, id);
+        return ok({ refs });
+      } catch (err) {
+        return fail(errMessage(err));
+      }
+    }
+  );
+  server.registerTool(
+    "search",
+    {
+      description: "\u30B9\u30DA\u30C3\u30AF\u3092\u5168\u6587\u691C\u7D22\u3057\u307E\u3059\u3002title > description > front-matter (data) > \u672C\u6587 \u306E\u512A\u5148\u9806\u3067\u30DE\u30C3\u30C1\u3057\u3001\u5404\u30D2\u30C3\u30C8\u306B snippet (\u524D\u5F8C\u306E\u6587\u8108\u4ED8\u304D\u629C\u7C8B) \u3068 field (\u30DE\u30C3\u30C1\u7B87\u6240) \u304C\u4ED8\u304D\u307E\u3059\u3002_template \u306F\u691C\u7D22\u5BFE\u8C61\u5916\u3002\u623B\u308A\u5024\u306F SearchResult[]\u3002",
+      inputSchema: {
+        query: z.string().describe("\u691C\u7D22\u30AF\u30A8\u30EA\u30FC\u6587\u5B57\u5217 (\u5927\u6587\u5B57\u5C0F\u6587\u5B57\u3092\u533A\u5225\u3057\u307E\u305B\u3093)"),
+        limit: z.number().int().positive().optional().describe("\u6700\u5927\u8FD4\u5374\u4EF6\u6570\u3002\u7701\u7565\u6642\u306F 20")
+      }
+    },
+    async ({ query, limit }) => {
+      try {
+        const results = await searchSpecs(specsDir, query, limit ?? 20);
+        return ok(results);
+      } catch (err) {
+        return fail(errMessage(err));
+      }
+    }
+  );
+  server.registerTool(
+    "get_data",
+    {
+      description: "\u30B9\u30DA\u30C3\u30AF\u306E front-matter (data) \u3092\u307E\u3068\u3081\u3066\u8FD4\u3057\u307E\u3059\u3002category \u3092\u7701\u7565\u3057\u305F\u5834\u5408\u306F { category: { slug: data } } \u306E\u30CD\u30B9\u30C8\u69CB\u9020 (\u5168\u30AB\u30C6\u30B4\u30EA\u30FC)\u3002category \u3092\u6307\u5B9A\u3057\u305F\u5834\u5408\u306F\u305D\u306E\u30AB\u30C6\u30B4\u30EA\u30FC\u306E { slug: data } \u306E\u307F\u3002_template \u306F\u9664\u5916\u3055\u308C\u307E\u3059\u3002\u30C6\u30FC\u30D6\u30EB\u5B9A\u7FA9\u4E00\u89A7\u306E\u53D6\u5F97\u306A\u3069\u306B\u4FBF\u5229\u3067\u3059\u3002",
+      inputSchema: {
+        category: z.string().optional().describe('\u30AB\u30C6\u30B4\u30EA\u30FC\u30D1\u30B9 ("/" \u533A\u5207\u308A)\u3002\u7701\u7565\u6642\u306F\u5168\u30AB\u30C6\u30B4\u30EA\u30FC')
+      }
+    },
+    async ({ category }) => {
+      try {
+        const specs = await loadSpecs(specsDir);
+        const filtered = specs.filter((s) => s.slug !== "_template");
+        if (category === void 0) {
+          const result2 = {};
+          for (const spec of filtered) {
+            const cat2 = spec.category;
+            if (!result2[cat2]) result2[cat2] = {};
+            result2[cat2][spec.slug] = spec.data;
+          }
+          return ok(result2);
+        }
+        const cat = category.split("/").filter(Boolean).join("/");
+        const result = {};
+        for (const spec of filtered) {
+          if (spec.category === cat) result[spec.slug] = spec.data;
+        }
+        return ok(result);
+      } catch (err) {
+        return fail(errMessage(err));
+      }
+    }
+  );
+  server.registerTool(
+    "validate",
+    {
+      description: "_schema.json \u3092\u6301\u3064\u30AB\u30C6\u30B4\u30EA\u30FC\u306B\u3064\u3044\u3066\u3001\u5168\u30B9\u30DA\u30C3\u30AF\u306E front-matter \u3092 JSON Schema (ajv) \u3067\u691C\u8A3C\u3057\u3001\u9055\u53CD\u4E00\u89A7 (ValidationReport { issues }) \u3092\u8FD4\u3057\u307E\u3059\u3002issues \u304C\u7A7A\u306A\u3089\u5168\u4EF6\u9069\u5408\u3067\u3059\u3002",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const report = await validateSpecs(specsDir);
+        return ok(report);
+      } catch (err) {
+        return fail(errMessage(err));
+      }
+    }
+  );
+  server.registerTool(
+    "lint",
+    {
+      description: "\u4FDD\u5B58\u305B\u305A\u306B MDX \u5168\u6587\u3092\u691C\u8A3C\u3057\u3001issues (LintIssue[]) \u3092\u8FD4\u3057\u307E\u3059\u3002\u30C1\u30A7\u30C3\u30AF\u5185\u5BB9: YAML \u30D1\u30FC\u30B9 / MDX \u69CB\u6587 / wiki \u30EA\u30F3\u30AF\u89E3\u6C7A / (category \u6307\u5B9A\u6642) \u30B9\u30AD\u30FC\u30DE\u691C\u8A3C\u3002content \u306F front-matter \u3092\u542B\u3080 MDX \u5168\u6587\u3002category/slug \u3092\u6E21\u3059\u3068\u30B9\u30AD\u30FC\u30DE\u691C\u8A3C\u3082\u884C\u308F\u308C\u307E\u3059\u3002\u4FDD\u5B58\u524D\u306E\u4E8B\u524D\u30C1\u30A7\u30C3\u30AF\u306B\u4F7F\u3063\u3066\u304F\u3060\u3055\u3044\u3002",
+      inputSchema: {
+        content: z.string().describe("front-matter \u3092\u542B\u3080 MDX \u5168\u6587"),
+        category: z.string().optional().describe("\u30B9\u30AD\u30FC\u30DE\u691C\u8A3C\u306B\u4F7F\u3046\u30AB\u30C6\u30B4\u30EA\u30FC\u3002\u7701\u7565\u6642\u306F\u30B9\u30AD\u30FC\u30DE\u691C\u8A3C\u3092\u30B9\u30AD\u30C3\u30D7"),
+        slug: z.string().optional().describe('\u5BFE\u8C61 slug\u3002"_" / "_template" \u306F\u30B9\u30AD\u30FC\u30DE\u691C\u8A3C\u5BFE\u8C61\u5916\u306B\u306A\u308A\u307E\u3059')
+      }
+    },
+    async ({ content, category, slug }) => {
+      try {
+        const issues = await lintContent(specsDir, { content, category, slug });
+        return ok({ issues });
+      } catch (err) {
+        return fail(errMessage(err));
+      }
+    }
+  );
+  server.registerTool(
+    "list_generators",
+    {
+      description: "specs/_generators/ \u914D\u4E0B\u306E\u30B3\u30FC\u30C9\u30B8\u30A7\u30CD\u30EC\u30FC\u30BF\u30FC\u540D\u4E00\u89A7 (string[]) \u3092\u8FD4\u3057\u307E\u3059\u3002generate \u30C4\u30FC\u30EB\u306E generator \u5F15\u6570\u306B\u4F7F\u3048\u307E\u3059\u3002",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const generators = await listGenerators(specsDir);
+        return ok(generators);
+      } catch (err) {
+        return fail(errMessage(err));
+      }
+    }
+  );
+  server.registerTool(
+    "generate",
+    {
+      description: '\u30B3\u30FC\u30C9\u30B8\u30A7\u30CD\u30EC\u30FC\u30BF\u30FC\u3092\u5B9F\u884C\u3057\u307E\u3059\u3002generator \u306F list_generators \u3067\u5F97\u3089\u308C\u308B\u540D\u524D\u3002specId ("category:slug") \u3092\u6307\u5B9A\u3059\u308B\u3068\u305D\u306E\u30B9\u30DA\u30C3\u30AF\u306E\u307F\u3001\u7701\u7565\u6642\u306F\u5168\u30B9\u30DA\u30C3\u30AF\u304C\u5BFE\u8C61\u3002out \u3092\u6307\u5B9A\u3059\u308B\u3068\u30D7\u30ED\u30BB\u30B9\u306E cwd \u76F8\u5BFE\u3067\u30D5\u30A1\u30A4\u30EB\u3092\u30C7\u30A3\u30B9\u30AF\u306B\u66F8\u304D\u51FA\u3057\u307E\u3059 (\u7701\u7565\u6642\u306F\u66F8\u304D\u8FBC\u307E\u305A\u30EC\u30B9\u30DD\u30F3\u30B9\u306E\u307F)\u3002\u623B\u308A\u5024\u306F { files: { path, content }[] }\u3002',
+      inputSchema: {
+        generator: z.string().describe("\u30B8\u30A7\u30CD\u30EC\u30FC\u30BF\u30FC\u540D (specs/_generators/<name>.md)"),
+        specId: z.string().optional().describe('\u5BFE\u8C61\u30B9\u30DA\u30C3\u30AF ID\u3002"category:slug" \u5F62\u5F0F\u3002\u7701\u7565\u6642\u306F\u5168\u30B9\u30DA\u30C3\u30AF'),
+        out: z.string().optional().describe("\u51FA\u529B\u5148\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u30FC (cwd \u76F8\u5BFE)\u3002\u7701\u7565\u6642\u306F\u30C7\u30A3\u30B9\u30AF\u306B\u66F8\u304D\u8FBC\u307F\u307E\u305B\u3093")
+      }
+    },
+    async ({ generator, specId, out }) => {
+      try {
+        const allSpecs = await loadSpecs(specsDir);
+        const files = await runGenerator(
+          specsDir,
+          generator,
+          allSpecs,
+          specId,
+          out
+        );
+        return ok({ files });
+      } catch (err) {
+        return fail(errMessage(err));
+      }
+    }
+  );
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  await new Promise((resolve) => {
+    transport.onclose = () => resolve();
+  });
+}
+
+// src/cli/index.ts
+var VERSION = "0.1.0";
+program.name("specifian").version(VERSION).description("Storybook \u30E9\u30A4\u30AF\u306A MDX \u30B9\u30DA\u30C3\u30AF\u7BA1\u7406\u30C4\u30FC\u30EB");
+program.command("serve", { isDefault: true }).description("\u30B9\u30DA\u30C3\u30AF\u30B5\u30FC\u30D0\u30FC\u3092\u8D77\u52D5\u3057\u307E\u3059").option("--dir <specsDir>", "\u30B9\u30DA\u30C3\u30AF\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u30FC", "./specs").option("--port <port>", "\u30DD\u30FC\u30C8\u756A\u53F7", "4400").option("--open", "\u30D6\u30E9\u30A6\u30B6\u30FC\u3092\u81EA\u52D5\u7684\u306B\u958B\u304F", false).action(async (opts) => {
+  const specsDir = path13.resolve(opts.dir);
+  const port = parseInt(opts.port, 10);
+  if (!fs11.existsSync(specsDir)) {
+    console.error(
+      `\u30A8\u30E9\u30FC: \u30B9\u30DA\u30C3\u30AF\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u30FC\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${specsDir}`
+    );
+    console.error("\u30D2\u30F3\u30C8: specifian init --dir <\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u30FC> \u3067\u521D\u671F\u5316\u3067\u304D\u307E\u3059\u3002");
+    process.exit(1);
+  }
+  console.log(`
+\u{1F5D2}  specifian v${VERSION}`);
+  console.log(`\u{1F4C2} \u30B9\u30DA\u30C3\u30AF\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u30FC: ${specsDir}`);
+  console.log(`\u{1F680} \u30B5\u30FC\u30D0\u30FC\u3092\u8D77\u52D5\u3057\u3066\u3044\u307E\u3059... http://localhost:${port}
+`);
+  try {
+    await startServer({ specsDir, port });
+    console.log(`\u2705 \u30B5\u30FC\u30D0\u30FC\u8D77\u52D5\u5B8C\u4E86: http://localhost:${port}`);
+    if (opts.open) {
+      const { default: open } = await import("open");
+      await open(`http://localhost:${port}`);
+    }
+  } catch (err) {
+    console.error("\u30B5\u30FC\u30D0\u30FC\u306E\u8D77\u52D5\u306B\u5931\u6557\u3057\u307E\u3057\u305F:", err);
+    process.exit(1);
+  }
+});
+program.command("init").description("\u30B5\u30F3\u30D7\u30EB\u30B9\u30DA\u30C3\u30AF\u3092\u4F7F\u3063\u3066\u521D\u671F\u5316\u3057\u307E\u3059").option("--dir <specsDir>", "\u521D\u671F\u5316\u5148\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u30FC", "./specs").action(async (opts) => {
+  const targetDir = path13.resolve(opts.dir);
+  console.log(`\u{1F4C2} \u521D\u671F\u5316\u5148: ${targetDir}`);
+  try {
+    await initSpecs(targetDir);
+    console.log(`\u2705 \u521D\u671F\u5316\u5B8C\u4E86: ${targetDir}`);
+    console.log("\u6B21\u306E\u30B3\u30DE\u30F3\u30C9\u3067\u30B5\u30FC\u30D0\u30FC\u3092\u8D77\u52D5\u3067\u304D\u307E\u3059:");
+    console.log(`  specifian serve --dir ${opts.dir}`);
+  } catch (err) {
+    console.error("\u521D\u671F\u5316\u306B\u5931\u6557\u3057\u307E\u3057\u305F:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+program.command("generate <generator>").description("\u30B3\u30FC\u30C9\u751F\u6210\u30C6\u30F3\u30D7\u30EC\u30FC\u30C8\u3092\u5B9F\u884C\u3057\u307E\u3059").option("--dir <specsDir>", "\u30B9\u30DA\u30C3\u30AF\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u30FC", "./specs").option("--spec <specId>", "\u5BFE\u8C61\u30B9\u30DA\u30C3\u30AF ID (\u7701\u7565\u6642\u306F\u5168\u30B9\u30DA\u30C3\u30AF)").option("--out <outDir>", "\u51FA\u529B\u5148\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u30FC", ".").action(
+  async (generator, opts) => {
+    const specsDir = path13.resolve(opts.dir);
+    if (!fs11.existsSync(specsDir)) {
+      console.error(
+        `\u30A8\u30E9\u30FC: \u30B9\u30DA\u30C3\u30AF\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u30FC\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${specsDir}`
+      );
+      process.exit(1);
+    }
+    try {
+      const allSpecs = await loadSpecs(specsDir);
+      const files = await runGenerator(
+        specsDir,
+        generator,
+        allSpecs,
+        opts.spec,
+        opts.out
+      );
+      if (files.length === 0) {
+        console.log("\u751F\u6210\u3055\u308C\u305F\u30D5\u30A1\u30A4\u30EB\u306F\u3042\u308A\u307E\u305B\u3093\u3002");
+      } else {
+        console.log(`\u2705 ${files.length} \u4EF6\u306E\u30D5\u30A1\u30A4\u30EB\u3092\u751F\u6210\u3057\u307E\u3057\u305F:`);
+        for (const f of files) {
+          console.log(`  ${f.path}`);
+        }
+      }
+    } catch (err) {
+      console.error(
+        "\u30B3\u30FC\u30C9\u751F\u6210\u306B\u5931\u6557\u3057\u307E\u3057\u305F:",
+        err instanceof Error ? err.message : err
+      );
+      process.exit(1);
+    }
+  }
+);
+program.command("validate").description("front-matter \u3092\u30B9\u30AD\u30FC\u30DE\u306B\u5BFE\u3057\u3066\u30D0\u30EA\u30C7\u30FC\u30B7\u30E7\u30F3\u3057\u307E\u3059").option("--dir <specsDir>", "\u30B9\u30DA\u30C3\u30AF\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u30FC", "./specs").action(async (opts) => {
+  const specsDir = path13.resolve(opts.dir);
+  if (!fs11.existsSync(specsDir)) {
+    console.error(
+      `\u30A8\u30E9\u30FC: \u30B9\u30DA\u30C3\u30AF\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u30FC\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${specsDir}`
+    );
+    process.exit(1);
+  }
+  try {
+    const report = await validateSpecs(specsDir);
+    if (report.issues.length === 0) {
+      console.log("\u2705 front-matter \u306F\u3059\u3079\u3066\u306E\u30B9\u30AD\u30FC\u30DE\u306B\u9069\u5408\u3057\u3066\u3044\u307E\u3059");
+      process.exit(0);
+    } else {
+      console.error(`\u274C \u30B9\u30AD\u30FC\u30DE\u9055\u53CD\u304C ${report.issues.length} \u4EF6\u898B\u3064\u304B\u308A\u307E\u3057\u305F:`);
+      for (const issue of report.issues) {
+        console.error(`  ${issue.specId} ${issue.path}: ${issue.message}`);
+      }
+      process.exit(1);
+    }
+  } catch (err) {
+    console.error(
+      "\u30D0\u30EA\u30C7\u30FC\u30B7\u30E7\u30F3\u306B\u5931\u6557\u3057\u307E\u3057\u305F:",
+      err instanceof Error ? err.message : err
+    );
+    process.exit(1);
+  }
+});
+program.command("mcp").description("MCP \u30B5\u30FC\u30D0\u30FC (stdio) \u3092\u8D77\u52D5\u3057\u307E\u3059\u3002AI \u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u304C\u30B9\u30DA\u30C3\u30AF\u3092\u8AAD\u307F\u66F8\u304D\u3067\u304D\u307E\u3059").option("--dir <specsDir>", "\u30B9\u30DA\u30C3\u30AF\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u30FC", "./specs").action(async (opts) => {
+  const specsDir = path13.resolve(opts.dir);
+  if (!fs11.existsSync(specsDir)) {
+    console.error(
+      `\u30A8\u30E9\u30FC: \u30B9\u30DA\u30C3\u30AF\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u30FC\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${specsDir}`
+    );
+    console.error("\u30D2\u30F3\u30C8: specifian init --dir <\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u30FC> \u3067\u521D\u671F\u5316\u3067\u304D\u307E\u3059\u3002");
+    process.exit(1);
+  }
+  console.error(`specifian MCP server (stdio) \u2014 specs: ${specsDir}`);
+  try {
+    await startMcpServer(specsDir);
+  } catch (err) {
+    console.error(
+      "MCP \u30B5\u30FC\u30D0\u30FC\u306E\u8D77\u52D5\u306B\u5931\u6557\u3057\u307E\u3057\u305F:",
+      err instanceof Error ? err.message : err
+    );
+    process.exit(1);
+  }
+});
+program.parse(process.argv);