jui-tools-mcp-server 2.5.0

package/src/tools/doc/doc_validate_component.ts

@@ -0,0 +1,47 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { join } from "path";
+import { ServerConfig } from "../../config.js";
+import { runCli } from "../../cli_runner.js";
+
+export function register(server: McpServer, config: ServerConfig) {
+  server.tool(
+    "doc_validate_component",
+    "Validate a component specification JSON file against the schema",
+    {
+      file: z.string().describe("Component spec file path (e.g., 'my_card.component.json' or full path)"),
+      project_dir: z.string().optional().describe("Project directory (overrides JUI_PROJECT_DIR env)"),
+    },
+    async (params) => {
+      try {
+        const projectDir = config.resolveProjectDir(params.project_dir);
+        let filePath = params.file;
+
+        if (!filePath.startsWith("/") && !filePath.includes("/")) {
+          try {
+            const projectConfig = config.readProjectConfig(projectDir);
+            const compDir = config.resolveDir(projectConfig, "component_spec_directory", projectDir);
+            filePath = join(compDir, filePath);
+          } catch {
+            filePath = join(projectDir, filePath);
+          }
+        }
+
+        const result = await runCli("jsonui-doc", ["validate", "component", filePath], { cwd: projectDir });
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              success: result.exitCode === 0,
+              is_valid: result.exitCode === 0,
+              output: result.stdout,
+              errors: result.stderr || undefined,
+            }, null, 2),
+          }],
+        };
+      } catch (e: any) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  );
+}

package/src/tools/doc/doc_validate_spec.ts

@@ -0,0 +1,48 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { join } from "path";
+import { ServerConfig } from "../../config.js";
+import { runCli } from "../../cli_runner.js";
+
+export function register(server: McpServer, config: ServerConfig) {
+  server.tool(
+    "doc_validate_spec",
+    "Validate a screen specification JSON file against the schema",
+    {
+      file: z.string().describe("Spec file path (e.g., 'login.spec.json' or full path)"),
+      project_dir: z.string().optional().describe("Project directory (overrides JUI_PROJECT_DIR env)"),
+    },
+    async (params) => {
+      try {
+        const projectDir = config.resolveProjectDir(params.project_dir);
+        let filePath = params.file;
+
+        // If relative and doesn't contain directory separator, resolve from spec_directory
+        if (!filePath.startsWith("/") && !filePath.includes("/")) {
+          try {
+            const projectConfig = config.readProjectConfig(projectDir);
+            const specDir = config.resolveDir(projectConfig, "spec_directory", projectDir);
+            filePath = join(specDir, filePath);
+          } catch {
+            filePath = join(projectDir, filePath);
+          }
+        }
+
+        const result = await runCli("jsonui-doc", ["validate", "spec", filePath], { cwd: projectDir });
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              success: result.exitCode === 0,
+              is_valid: result.exitCode === 0,
+              output: result.stdout,
+              errors: result.stderr || undefined,
+            }, null, 2),
+          }],
+        };
+      } catch (e: any) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  );
+}

package/src/tools/jui/jui_build.ts

@@ -0,0 +1,31 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { ServerConfig } from "../../config.js";
+import { runCli, formatResult } from "../../cli_runner.js";
+
+export function register(server: McpServer, config: ServerConfig) {
+  server.tool(
+    "jui_build",
+    "Distribute layouts/strings/images to all platforms and run platform builds (sjui/kjui/rjui build)",
+    {
+      clean: z.boolean().optional().describe("Clean build (regenerate all)"),
+      platform: z.enum(["ios", "android", "web"]).optional().describe("Build single platform only"),
+      project_dir: z.string().optional().describe("Project directory (overrides JUI_PROJECT_DIR env)"),
+    },
+    async (params) => {
+      try {
+        const projectDir = config.resolveProjectDir(params.project_dir);
+        const args = ["build"];
+        if (params.clean) { args.push("--clean"); }
+        if (params.platform === "ios") { args.push("--ios-only"); }
+        if (params.platform === "android") { args.push("--android-only"); }
+        if (params.platform === "web") { args.push("--web-only"); }
+
+        const result = await runCli("jui", args, { cwd: projectDir, timeout: 300_000 });
+        return { content: [{ type: "text", text: formatResult(result) }] };
+      } catch (e: any) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  );
+}

package/src/tools/jui/jui_generate_converter.ts

@@ -0,0 +1,41 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { ServerConfig } from "../../config.js";
+import { runCli, formatResult } from "../../cli_runner.js";
+
+export function register(server: McpServer, config: ServerConfig) {
+  server.tool(
+    "jui_generate_converter",
+    "Generate custom component converter code for each platform",
+    {
+      name: z.string().optional().describe("Component name (direct mode, e.g., 'MyComponent')"),
+      from_spec: z.string().optional().describe("Generate from component spec file path"),
+      all: z.boolean().optional().describe("Generate from all component specs"),
+      attributes: z.string().optional().describe("Attributes in key:type format (e.g., 'prop1:String,prop2:Int')"),
+      container: z.boolean().optional().describe("Mark as container component"),
+      skip_existing: z.boolean().optional().describe(
+        "Leave existing converter files untouched (no overwrite prompt). " +
+        "`jui build` enables this automatically; pass it here for idempotent " +
+        "explicit scaffold runs."
+      ),
+      project_dir: z.string().optional().describe("Project directory (overrides JUI_PROJECT_DIR env)"),
+    },
+    async (params) => {
+      try {
+        const projectDir = config.resolveProjectDir(params.project_dir);
+        const args = ["generate", "converter"];
+        if (params.name) { args.push(params.name); }
+        if (params.from_spec) { args.push("--from", params.from_spec); }
+        if (params.all) { args.push("--all"); }
+        if (params.attributes) { args.push("--attributes", params.attributes); }
+        if (params.container) { args.push("--container"); }
+        if (params.skip_existing) { args.push("--skip-existing"); }
+
+        const result = await runCli("jui", args, { cwd: projectDir });
+        return { content: [{ type: "text", text: formatResult(result) }] };
+      } catch (e: any) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  );
+}

package/src/tools/jui/jui_generate_project.ts

@@ -0,0 +1,37 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { ServerConfig } from "../../config.js";
+import { runCli, formatResult } from "../../cli_runner.js";
+
+export function register(server: McpServer, config: ServerConfig) {
+  server.tool(
+    "jui_generate_project",
+    "Generate Layout JSON and ViewModel files from screen specs (all or single spec)",
+    {
+      spec_file: z.string().optional().describe("Single spec file to process (e.g., 'login.spec.json')"),
+      force: z.boolean().optional().describe("Force overwrite declaration files"),
+      skip_layout: z.boolean().optional().describe("Skip Layout JSON generation"),
+      dry_run: z.boolean().optional().describe("Show what would be generated without writing"),
+      platform: z.enum(["ios", "android", "web"]).optional().describe("Generate for single platform only"),
+      project_dir: z.string().optional().describe("Project directory (overrides JUI_PROJECT_DIR env)"),
+    },
+    async (params) => {
+      try {
+        const projectDir = config.resolveProjectDir(params.project_dir);
+        const args = ["generate", "project"];
+        if (params.spec_file) { args.push("--file", params.spec_file); }
+        if (params.force) { args.push("--force"); }
+        if (params.skip_layout) { args.push("--skip-layout"); }
+        if (params.dry_run) { args.push("--dry-run"); }
+        if (params.platform === "ios") { args.push("--ios-only"); }
+        if (params.platform === "android") { args.push("--android-only"); }
+        if (params.platform === "web") { args.push("--web-only"); }
+
+        const result = await runCli("jui", args, { cwd: projectDir, timeout: 120_000 });
+        return { content: [{ type: "text", text: formatResult(result) }] };
+      } catch (e: any) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  );
+}

package/src/tools/jui/jui_generate_screen.ts

@@ -0,0 +1,28 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { ServerConfig } from "../../config.js";
+import { runCli, formatResult } from "../../cli_runner.js";
+
+export function register(server: McpServer, config: ServerConfig) {
+  server.tool(
+    "jui_generate_screen",
+    "Create screen spec template files for new screens",
+    {
+      names: z.array(z.string()).describe("Screen names in PascalCase (e.g., ['LoginScreen', 'RegisterScreen'])"),
+      display_name: z.string().optional().describe("Display name (for single screen only)"),
+      project_dir: z.string().optional().describe("Project directory (overrides JUI_PROJECT_DIR env)"),
+    },
+    async (params) => {
+      try {
+        const projectDir = config.resolveProjectDir(params.project_dir);
+        const args = ["generate", "screen", ...params.names];
+        if (params.display_name) { args.push("--display-name", params.display_name); }
+
+        const result = await runCli("jui", args, { cwd: projectDir });
+        return { content: [{ type: "text", text: formatResult(result) }] };
+      } catch (e: any) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  );
+}

package/src/tools/jui/jui_init.ts

@@ -0,0 +1,38 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { ServerConfig } from "../../config.js";
+import { runCli, formatResult } from "../../cli_runner.js";
+
+export function register(server: McpServer, config: ServerConfig) {
+  server.tool(
+    "jui_init",
+    "Initialize a new JsonUI project (creates jui.config.json and directory structure)",
+    {
+      project_name: z.string().describe("Project name"),
+      ios_path: z.string().optional().describe("iOS project root relative path"),
+      ios_mode: z.enum(["swiftui", "uikit", "all"]).optional().describe("iOS rendering mode (default: swiftui)"),
+      android_path: z.string().optional().describe("Android project root relative path"),
+      android_mode: z.enum(["compose", "xml"]).optional().describe("Android rendering mode (default: compose)"),
+      package_name: z.string().optional().describe("Android package name (e.g., com.example.app)"),
+      web_path: z.string().optional().describe("Web project root relative path"),
+      project_dir: z.string().optional().describe("Project directory (overrides JUI_PROJECT_DIR env)"),
+    },
+    async (params) => {
+      try {
+        const projectDir = config.resolveProjectDir(params.project_dir);
+        const args = ["init", "--project-name", params.project_name];
+        if (params.ios_path) { args.push("--ios", params.ios_path); }
+        if (params.ios_mode) { args.push("--ios-mode", params.ios_mode); }
+        if (params.android_path) { args.push("--android", params.android_path); }
+        if (params.android_mode) { args.push("--android-mode", params.android_mode); }
+        if (params.package_name) { args.push("--package-name", params.package_name); }
+        if (params.web_path) { args.push("--web", params.web_path); }
+
+        const result = await runCli("jui", args, { cwd: projectDir });
+        return { content: [{ type: "text", text: formatResult(result) }] };
+      } catch (e: any) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  );
+}

package/src/tools/jui/jui_migrate_layouts.ts

@@ -0,0 +1,29 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { ServerConfig } from "../../config.js";
+import { runCli, formatResult } from "../../cli_runner.js";
+
+export function register(server: McpServer, config: ServerConfig) {
+  server.tool(
+    "jui_migrate_layouts",
+    "Copy existing platform layouts to the shared layouts directory",
+    {
+      source_platform: z.enum(["ios", "android", "web"]).optional().describe("Platform to copy from (default: ios)"),
+      dry_run: z.boolean().optional().describe("Show what would be copied without executing"),
+      project_dir: z.string().optional().describe("Project directory (overrides JUI_PROJECT_DIR env)"),
+    },
+    async (params) => {
+      try {
+        const projectDir = config.resolveProjectDir(params.project_dir);
+        const args = ["migrate-layouts"];
+        if (params.source_platform) { args.push("--from", params.source_platform); }
+        if (params.dry_run) { args.push("--dry-run"); }
+
+        const result = await runCli("jui", args, { cwd: projectDir });
+        return { content: [{ type: "text", text: formatResult(result) }] };
+      } catch (e: any) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  );
+}

package/src/tools/jui/jui_sync_tool.ts

@@ -0,0 +1,33 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { ServerConfig } from "../../config.js";
+import { runCli, formatResult } from "../../cli_runner.js";
+
+export function register(server: McpServer, config: ServerConfig) {
+  server.tool(
+    "jui_sync_tool",
+    "Sync the project's platform-local tool checkouts (sjui_tools / kjui_tools / rjui_tools under each platform root) with the home install (~/.jsonui-cli/ or $JSONUI_CLI_PATH). Preserves every `extensions/` directory — that's where custom converters generated by `rjui g converter` etc. live. Also propagates each tool's `.ruby-version` to the platform root so that standalone `rjui build` (not routed through `jui build`) picks up the correct Ruby via rbenv. Safe to run after bumping jsonui-cli or when bootstrapping a newly scaffolded platform (target dir is created on first run).",
+    {
+      platform: z.enum(["ios", "android", "web"]).optional().describe("Sync only one platform. Defaults to every platform listed in jui.config.json."),
+      prune: z.boolean().optional().describe("Delete files in the target that don't exist in the source (never inside extensions/). Default false."),
+      dry_run: z.boolean().optional().describe("Show what would change without writing any files."),
+      from: z.string().optional().describe("Override source CLI root (default: $JSONUI_CLI_PATH or ~/.jsonui-cli/)."),
+      project_dir: z.string().optional().describe("Project directory (overrides JUI_PROJECT_DIR env)"),
+    },
+    async (params) => {
+      try {
+        const projectDir = config.resolveProjectDir(params.project_dir);
+        const args = ["sync_tool"];
+        if (params.platform) { args.push("--platform", params.platform); }
+        if (params.prune) { args.push("--prune"); }
+        if (params.dry_run) { args.push("--dry-run"); }
+        if (params.from) { args.push("--from", params.from); }
+
+        const result = await runCli("jui", args, { cwd: projectDir });
+        return { content: [{ type: "text", text: formatResult(result) }] };
+      } catch (e: any) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  );
+}

package/src/tools/jui/jui_verify.ts

@@ -0,0 +1,43 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { ServerConfig } from "../../config.js";
+import { runCli } from "../../cli_runner.js";
+
+export function register(server: McpServer, config: ServerConfig) {
+  server.tool(
+    "jui_verify",
+    "Compare generated Layout JSON against on-disk layouts and report differences",
+    {
+      spec_file: z.string().optional().describe("Single spec file to verify (e.g., 'login.spec.json')"),
+      detail: z.boolean().optional().describe("Include per-screen diff details in report"),
+      fail_on_diff: z.boolean().optional().describe("Exit with error if any diff detected"),
+      platform: z.string().optional().describe("Target platform (defaults to first in config)"),
+      project_dir: z.string().optional().describe("Project directory (overrides JUI_PROJECT_DIR env)"),
+    },
+    async (params) => {
+      try {
+        const projectDir = config.resolveProjectDir(params.project_dir);
+        const args = ["verify"];
+        if (params.spec_file) { args.push("--file", params.spec_file); }
+        if (params.detail) { args.push("--detail"); }
+        if (params.fail_on_diff) { args.push("--fail-on-diff"); }
+        if (params.platform) { args.push("--platform", params.platform); }
+
+        const result = await runCli("jui", args, { cwd: projectDir });
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              success: result.exitCode === 0,
+              has_diffs: result.exitCode !== 0,
+              report: result.stdout,
+              errors: result.stderr || undefined,
+            }, null, 2),
+          }],
+        };
+      } catch (e: any) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  );
+}

package/src/tools/spec/get_binding_rules.ts

@@ -0,0 +1,16 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SpecLoader } from "../../spec_loader.js";
+
+export function register(server: McpServer, loader: SpecLoader) {
+  server.tool(
+    "get_binding_rules",
+    "Get binding syntax rules: two-way vs read-only, platform-specific formats, critical rules",
+    {},
+    async () => {
+      const result = loader.getBindingRules();
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+      };
+    }
+  );
+}

package/src/tools/spec/get_data_source.ts

@@ -0,0 +1,53 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SpecLoader } from "../../spec_loader.js";
+
+export function register(server: McpServer, loader: SpecLoader) {
+  server.tool(
+    "get_data_source",
+    "Report where the MCP server loaded EVERY canonical data file from — attribute_definitions.json (raw schema), component_metadata.json (presentation metadata), screen_identity.json and binding_semantics.json. Shows layer (env / cwd / home / bundled), the absolute path actually read, file mtime and freshness per file, plus when this server process loaded them. Use it when the CLI and the MCP seem to disagree about the canon: it distinguishes a stale file from a server that simply has not been restarted since the file changed.",
+    {},
+    async () => {
+      const info = loader.getDataSource();
+      const files = [
+        info.attributeDefinitions,
+        info.componentMetadata,
+        info.screenIdentity,
+        info.bindingSemantics,
+        info.attributeSemantics,
+      ].filter((f): f is NonNullable<typeof f> => f != null);
+      const stale = files.some((f) => f.freshness === "stale");
+      // The data is read once at construction and cached in memory, so a
+      // file edited after this timestamp is NOT what the server is serving,
+      // however current the file on disk looks.
+      const loadedAt = loader.getLoadedAt();
+      const changedSinceLoad = loader.getChangedSinceLoad();
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                attributeDefinitions: info.attributeDefinitions,
+                componentMetadata: info.componentMetadata,
+                screenIdentity: info.screenIdentity,
+                bindingSemantics: info.bindingSemantics,
+                attributeSemantics: info.attributeSemantics,
+                componentCount: info.componentCount,
+                commonAttributeCount: info.commonAttributeCount,
+                loadedAt,
+                staleInMemory: changedSinceLoad.length > 0 ? changedSinceLoad : undefined,
+                hint: changedSinceLoad.length
+                  ? "These files changed on disk AFTER this server loaded them. The server is serving the older content from memory — restart it."
+                  : stale
+                    ? "At least one data file is > 90 days old. Re-fetch via `npm rebuild jui-tools-mcp-server` or point JSONUI_CLI_PATH at a fresher checkout."
+                    : undefined,
+              },
+              null,
+              2
+            ),
+          },
+        ],
+      };
+    }
+  );
+}

package/src/tools/spec/get_modifier_order.ts

@@ -0,0 +1,22 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { SpecLoader } from "../../spec_loader.js";
+
+export function register(server: McpServer, loader: SpecLoader) {
+  server.tool(
+    "get_modifier_order",
+    "Get modifier application order for a platform (critical for correct rendering)",
+    {
+      platform: z
+        .enum(["swift", "kotlin", "react"])
+        .optional()
+        .describe("Platform (omit for all platforms)"),
+    },
+    async ({ platform }) => {
+      const result = loader.getModifierOrder(platform);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+      };
+    }
+  );
+}

package/src/tools/spec/get_platform_mapping.ts

@@ -0,0 +1,28 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { SpecLoader } from "../../spec_loader.js";
+
+export function register(server: McpServer, loader: SpecLoader) {
+  server.tool(
+    "get_platform_mapping",
+    "Get cross-platform attribute value conversion mapping (e.g. matchParent, textAlign, fontWeight)",
+    {
+      category: z
+        .string()
+        .optional()
+        .describe("Mapping category (values, contentMode, textAlign, fontWeight, orientation, gravity, types). Omit for all."),
+    },
+    async ({ category }) => {
+      const result = loader.getPlatformMapping(category);
+      if (!result) {
+        const categories = Object.keys(loader.getPlatformMapping()).join(", ");
+        return {
+          content: [{ type: "text", text: `Category '${category}' not found. Available: ${categories}` }],
+        };
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+      };
+    }
+  );
+}

package/src/tools/spec/get_screen_identity.ts

@@ -0,0 +1,31 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SpecLoader } from "../../spec_loader.js";
+
+export function register(server: McpServer, loader: SpecLoader) {
+  server.tool(
+    "get_screen_identity",
+    "Get the canonical screen-identity rules: what counts as a screen, how a screen id is derived, " +
+      "the runtime marker, the per-platform 'is this screen displayed' predicates, and the " +
+      "assert:\"screen\" vocabulary. Use before writing screen/flow tests or navigation code.",
+    {},
+    async () => {
+      const result = loader.getScreenIdentity();
+      if (!result) {
+        return {
+          content: [
+            {
+              type: "text",
+              text:
+                "screen_identity.json is not available in this installation. " +
+                "Update the MCP server (npm run fetch-definitions) or point it at a " +
+                "jsonui-cli checkout that has shared/core/screen_identity.json.",
+            },
+          ],
+        };
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+      };
+    }
+  );
+}

package/src/tools/spec/lookup_attribute.ts

@@ -0,0 +1,22 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { SpecLoader } from "../../spec_loader.js";
+
+export function register(server: McpServer, loader: SpecLoader) {
+  server.tool(
+    "lookup_attribute",
+    "Look up a specific attribute definition: type, binding support, which components use it, the declared platform surface (`platform`, with `platform_reasons` explaining excluded platforms), and `implementationGaps` — platforms that declare the attribute but whose codegen does not consume it yet, with the recorded reason",
+    { name: z.string().describe("Attribute name (e.g. 'fontSize', 'padding', 'onClick')") },
+    async ({ name }) => {
+      const result = loader.getAttribute(name);
+      if (!result) {
+        return {
+          content: [{ type: "text", text: `Attribute '${name}' not found.` }],
+        };
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+      };
+    }
+  );
+}

package/src/tools/spec/lookup_component.ts

@@ -0,0 +1,23 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { SpecLoader } from "../../spec_loader.js";
+
+export function register(server: McpServer, loader: SpecLoader) {
+  server.tool(
+    "lookup_component",
+    "Look up a JsonUI component specification including attributes, binding behavior, platform-specific details, and rules",
+    { name: z.string().describe("Component name (e.g. 'TextField', 'Button', 'View')") },
+    async ({ name }) => {
+      const spec = loader.getComponentWithCommon(name);
+      if (!spec) {
+        const available = loader.listComponents().join(", ");
+        return {
+          content: [{ type: "text", text: `Component '${name}' not found. Available: ${available}` }],
+        };
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify(spec, null, 2) }],
+      };
+    }
+  );
+}

package/src/tools/spec/search_components.ts

@@ -0,0 +1,22 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { SpecLoader } from "../../spec_loader.js";
+
+export function register(server: McpServer, loader: SpecLoader) {
+  server.tool(
+    "search_components",
+    "Search components and attributes by keyword (e.g. 'binding', 'focus', 'color')",
+    { query: z.string().describe("Search keyword") },
+    async ({ query }) => {
+      const results = loader.searchComponents(query);
+      if (results.length === 0) {
+        return {
+          content: [{ type: "text", text: `No results for '${query}'.` }],
+        };
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify(results.slice(0, 20), null, 2) }],
+      };
+    }
+  );
+}