@neuctra/ui-mcp 0.4.4 → 0.4.5

package/src/tools/get-neuctra-ui-component/index.mjs

@@ -0,0 +1,160 @@
+import { z } from "zod";
+
+const COMPONENT_CATEGORIES = [
+  "layout", "typography", "form", "actions", "data-display", "feedback", "overlay", "navigation",
+];
+
+const SYNONYMS = {
+  layouting: "layout container section grid",
+  layout: "layout container section grid",
+  form: "form input field select checkbox radio textarea",
+  forms: "form input field select checkbox radio textarea",
+  field: "input form field",
+  fields: "input form field",
+  image: "image media picture avatar",
+  images: "image media picture avatar",
+  carousel: "carousel slider slides",
+  carousels: "carousel slider slides",
+  slider: "carousel slider slides",
+  modal: "modal dialog overlay popup",
+  dialog: "modal dialog overlay popup",
+  dialogs: "modal dialog overlay popup",
+  drawer: "drawer panel sheet overlay",
+  drawers: "drawer panel sheet overlay",
+  card: "card panel surface",
+  cards: "card panel surface",
+};
+
+const STOP_WORDS = new Set(["a", "an", "and", "for", "i", "in", "it", "of", "on", "the", "to", "ui", "use", "with"]);
+
+function tokens(text) {
+  return text
+    .toLowerCase()
+    .replace(/([a-z])([A-Z])/g, "$1 $2")
+    .split(/[^a-z0-9]+/)
+    .filter((token) => token && !STOP_WORDS.has(token));
+}
+
+function searchableText(component) {
+  return [
+    component.name,
+    component.category,
+    component.description,
+    ...component.props.flatMap((prop) => [prop.name, prop.description, prop.type]),
+  ].join(" ").toLowerCase();
+}
+
+function rankComponent(component, query) {
+  const name = component.name.toLowerCase();
+  const haystack = searchableText(component);
+  const queryText = query.toLowerCase().trim();
+  const queryTokens = tokens(queryText);
+  let score = 0;
+
+  if (name === queryText) score += 100;
+  else if (name.includes(queryText) && queryText) score += 50;
+
+  for (const token of queryTokens) {
+    const expanded = tokens(SYNONYMS[token] ?? token);
+    for (const term of expanded) {
+      if (name === term) score += 32;
+      else if (name.includes(term)) score += 18;
+      if (component.category.toLowerCase() === term) score += 10;
+      if (haystack.includes(term)) score += 3;
+    }
+  }
+
+  return score;
+}
+
+function summarize(component) {
+  return {
+    name: component.name,
+    import: `import { ${component.name} } from '${component.importFrom}';`,
+    category: component.category,
+    description: component.description,
+    propCount: component.props.length,
+  };
+}
+
+export function findNeuctraUiComponents(registry, request, { category, limit = 5 } = {}) {
+  if (!request?.trim()) return [];
+  return registry.components
+    .filter((component) => !category || component.category === category)
+    .map((component) => ({ component, score: rankComponent(component, request) }))
+    .filter(({ score }) => score > 0)
+    .sort((a, b) => b.score - a.score || a.component.name.localeCompare(b.component.name))
+    .slice(0, limit)
+    .map(({ component }) => component);
+}
+
+export function registerGetNeuctraUiComponentTool(server, registry) {
+  const componentsByName = new Map(
+    registry.components.map((component) => [component.name.toLowerCase(), component]),
+  );
+
+  server.registerTool(
+    "get-neuctra-ui-component",
+    {
+      title: "Get Neuctra UI components for a UI need",
+      description:
+        "Find and retrieve the real @neuctra/ui components that fit a natural-language UI requirement, such as layout containers, input forms, images, carousels, cards, modals, or drawers. Returns exact package imports, full prop specifications, and documented examples for ranked matches. Use this before implementing with Neuctra UI; do not guess component names or props. Set category to browse a category or omit request/category to list components.",
+      inputSchema: {
+        request: z.string().optional().describe("Describe the UI need naturally, e.g. 'a dismissible confirmation dialog' or 'responsive carousel for product images'."),
+        componentName: z.string().optional().describe("Exact component name when already known, e.g. Container, Input, Carousel, Card, Modal, or Drawer."),
+        category: z.enum(COMPONENT_CATEGORIES).optional().describe("Optionally restrict component discovery to a library category."),
+        limit: z.number().int().min(1).max(10).default(5).describe("Maximum number of full component specs to return for a natural-language request."),
+      },
+    },
+    async ({ request, componentName, category, limit }) => {
+      if (componentName) {
+        const exact = componentsByName.get(componentName.toLowerCase());
+        if (exact && (!category || exact.category === category)) {
+          return { content: [{ type: "text", text: JSON.stringify({ components: [exact] }, null, 2) }] };
+        }
+        if (!request?.trim()) {
+          const suggestions = registry.components
+            .filter((component) => (!category || component.category === category)
+              && component.name.toLowerCase().includes(componentName.toLowerCase()))
+            .slice(0, 8)
+            .map(summarize);
+          return {
+            isError: true,
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                message: `No exact component named "${componentName}"${category ? ` in category "${category}"` : ""}.`,
+                suggestions,
+              }, null, 2),
+            }],
+          };
+        }
+      }
+
+      if (!request?.trim()) {
+        const components = registry.components
+          .filter((component) => !category || component.category === category)
+          .map(summarize);
+        return { content: [{ type: "text", text: JSON.stringify({ components }, null, 2) }] };
+      }
+
+      const ranked = findNeuctraUiComponents(registry, request, { category, limit });
+
+      if (!ranked.length) {
+        const suggestions = registry.components
+          .filter((component) => !category || component.category === category)
+          .map(summarize);
+        return {
+          content: [{ type: "text", text: JSON.stringify({ message: "No component matched that request. Browse these available components or refine the request.", suggestions }, null, 2) }],
+        };
+      }
+
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ request, components: ranked }, null, 2),
+        }],
+      };
+    },
+  );
+}

package/src/tools/neuctra-ui-page-builder/index.mjs

@@ -0,0 +1,157 @@
+import { z } from "zod";
+import { FRAMEWORKS } from "../../seo.mjs";
+import { findNeuctraUiComponents } from "../get-neuctra-ui-component/index.mjs";
+import { getDesignRulesContext } from "../get-design-rules/index.mjs";
+import { buildSeoGuideContext } from "../neuctra-ui-seo-setup/index.mjs";
+
+function resolveLayout(request, requestedType, layoutData) {
+  const layouts = layoutData?.layouts ?? [];
+  if (requestedType !== "auto") {
+    const explicit = layouts.find((layout) => layout.id === requestedType);
+    if (explicit) return { layout: explicit, confidence: 1, evidence: [`Explicit page type: ${requestedType}`] };
+  }
+
+  const normalized = request.toLowerCase();
+  const scored = layouts
+    .filter((layout) => layout.id !== "custom")
+    .map((layout) => {
+      let score = 0;
+      const evidence = [];
+      for (const alias of layout.aliases ?? []) {
+        if (normalized.includes(alias.toLowerCase())) {
+          score += alias.includes(" ") ? 5 : 3;
+          evidence.push(alias);
+        }
+      }
+      for (const keyword of layout.keywords ?? []) {
+        const pattern = new RegExp(`\\b${keyword}\\b`, "i");
+        if (pattern.test(normalized)) {
+          score += 1;
+          evidence.push(keyword);
+        }
+      }
+      return { layout, score, evidence };
+    })
+    .sort((a, b) => b.score - a.score);
+
+  const best = scored[0];
+  const custom = layouts.find((layout) => layout.id === "custom") ?? layouts[0];
+  if (!best || best.score === 0) {
+    return { layout: custom, confidence: 0.25, evidence: ["No specific page pattern detected; use a custom structure based on the stated task."] };
+  }
+  const nextScore = scored[1]?.score ?? 0;
+  return {
+    layout: best.layout,
+    confidence: Math.min(0.98, 0.55 + best.score / (best.score + nextScore + 4)),
+    evidence: best.evidence.slice(0, 8),
+  };
+}
+
+function detectTaskSignals(request) {
+  return [
+    ["create", /\b(create|build|make|new|design)\b/i],
+    ["review", /\b(review|view|inspect|monitor|track|activity|analytics)\b/i],
+    ["search", /\b(search|find|filter|sort)\b/i],
+    ["edit", /\b(edit|update|change|manage|configure)\b/i],
+    ["complete", /\b(complete|submit|checkout|send|publish|save|convert|upload)\b/i],
+    ["compare", /\b(compare|pricing|plan|option|alternative)\b/i],
+  ].filter(([, pattern]) => pattern.test(request)).map(([signal]) => signal);
+}
+
+function getComponentGuidance(registry, request, layout) {
+  const candidates = new Map();
+  const queries = [request, ...(layout.componentQueries ?? [])];
+  for (const query of queries) {
+    for (const component of findNeuctraUiComponents(registry, query, { limit: query === request ? 5 : 2 })) {
+      if (!candidates.has(component.name)) candidates.set(component.name, component);
+      if (candidates.size >= 12) return [...candidates.values()];
+    }
+  }
+  return [...candidates.values()];
+}
+
+export function registerNeuctraUiPageBuilderTool(server, data) {
+  const layouts = data.layouts?.layouts ?? [];
+  const pageTypeOptions = ["auto", ...layouts.map((layout) => layout.id)];
+
+  server.registerTool(
+    "neuctra-ui-page-builder",
+    {
+      title: "Analyze and plan a Neuctra UI page",
+      description:
+        "Analyze a page request, infer its page type (for example tool, blog, dashboard, form, ecommerce, or docs), select a matching editable recipe from data/layouts.json, then compose matching @neuctra/ui component specs, design rules, and framework-aware SEO rules. Use this as the page-planning entry point. It plans the page; the assistant implements it using the returned layout and exact component APIs. Layout recipes can be added or edited in data/layouts.json.",
+      inputSchema: {
+        request: z.string().min(8).describe("Describe the page to create and the main user task."),
+        pageType: z.enum(pageTypeOptions).default("auto").describe("Page type or auto to infer the closest layout from the request."),
+        framework: z.enum(["auto", ...FRAMEWORKS, "remix"]).default("auto").describe("Framework and router for framework-specific SEO implementation guidance."),
+        preferences: z.object({
+          visualDirection: z.string().optional(),
+          density: z.enum(["compact", "balanced", "spacious"]).optional(),
+          primaryAction: z.string().optional(),
+          platform: z.enum(["desktop", "mobile", "responsive"]).default("responsive"),
+          audience: z.string().optional(),
+        }).default({}).describe("Optional design and audience preferences."),
+      },
+    },
+    async ({ request, pageType, framework, preferences }) => {
+      const { layout, confidence, evidence } = resolveLayout(request, pageType, data.layouts);
+      if (!layout) {
+        return { isError: true, content: [{ type: "text", text: "No layouts are configured. Add layout recipes to data/layouts.json." }] };
+      }
+
+      const components = getComponentGuidance(data.registry, request, layout);
+      const design = getDesignRulesContext(data.theme, data.aiDesignRules, layout.designRuleNumbers);
+      const seo = buildSeoGuideContext(data.seoGuide, {
+        framework,
+        ruleIds: layout.seoRuleIds,
+      });
+      const signals = detectTaskSignals(request);
+      const preferencesToClarify = [];
+      if (!preferences.visualDirection) preferencesToClarify.push("visual direction");
+      if (!preferences.density) preferencesToClarify.push("content density");
+      if (!preferences.primaryAction && layout.id !== "blog-page" && layout.id !== "documentation") preferencesToClarify.push("primary action");
+
+      const brief = {
+        pageAnalysis: {
+          request,
+          inferredPageType: layout.id,
+          layoutName: layout.name,
+          confidence,
+          evidence,
+          detectedTaskSignals: signals,
+          userGoal: signals.length
+            ? `Support the requested ${signals.join(", ")} task with a clear primary path.`
+            : "Use the requested page outcome to define the primary path without adding unrelated features.",
+        },
+        layout: {
+          purpose: layout.purpose,
+          outline: layout.outline,
+          responsiveNotes: layout.responsiveNotes,
+          userPreferences: preferences,
+          preferencesToClarify,
+        },
+        components: {
+          source: "@neuctra/ui component registry",
+          matches: components,
+          instruction: "Use these exact exports and documented props. If a required component is absent from the matches, call get-neuctra-ui-component for that need before inventing a pattern.",
+        },
+        designRules: design,
+        seoGuidance: seo ? {
+          framework: seo.framework,
+          relevantRules: seo.seoRules,
+          implementationSteps: seo.implementationSteps,
+          layoutSpecificNotes: layout.seoNotes,
+        } : null,
+        implementationInstructions: [
+          "Use the selected layout as a starting structure and adapt its sections to the exact request.",
+          "Keep the primary task visually clear; do not add sections that do not serve the request.",
+          "Use Neuctra UI components with the exact props and semantic theme tokens from the supplied context.",
+          "Apply the SEO steps only when the page is public and indexable; protect private application pages.",
+          "When framework is auto, inspect the project files and choose metadata and rendering APIs for the installed framework and router.",
+        ],
+      };
+
+      return { content: [{ type: "text", text: JSON.stringify(brief, null, 2) }] };
+    },
+  );
+}

package/src/tools/neuctra-ui-seo-setup/index.mjs

@@ -0,0 +1,62 @@
+import { z } from "zod";
+import { FRAMEWORKS } from "../../seo.mjs";
+
+export function buildSeoGuideContext(seoGuide, { framework = "auto", ruleIds } = {}) {
+  if (!seoGuide) return null;
+  const selectedRules = ruleIds
+    ? seoGuide.seoRules.filter((rule) => ruleIds.includes(rule.id))
+    : seoGuide.seoRules;
+  const knownFramework = ["nextjs-app", "nextjs-pages", "react-vite", "react-router", "remix"].includes(framework);
+  const implementation = knownFramework
+    ? seoGuide.implementationSteps.frameworkSpecific[framework]
+    : framework === "auto"
+      ? seoGuide.implementationSteps.frameworkSpecific
+      : seoGuide.implementationSteps.frameworkSpecific.other;
+
+  return {
+    title: seoGuide.title,
+    intro: seoGuide.intro,
+    seoRules: selectedRules,
+    implementationSteps: seoGuide.implementationSteps.steps,
+    framework: {
+      requested: framework,
+      implementation,
+      assistantGuidance: seoGuide.implementationSteps.assistantGuidance,
+    },
+  };
+}
+
+export function registerNeuctraUiSeoSetupTool(server, { seoGuide }) {
+  server.registerTool(
+    "neuctra-ui-seo-setup",
+    {
+      title: "Neuctra UI SEO rules and implementation guide",
+      description:
+        "Return one complete SEO, AEO, and GEO guide for a Neuctra UI project. The guide has two portions: comprehensive SEO rules and ordered implementation steps, including framework-specific metadata, rendering, JSON-LD, sitemap, and robots guidance. This is an assistant reference tool: inspect the project and apply the rules to its actual framework; it does not generate a single page snippet or audit input.",
+      inputSchema: {
+        framework: z
+          .enum(["auto", ...FRAMEWORKS, "remix"])
+          .default("auto")
+          .describe("Project framework. Use auto to inspect repository context and infer it; framework changes how metadata and rendering are implemented."),
+        projectContext: z
+          .string()
+          .optional()
+          .describe("Optional package.json/framework config or brief project details to help select the right implementation steps."),
+      },
+    },
+    async ({ framework, projectContext }) => {
+      const response = buildSeoGuideContext(seoGuide, { framework });
+      if (!response) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: "SEO guide data was not loaded into this server." }],
+        };
+      }
+      response.framework.projectContext = projectContext ?? null;
+
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }],
+      };
+    },
+  );
+}

package/src/tools/neuctra-ui-setup/index.mjs

@@ -0,0 +1,114 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { spawn } from "node:child_process";
+
+const FRAMEWORKS = ["nextjs", "vite", "remix", "react-router"];
+const ignored = new Set(["node_modules", ".git", ".next", "dist", "build"]);
+
+async function walk(dir, depth = 0) {
+  if (depth > 4) return [];
+  let entries;
+  try { entries = await fs.readdir(dir, { withFileTypes: true }); } catch { return []; }
+  const files = [];
+  for (const entry of entries) {
+    if (ignored.has(entry.name)) continue;
+    const full = path.join(dir, entry.name);
+    if (entry.isFile()) files.push(path.relative(dir, full));
+    else if (entry.isDirectory()) files.push(...(await walk(full, depth + 1)).map((f) => path.join(entry.name, f)));
+  }
+  return files;
+}
+
+async function analyze(projectPath) {
+  const files = await walk(projectPath);
+  let pkg = {};
+  try { pkg = JSON.parse(await fs.readFile(path.join(projectPath, "package.json"), "utf8")); } catch {}
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  const scripts = Object.values(pkg.scripts ?? {}).join(" ");
+  let framework = null;
+  if (deps.next || files.some((f) => /(^|\/)next\.config\./.test(f))) framework = "nextjs";
+  else if (deps["@remix-run/react"] || deps["@remix-run/dev"]) framework = "remix";
+  else if (deps["react-router"] || deps["@react-router/dev"] || /react-router/.test(scripts)) framework = "react-router";
+  else if (deps.vite && deps.react) framework = "vite";
+  const rootItems = await fs.readdir(projectPath).catch(() => []);
+  return {
+    projectPath,
+    framework,
+    packageName: pkg.name ?? null,
+    hasPackageJson: Boolean(pkg.name || Object.keys(pkg).length),
+    filesFound: files.length,
+    rootItems: rootItems.filter((name) => name !== "node_modules" && name !== ".git").slice(0, 40),
+    state: framework ? "framework-detected" : files.length ? "unrecognized-or-partial-project" : "empty-directory",
+  };
+}
+
+function run(command, args, cwd) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, { cwd, stdio: "inherit", shell: process.platform === "win32" });
+    child.once("error", reject);
+    child.once("close", (code) => code === 0 ? resolve() : reject(new Error(`${command} exited with code ${code}`)));
+  });
+}
+
+async function emptyDirectory(projectPath) {
+  const resolved = path.resolve(projectPath);
+  if (resolved === path.parse(resolved).root || resolved === process.cwd()) {
+    throw new Error("Refusing to clear a filesystem root or the MCP server working directory.");
+  }
+  for (const entry of await fs.readdir(resolved, { withFileTypes: true })) {
+    await fs.rm(path.join(resolved, entry.name), { recursive: true, force: true });
+  }
+}
+
+async function createFramework(projectPath, framework) {
+  if (framework === "nextjs") {
+    await run("npx", ["create-next-app@latest", ".", "--js", "--tailwind", "--app", "--src-dir", "--use-npm", "--yes"], projectPath);
+    const config = path.join(projectPath, "next.config.mjs");
+    await fs.writeFile(config, 'const nextConfig = { output: "export" };\n\nexport default nextConfig;\n');
+  } else if (framework === "vite") {
+    await run("npm", ["create", "vite@latest", ".", "--", "--template", "react"], projectPath);
+    await run("npm", ["install"], projectPath);
+  } else if (framework === "remix") {
+    await run("npx", ["create-remix@latest", ".", "--template", "remix-run/remix/templates/spa"], projectPath);
+  } else {
+    await run("npx", ["create-react-router@latest", "."], projectPath);
+  }
+}
+
+/** Analyze first; setup actions require a subsequent explicit call with framework and choices. */
+export async function setupNeuctraUi(input) {
+  const projectPath = path.resolve(input.projectPath || process.cwd());
+  const report = await analyze(projectPath);
+  if (input.action !== "setup") {
+    return { ...report, nextStep: report.framework ? "Choose whether to use CLI setup or manual setup." : "Choose a framework; if clearing is required, explicitly confirm it." };
+  }
+
+  const framework = input.framework ?? report.framework ?? "nextjs";
+  if (!FRAMEWORKS.includes(framework)) {
+    return { ...report, needsInput: "framework", allowedFrameworks: FRAMEWORKS, message: "Select a supported framework before setup can continue." };
+  }
+  if (!input.setupMode) {
+    return { ...report, selectedFramework: framework, needsInput: "setupMode", allowedSetupModes: ["cli", "manual"], message: "Choose whether to run the Neuctra UI CLI setup or get manual setup instructions." };
+  }
+  const setupMode = input.setupMode;
+  if (!["cli", "manual"].includes(setupMode)) throw new Error("setupMode must be cli or manual.");
+  if (setupMode === "manual") {
+    return { ...report, selectedFramework: framework, setupMode, instructions: ["Install @neuctra/ui.", "Configure Tailwind CSS v4 for the selected framework.", "Add @import \"tailwindcss\" and @source \"../node_modules/@neuctra/ui\" to global CSS.", "Run npx @neuctra/ui-cli@latest init to generate theme setup.", "Install lucide-react."] };
+  }
+
+  const projectExists = report.filesFound > 0;
+  if (report.framework && report.framework !== framework && !input.confirmReplace) {
+    return { ...report, needsInput: "confirmReplace", message: `Detected ${report.framework}. Confirm replacing this project before selecting ${framework}.` };
+  }
+  const replaceProject = projectExists && (!report.framework || report.framework !== framework);
+  if (replaceProject && !input.confirmClear) {
+    return { ...report, needsInput: "confirmClear", message: "This directory contains files. Explicitly confirm clearing it to initialize a new framework." };
+  }
+
+  if (replaceProject) await emptyDirectory(projectPath);
+  await fs.mkdir(projectPath, { recursive: true });
+  if (!report.framework || replaceProject) await createFramework(projectPath, framework);
+  await run("npx", ["@neuctra/ui-cli@latest", "init"], projectPath);
+  await run("npm", ["install", "lucide-react"], projectPath);
+  return { ...(await analyze(projectPath)), setupMode, setupComplete: true, installed: ["@neuctra/ui", "lucide-react"], themeInitializedBy: "@neuctra/ui-cli init", staticExport: framework === "nextjs" };
+}

package/src/tools/neuctra-ui-setup/register.mjs

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { setupNeuctraUi } from "./index.mjs";
+
+export function registerNeuctraUiSetupTool(server) {
+  server.registerTool(
+    "neuctra-ui-setup",
+    {
+      title: "Analyze or set up a Neuctra UI project",
+      description: "Dedicated project setup assistant for @neuctra/ui. It first analyzes the target directory and detects Next.js, Vite React, Remix, or React Router. Call with action=analyze first. Setup calls require an explicit framework and either cli (scaffold/configure using @neuctra/ui-cli, then install lucide-react) or manual (return step-by-step instructions). Existing matching projects are preserved and initialized in place. Replacing or clearing populated directories requires explicit confirmation flags; this tool never cleans a directory during analysis.",
+      inputSchema: {
+        action: z.enum(["analyze", "setup"]).default("analyze").describe("Always analyze before setup; setup performs the selected workflow."),
+        projectPath: z.string().optional().describe("Project directory; defaults to the MCP client's current working directory."),
+        framework: z.enum(["nextjs", "vite", "remix", "react-router"]).optional().describe("Framework selected by the user. With no preference, the recommended default is Next.js App Router, JavaScript, Tailwind, and static export."),
+        setupMode: z.enum(["cli", "manual"]).optional().describe("Use the setup CLI workflow, or return manual setup instructions."),
+        confirmClear: z.boolean().optional().describe("Explicit confirmation to remove files from a populated unrecognized directory before scaffolding."),
+        confirmReplace: z.boolean().optional().describe("Explicit confirmation to replace an existing detected framework with a different one."),
+      },
+    },
+    async (input) => {
+      try {
+        const result = await setupNeuctraUi(input);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (error) {
+        return { isError: true, content: [{ type: "text", text: `Neuctra UI setup failed: ${error.message}` }] };
+      }
+    },
+  )
+}

package/src/tools/neuctra-ui-theme-setup/index.mjs

@@ -0,0 +1,17 @@
+export function registerNeuctraUiThemeSetupTool(server, { theme }) {
+  server.registerTool(
+    "neuctra-ui-theme-setup",
+    {
+      title: "Get Neuctra UI theme setup",
+      description:
+        "Return the Neuctra UI theme setup configuration: semantic color tokens, Tailwind CSS theme mappings, and theme initialization guidance. Use this to configure the theme system; use neuctra-ui-setup to run the CLI initializer in a project.",
+      inputSchema: {},
+    },
+    async () => {
+      const { rules, antiAiLookRules, ...themeSetup } = theme;
+      return {
+        content: [{ type: "text", text: JSON.stringify(themeSetup, null, 2) }],
+      };
+    },
+  );
+}