alus-ui-mcp 0.1.0

package/README.md

@@ -0,0 +1,58 @@
+# alus-ui-mcp
+
+> MCP stdio server for the [alus-ui](https://www.npmjs.com/package/alus-ui) Svelte 5 component library.
+
+Gives LLMs (Claude, Cursor, etc.) direct access to alus-ui component source, demos, exports, and utilities via the [Model Context Protocol](https://modelcontextprotocol.io).
+
+## Usage
+
+### npx (no install)
+
+```bash
+npx alus-ui-mcp
+```
+
+### Claude Code
+
+Add to `.mcp.json` at your project root:
+
+```json
+{
+  "mcpServers": {
+    "alus-ui": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["alus-ui-mcp"]
+    }
+  }
+}
+```
+
+### Remote HTTP
+
+The production Cloudflare deployment exposes `/mcp`. Point your client to:
+
+```json
+{
+  "mcpServers": {
+    "alus-ui": {
+      "url": "https://alus.lkmn.link/mcp"
+    }
+  }
+}
+```
+
+## Tools
+
+| Tool | Description |
+|---|---|
+| `alus_list_components` | Browse all 150+ components by category |
+| `alus_get_component` | Read full `.svelte` + `index.ts` source |
+| `alus_search_components` | Full-text search across all source files |
+| `alus_get_component_demo` | Read showcase demo page |
+| `alus_list_exports` | Show full public API (`components/index.ts`) |
+| `alus_get_utils` | Read a11y/form utility module source |
+
+## License
+
+MIT — part of the [alus](https://github.com/Hanivan/alus) monorepo.

package/dist/index.js

@@ -0,0 +1,1221 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../../node_modules/.pnpm/@tmcp+adapter-valibot@0.1.6_tmcp@1.19.4_typescript@5.9.3__valibot@1.4.1_typescript@5.9.3_/node_modules/@tmcp/adapter-valibot/src/index.js
+import { JsonSchemaAdapter } from "tmcp/adapter";
+
+// ../../node_modules/.pnpm/@valibot+to-json-schema@1.7.0_valibot@1.4.1_typescript@5.9.3_/node_modules/@valibot/to-json-schema/dist/index.mjs
+function addError(errors, message) {
+  if (errors) {
+    errors.push(message);
+    return errors;
+  }
+  return [message];
+}
+var ESCAPE_REGEX = /[.*+?^${}()|[\]\\]/g;
+function escapeRegExp(string2) {
+  return string2.replace(ESCAPE_REGEX, "\\$&");
+}
+function handleError(message, config) {
+  switch (config?.errorMode) {
+    case "ignore":
+      break;
+    case "warn":
+      console.warn(message);
+      break;
+    default:
+      throw new Error(message);
+  }
+}
+function isJsonConstValue(value) {
+  return typeof value === "boolean" || typeof value === "number" && Number.isFinite(value) || typeof value === "string";
+}
+function isJsonEnumValues(values) {
+  return values.every(isJsonConstValue);
+}
+function convertAction(jsonSchema, valibotAction, config) {
+  if (config?.ignoreActions?.includes(valibotAction.type)) return jsonSchema;
+  let errors;
+  switch (valibotAction.type) {
+    case "base64":
+      jsonSchema.contentEncoding = "base64";
+      break;
+    case "bic":
+    case "cuid2":
+    case "decimal":
+    case "digits":
+    case "domain":
+    case "emoji":
+    case "hash":
+    case "hexadecimal":
+    case "hex_color":
+    case "isrc":
+    case "iso_time_second":
+    case "iso_week":
+    case "mac":
+    case "mac48":
+    case "mac64":
+    case "nanoid":
+    case "octal":
+    case "slug":
+    case "ulid":
+      if (jsonSchema.pattern) errors = addError(errors, `The "${valibotAction.type}" action is not supported in combination with another regex action.`);
+      else jsonSchema.pattern = valibotAction.requirement.source;
+      break;
+    case "description":
+      jsonSchema.description = valibotAction.description;
+      break;
+    case "email":
+    case "rfc_email":
+      jsonSchema.format = "email";
+      break;
+    case "ends_with":
+      if (jsonSchema.pattern) errors = addError(errors, `The "${valibotAction.type}" action is not supported in combination with another regex action.`);
+      else jsonSchema.pattern = `${escapeRegExp(valibotAction.requirement)}$`;
+      break;
+    case "empty":
+      if (jsonSchema.type === "array") jsonSchema.maxItems = 0;
+      else {
+        if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
+        jsonSchema.maxLength = 0;
+      }
+      break;
+    case "entries":
+      jsonSchema.minProperties = valibotAction.requirement;
+      jsonSchema.maxProperties = valibotAction.requirement;
+      break;
+    case "examples":
+      if (Array.isArray(jsonSchema.examples)) jsonSchema.examples = [...jsonSchema.examples, ...valibotAction.examples];
+      else jsonSchema.examples = valibotAction.examples;
+      break;
+    case "gt_value":
+      if (jsonSchema.type !== "number" && jsonSchema.type !== "integer") errors = addError(errors, `The "gt_value" action is not supported on type "${jsonSchema.type}".`);
+      if (config?.target === "openapi-3.0") {
+        errors = addError(errors, 'The "gt_value" action is not supported for OpenAPI 3.0.');
+        break;
+      }
+      jsonSchema.exclusiveMinimum = valibotAction.requirement;
+      break;
+    case "includes":
+      if (jsonSchema.pattern) errors = addError(errors, `The "${valibotAction.type}" action is not supported in combination with another regex action.`);
+      else jsonSchema.pattern = escapeRegExp(valibotAction.requirement);
+      break;
+    case "integer":
+      jsonSchema.type = "integer";
+      break;
+    case "ipv4":
+      jsonSchema.format = "ipv4";
+      break;
+    case "ipv6":
+      jsonSchema.format = "ipv6";
+      break;
+    case "iso_date":
+      jsonSchema.format = "date";
+      break;
+    case "iso_date_time":
+    case "iso_timestamp":
+      jsonSchema.format = "date-time";
+      break;
+    case "iso_time":
+      jsonSchema.format = "time";
+      break;
+    case "jws_compact":
+      if (jsonSchema.pattern) errors = addError(errors, `The "${valibotAction.type}" action is not supported in combination with another regex action.`);
+      else jsonSchema.pattern = valibotAction.requirement.source;
+      break;
+    case "length":
+      if (jsonSchema.type === "array") {
+        jsonSchema.minItems = valibotAction.requirement;
+        jsonSchema.maxItems = valibotAction.requirement;
+      } else {
+        if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
+        jsonSchema.minLength = valibotAction.requirement;
+        jsonSchema.maxLength = valibotAction.requirement;
+      }
+      break;
+    case "lt_value":
+      if (jsonSchema.type !== "number" && jsonSchema.type !== "integer") errors = addError(errors, `The "lt_value" action is not supported on type "${jsonSchema.type}".`);
+      if (config?.target === "openapi-3.0") {
+        errors = addError(errors, 'The "lt_value" action is not supported for OpenAPI 3.0.');
+        break;
+      }
+      jsonSchema.exclusiveMaximum = valibotAction.requirement;
+      break;
+    case "max_entries":
+      jsonSchema.maxProperties = valibotAction.requirement;
+      break;
+    case "max_length":
+      if (jsonSchema.type === "array") jsonSchema.maxItems = valibotAction.requirement;
+      else {
+        if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
+        jsonSchema.maxLength = valibotAction.requirement;
+      }
+      break;
+    case "max_value":
+      if (jsonSchema.type !== "number" && jsonSchema.type !== "integer") errors = addError(errors, `The "max_value" action is not supported on type "${jsonSchema.type}".`);
+      jsonSchema.maximum = valibotAction.requirement;
+      break;
+    case "metadata":
+      if (typeof valibotAction.metadata.title === "string") jsonSchema.title = valibotAction.metadata.title;
+      if (typeof valibotAction.metadata.description === "string") jsonSchema.description = valibotAction.metadata.description;
+      if (Array.isArray(valibotAction.metadata.examples)) if (Array.isArray(jsonSchema.examples)) jsonSchema.examples = [...jsonSchema.examples, ...valibotAction.metadata.examples];
+      else jsonSchema.examples = valibotAction.metadata.examples;
+      break;
+    case "min_entries":
+      jsonSchema.minProperties = valibotAction.requirement;
+      break;
+    case "min_length":
+      if (jsonSchema.type === "array") jsonSchema.minItems = valibotAction.requirement;
+      else {
+        if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
+        jsonSchema.minLength = valibotAction.requirement;
+      }
+      break;
+    case "min_value":
+      if (jsonSchema.type !== "number" && jsonSchema.type !== "integer") errors = addError(errors, `The "min_value" action is not supported on type "${jsonSchema.type}".`);
+      jsonSchema.minimum = valibotAction.requirement;
+      break;
+    case "multiple_of":
+      jsonSchema.multipleOf = valibotAction.requirement;
+      break;
+    case "non_empty":
+      if (jsonSchema.type === "array") jsonSchema.minItems = 1;
+      else {
+        if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
+        jsonSchema.minLength = 1;
+      }
+      break;
+    case "not_value":
+      if (!isJsonConstValue(valibotAction.requirement)) {
+        errors = addError(errors, 'The requirement of the "not_value" action is not JSON compatible.');
+        break;
+      }
+      if (config?.target === "openapi-3.0") jsonSchema.not = { enum: [valibotAction.requirement] };
+      else jsonSchema.not = { const: valibotAction.requirement };
+      break;
+    case "not_values":
+      if (!isJsonEnumValues(valibotAction.requirement)) {
+        errors = addError(errors, 'A requirement of the "not_values" action is not JSON compatible.');
+        break;
+      }
+      jsonSchema.not = { enum: valibotAction.requirement };
+      break;
+    case "regex":
+      if (valibotAction.requirement.flags) errors = addError(errors, "RegExp flags are not supported by JSON Schema.");
+      if (jsonSchema.pattern) errors = addError(errors, `The "${valibotAction.type}" action is not supported in combination with another regex action.`);
+      else jsonSchema.pattern = valibotAction.requirement.source;
+      break;
+    case "safe_integer":
+      jsonSchema.type = "integer";
+      if (typeof jsonSchema.minimum !== "number" || jsonSchema.minimum < Number.MIN_SAFE_INTEGER) jsonSchema.minimum = Number.MIN_SAFE_INTEGER;
+      if (typeof jsonSchema.maximum !== "number" || jsonSchema.maximum > Number.MAX_SAFE_INTEGER) jsonSchema.maximum = Number.MAX_SAFE_INTEGER;
+      break;
+    case "starts_with":
+      if (jsonSchema.pattern) errors = addError(errors, `The "${valibotAction.type}" action is not supported in combination with another regex action.`);
+      else jsonSchema.pattern = `^${escapeRegExp(valibotAction.requirement)}`;
+      break;
+    case "title":
+      jsonSchema.title = valibotAction.title;
+      break;
+    case "url":
+      jsonSchema.format = "uri";
+      break;
+    case "uuid":
+      jsonSchema.format = "uuid";
+      break;
+    case "value":
+      if (!isJsonConstValue(valibotAction.requirement)) {
+        errors = addError(errors, 'The requirement of the "value" action is not JSON compatible.');
+        break;
+      }
+      if (config?.target === "openapi-3.0") jsonSchema.enum = [valibotAction.requirement];
+      else jsonSchema.const = valibotAction.requirement;
+      break;
+    case "values":
+      if (!isJsonEnumValues(valibotAction.requirement)) {
+        errors = addError(errors, 'A requirement of the "values" action is not JSON compatible.');
+        break;
+      }
+      jsonSchema.enum = valibotAction.requirement;
+      break;
+    default:
+      errors = addError(errors, `The "${valibotAction.type}" action cannot be converted to JSON Schema.`);
+  }
+  if (config?.overrideAction) {
+    const actionOverride = config.overrideAction({
+      valibotAction,
+      jsonSchema,
+      errors
+    });
+    if (actionOverride) return { ...actionOverride };
+  }
+  if (errors) for (const message of errors) handleError(message, config);
+  return jsonSchema;
+}
+function flattenPipe(pipe2) {
+  return pipe2.flatMap((item) => "pipe" in item ? flattenPipe(item.pipe) : item);
+}
+var refCount = 0;
+function convertSchema(jsonSchema, valibotSchema, config, context, skipRef = false) {
+  if (!skipRef) {
+    const referenceId = context.referenceMap.get(valibotSchema);
+    if (referenceId) {
+      jsonSchema.$ref = `#/$defs/${referenceId}`;
+      if (config?.overrideRef) {
+        const refOverride = config.overrideRef({
+          ...context,
+          referenceId,
+          valibotSchema,
+          jsonSchema
+        });
+        if (refOverride) jsonSchema.$ref = refOverride;
+      }
+      return jsonSchema;
+    }
+  }
+  if ("pipe" in valibotSchema) {
+    const flatPipe = flattenPipe(valibotSchema.pipe);
+    let startIndex = 0;
+    let stopIndex = flatPipe.length - 1;
+    if (config?.typeMode === "input") {
+      const inputStopIndex = flatPipe.slice(1).findIndex((item) => item.kind === "schema" || item.kind === "transformation" && (item.type === "find_item" || item.type === "parse_json" || item.type === "raw_transform" || item.type === "reduce_items" || item.type === "stringify_json" || item.type === "to_bigint" || item.type === "to_boolean" || item.type === "to_date" || item.type === "to_number" || item.type === "to_string" || item.type === "transform"));
+      if (inputStopIndex !== -1) stopIndex = inputStopIndex;
+    } else if (config?.typeMode === "output") {
+      const outputStartIndex = flatPipe.findLastIndex((item) => item.kind === "schema");
+      if (outputStartIndex !== -1) startIndex = outputStartIndex;
+    }
+    for (let index = startIndex; index <= stopIndex; index++) {
+      const valibotPipeItem = flatPipe[index];
+      if (valibotPipeItem.kind === "schema") {
+        if (index > startIndex) handleError('Set the "typeMode" config to "input" or "output" to convert pipelines with multiple schemas.', config);
+        jsonSchema = convertSchema(jsonSchema, valibotPipeItem, config, context, true);
+      } else jsonSchema = convertAction(jsonSchema, valibotPipeItem, config);
+    }
+    return jsonSchema;
+  }
+  let errors;
+  switch (valibotSchema.type) {
+    case "boolean":
+      jsonSchema.type = "boolean";
+      break;
+    case "null":
+      if (config?.target === "openapi-3.0") jsonSchema.enum = [null];
+      else jsonSchema.type = "null";
+      break;
+    case "number":
+      jsonSchema.type = "number";
+      break;
+    case "string":
+      jsonSchema.type = "string";
+      break;
+    case "array":
+      jsonSchema.type = "array";
+      jsonSchema.items = convertSchema({}, valibotSchema.item, config, context);
+      break;
+    case "tuple":
+    case "tuple_with_rest":
+    case "loose_tuple":
+    case "strict_tuple":
+      jsonSchema.type = "array";
+      if (config?.target === "openapi-3.0") {
+        jsonSchema.items = { anyOf: [] };
+        jsonSchema.minItems = valibotSchema.items.length;
+        for (const item of valibotSchema.items) jsonSchema.items.anyOf.push(convertSchema({}, item, config, context));
+        if (valibotSchema.type === "tuple_with_rest") jsonSchema.items.anyOf.push(convertSchema({}, valibotSchema.rest, config, context));
+        else if (valibotSchema.type === "strict_tuple" || valibotSchema.type === "tuple") jsonSchema.maxItems = valibotSchema.items.length;
+      } else if (config?.target === "draft-2020-12") {
+        jsonSchema.prefixItems = [];
+        jsonSchema.minItems = valibotSchema.items.length;
+        for (const item of valibotSchema.items) jsonSchema.prefixItems.push(convertSchema({}, item, config, context));
+        if (valibotSchema.type === "tuple_with_rest") jsonSchema.items = convertSchema({}, valibotSchema.rest, config, context);
+        else if (valibotSchema.type === "strict_tuple") jsonSchema.items = false;
+      } else {
+        jsonSchema.items = [];
+        jsonSchema.minItems = valibotSchema.items.length;
+        for (const item of valibotSchema.items) jsonSchema.items.push(convertSchema({}, item, config, context));
+        if (valibotSchema.type === "tuple_with_rest") jsonSchema.additionalItems = convertSchema({}, valibotSchema.rest, config, context);
+        else if (valibotSchema.type === "strict_tuple") jsonSchema.additionalItems = false;
+      }
+      break;
+    case "object":
+    case "object_with_rest":
+    case "loose_object":
+    case "strict_object":
+      jsonSchema.type = "object";
+      jsonSchema.properties = {};
+      jsonSchema.required = [];
+      for (const key in valibotSchema.entries) {
+        const entry = valibotSchema.entries[key];
+        jsonSchema.properties[key] = convertSchema({}, entry, config, context);
+        if (entry.type !== "exact_optional" && entry.type !== "nullish" && entry.type !== "optional") jsonSchema.required.push(key);
+      }
+      if (valibotSchema.type === "object_with_rest") jsonSchema.additionalProperties = convertSchema({}, valibotSchema.rest, config, context);
+      else if (valibotSchema.type === "strict_object") jsonSchema.additionalProperties = false;
+      break;
+    case "record":
+      if (config?.target === "openapi-3.0" && "pipe" in valibotSchema.key) errors = addError(errors, 'The "record" schema with a schema for the key that contains a "pipe" cannot be converted to JSON Schema.');
+      if (valibotSchema.key.type !== "string") errors = addError(errors, `The "record" schema with the "${valibotSchema.key.type}" schema for the key cannot be converted to JSON Schema.`);
+      jsonSchema.type = "object";
+      if (config?.target !== "openapi-3.0") jsonSchema.propertyNames = convertSchema({}, valibotSchema.key, config, context);
+      jsonSchema.additionalProperties = convertSchema({}, valibotSchema.value, config, context);
+      break;
+    case "any":
+    case "unknown":
+      break;
+    case "never":
+      jsonSchema.not = {};
+      break;
+    case "nullable":
+    case "nullish":
+      if (config?.target === "openapi-3.0") {
+        const innerSchema = convertSchema({}, valibotSchema.wrapped, config, context);
+        Object.assign(jsonSchema, innerSchema);
+        jsonSchema.nullable = true;
+      } else jsonSchema.anyOf = [convertSchema({}, valibotSchema.wrapped, config, context), { type: "null" }];
+      if (valibotSchema.default !== void 0) jsonSchema.default = typeof valibotSchema.default === "function" ? valibotSchema.default() : valibotSchema.default;
+      break;
+    case "exact_optional":
+    case "optional":
+    case "undefinedable":
+      jsonSchema = convertSchema(jsonSchema, valibotSchema.wrapped, config, context);
+      if (valibotSchema.default !== void 0) jsonSchema.default = typeof valibotSchema.default === "function" ? valibotSchema.default() : valibotSchema.default;
+      break;
+    case "literal":
+      if (typeof valibotSchema.literal !== "boolean" && typeof valibotSchema.literal !== "number" && typeof valibotSchema.literal !== "string") errors = addError(errors, 'The value of the "literal" schema is not JSON compatible.');
+      if (config?.target === "openapi-3.0") jsonSchema.enum = [valibotSchema.literal];
+      else jsonSchema.const = valibotSchema.literal;
+      break;
+    case "enum":
+      jsonSchema.enum = valibotSchema.options;
+      if (valibotSchema.options.every((option) => typeof option === "string")) jsonSchema.type = "string";
+      else if (valibotSchema.options.every((option) => typeof option === "number")) jsonSchema.type = "number";
+      else if (config?.target !== "openapi-3.0") jsonSchema.type = ["string", "number"];
+      break;
+    case "picklist": {
+      const hasInvalidOption = valibotSchema.options.some((option) => typeof option !== "number" && typeof option !== "string");
+      if (hasInvalidOption) errors = addError(errors, 'An option of the "picklist" schema is not JSON compatible.');
+      jsonSchema.enum = valibotSchema.options;
+      if (valibotSchema.options.every((option) => typeof option === "string")) jsonSchema.type = "string";
+      else if (valibotSchema.options.every((option) => typeof option === "number")) jsonSchema.type = "number";
+      else if (!hasInvalidOption && config?.target !== "openapi-3.0") jsonSchema.type = ["string", "number"];
+      break;
+    }
+    case "union":
+      jsonSchema.anyOf = valibotSchema.options.map((option) => convertSchema({}, option, config, context));
+      break;
+    case "variant":
+      jsonSchema.oneOf = valibotSchema.options.map((option) => convertSchema({}, option, config, context));
+      break;
+    case "intersect":
+      jsonSchema.allOf = valibotSchema.options.map((option) => convertSchema({}, option, config, context));
+      break;
+    case "lazy": {
+      let wrappedValibotSchema = context.getterMap.get(valibotSchema.getter);
+      if (!wrappedValibotSchema) {
+        wrappedValibotSchema = valibotSchema.getter(void 0);
+        context.getterMap.set(valibotSchema.getter, wrappedValibotSchema);
+      }
+      let referenceId = context.referenceMap.get(wrappedValibotSchema);
+      if (!referenceId) {
+        referenceId = `${refCount++}`;
+        context.referenceMap.set(wrappedValibotSchema, referenceId);
+        context.definitions[referenceId] = convertSchema({}, wrappedValibotSchema, config, context, true);
+      }
+      jsonSchema.$ref = `#/$defs/${referenceId}`;
+      if (config?.overrideRef) {
+        const refOverride = config.overrideRef({
+          ...context,
+          referenceId,
+          valibotSchema: wrappedValibotSchema,
+          jsonSchema
+        });
+        if (refOverride) jsonSchema.$ref = refOverride;
+      }
+      break;
+    }
+    default:
+      errors = addError(errors, `The "${valibotSchema.type}" schema cannot be converted to JSON Schema.`);
+  }
+  if (config?.overrideSchema) {
+    const schemaOverride = config.overrideSchema({
+      ...context,
+      referenceId: context.referenceMap.get(valibotSchema),
+      valibotSchema,
+      jsonSchema,
+      errors
+    });
+    if (schemaOverride) return { ...schemaOverride };
+  }
+  if (errors) for (const message of errors) handleError(message, config);
+  return jsonSchema;
+}
+var store;
+function getGlobalDefs() {
+  return store;
+}
+function toJsonSchema(schema6, config) {
+  const context = {
+    definitions: {},
+    referenceMap: /* @__PURE__ */ new Map(),
+    getterMap: /* @__PURE__ */ new Map()
+  };
+  const definitions = config?.definitions ?? getGlobalDefs();
+  if (definitions) {
+    for (const key in definitions) context.referenceMap.set(definitions[key], key);
+    for (const key in definitions) context.definitions[key] = convertSchema({}, definitions[key], config, context, true);
+  }
+  const jsonSchema = convertSchema({}, schema6, config, context);
+  const target = config?.target ?? "draft-07";
+  if (target === "draft-2020-12") jsonSchema.$schema = "https://json-schema.org/draft/2020-12/schema";
+  else if (target === "draft-07") jsonSchema.$schema = "http://json-schema.org/draft-07/schema#";
+  if (context.referenceMap.size) jsonSchema.$defs = context.definitions;
+  return jsonSchema;
+}
+
+// ../../node_modules/.pnpm/@tmcp+adapter-valibot@0.1.6_tmcp@1.19.4_typescript@5.9.3__valibot@1.4.1_typescript@5.9.3_/node_modules/@tmcp/adapter-valibot/src/index.js
+function add_type_to_enums(json_schema) {
+  for (let key in json_schema) {
+    const property = json_schema[
+      /** @type {keyof json_schema} */
+      key
+    ];
+    if (property != null && typeof property === "object" && !Array.isArray(property)) {
+      if ("enum" in property && !("type" in property)) {
+        property.type = "string";
+      }
+      add_type_to_enums(property);
+    }
+  }
+  return json_schema;
+}
+var ValibotJsonSchemaAdapter = class extends JsonSchemaAdapter {
+  /**
+   * Converts a Valibot schema to JSON Schema format
+   * @param {GenericSchema} schema - The Valibot schema to convert
+   * @returns {Promise<ReturnType<typeof toJsonSchema>>} - The converted JSON Schema
+   */
+  async toJsonSchema(schema6) {
+    return add_type_to_enums(toJsonSchema(schema6));
+  }
+};
+
+// ../mcp-server/src/mcp/index.ts
+import { McpServer } from "tmcp";
+
+// ../mcp-server/src/mcp/handlers/tools/index.ts
+var tools_exports = {};
+__export(tools_exports, {
+  get_component: () => get_component,
+  get_component_demo: () => get_component_demo,
+  get_utils: () => get_utils,
+  list_components: () => list_components,
+  list_exports: () => list_exports,
+  search_components: () => search_components
+});
+
+// ../../node_modules/.pnpm/valibot@1.4.1_typescript@5.9.3/node_modules/valibot/dist/index.mjs
+var store$4;
+var DEFAULT_CONFIG = {
+  lang: void 0,
+  message: void 0,
+  abortEarly: void 0,
+  abortPipeEarly: void 0
+};
+// @__NO_SIDE_EFFECTS__
+function getGlobalConfig(config$1) {
+  if (!config$1 && !store$4) return DEFAULT_CONFIG;
+  return {
+    lang: config$1?.lang ?? store$4?.lang,
+    message: config$1?.message,
+    abortEarly: config$1?.abortEarly ?? store$4?.abortEarly,
+    abortPipeEarly: config$1?.abortPipeEarly ?? store$4?.abortPipeEarly
+  };
+}
+var store$3;
+// @__NO_SIDE_EFFECTS__
+function getGlobalMessage(lang) {
+  return store$3?.get(lang);
+}
+var store$2;
+// @__NO_SIDE_EFFECTS__
+function getSchemaMessage(lang) {
+  return store$2?.get(lang);
+}
+var store$1;
+// @__NO_SIDE_EFFECTS__
+function getSpecificMessage(reference, lang) {
+  return store$1?.get(reference)?.get(lang);
+}
+// @__NO_SIDE_EFFECTS__
+function _stringify(input) {
+  const type = typeof input;
+  if (type === "string") return `"${input}"`;
+  if (type === "number" || type === "bigint" || type === "boolean") return `${input}`;
+  if (type === "object" || type === "function") return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
+  return type;
+}
+function _addIssue(context, label, dataset, config$1, other) {
+  const input = other && "input" in other ? other.input : dataset.value;
+  const expected = other?.expected ?? context.expects ?? null;
+  const received = other?.received ?? /* @__PURE__ */ _stringify(input);
+  const issue = {
+    kind: context.kind,
+    type: context.type,
+    input,
+    expected,
+    received,
+    message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
+    requirement: context.requirement,
+    path: other?.path,
+    issues: other?.issues,
+    lang: config$1.lang,
+    abortEarly: config$1.abortEarly,
+    abortPipeEarly: config$1.abortPipeEarly
+  };
+  const isSchema = context.kind === "schema";
+  const message$1 = other?.message ?? context.message ?? /* @__PURE__ */ getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage(issue.lang) : null) ?? config$1.message ?? /* @__PURE__ */ getGlobalMessage(issue.lang);
+  if (message$1 !== void 0) issue.message = typeof message$1 === "function" ? message$1(issue) : message$1;
+  if (isSchema) dataset.typed = false;
+  if (dataset.issues) dataset.issues.push(issue);
+  else dataset.issues = [issue];
+}
+var _standardCache = /* @__PURE__ */ new WeakMap();
+// @__NO_SIDE_EFFECTS__
+function _getStandardProps(context) {
+  let cached = _standardCache.get(context);
+  if (!cached) {
+    cached = {
+      version: 1,
+      vendor: "valibot",
+      validate(value$1) {
+        return context["~run"]({ value: value$1 }, /* @__PURE__ */ getGlobalConfig());
+      }
+    };
+    _standardCache.set(context, cached);
+  }
+  return cached;
+}
+// @__NO_SIDE_EFFECTS__
+function _joinExpects(values$1, separator) {
+  const list = [...new Set(values$1)];
+  if (list.length > 1) return `(${list.join(` ${separator} `)})`;
+  return list[0] ?? "never";
+}
+var EMOJI_REGEX = new RegExp("^(?:[\\u{1F1E6}-\\u{1F1FF}]{2}|\\u{1F3F4}[\\u{E0061}-\\u{E007A}]{2}[\\u{E0030}-\\u{E0039}\\u{E0061}-\\u{E007A}]{1,3}\\u{E007F}|(?:\\p{Emoji}\\uFE0F\\u20E3?|\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|(?![\\p{Emoji_Modifier_Base}\\u{1F1E6}-\\u{1F1FF}])\\p{Emoji_Presentation})(?:\\u200D(?:\\p{Emoji}\\uFE0F\\u20E3?|\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|(?![\\p{Emoji_Modifier_Base}\\u{1F1E6}-\\u{1F1FF}])\\p{Emoji_Presentation}))*)+$", "u");
+// @__NO_SIDE_EFFECTS__
+function description(description_) {
+  return {
+    kind: "metadata",
+    type: "description",
+    reference: description,
+    description: description_
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function integer(message$1) {
+  return {
+    kind: "validation",
+    type: "integer",
+    reference: integer,
+    async: false,
+    expects: null,
+    requirement: Number.isInteger,
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && !this.requirement(dataset.value)) _addIssue(this, "integer", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function maxValue(requirement, message$1) {
+  return {
+    kind: "validation",
+    type: "max_value",
+    reference: maxValue,
+    async: false,
+    expects: `<=${requirement instanceof Date ? requirement.toJSON() : /* @__PURE__ */ _stringify(requirement)}`,
+    requirement,
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && !(dataset.value <= this.requirement)) _addIssue(this, "value", dataset, config$1, { received: dataset.value instanceof Date ? dataset.value.toJSON() : /* @__PURE__ */ _stringify(dataset.value) });
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function minLength(requirement, message$1) {
+  return {
+    kind: "validation",
+    type: "min_length",
+    reference: minLength,
+    async: false,
+    expects: `>=${requirement}`,
+    requirement,
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && dataset.value.length < this.requirement) _addIssue(this, "length", dataset, config$1, { received: `${dataset.value.length}` });
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function minValue(requirement, message$1) {
+  return {
+    kind: "validation",
+    type: "min_value",
+    reference: minValue,
+    async: false,
+    expects: `>=${requirement instanceof Date ? requirement.toJSON() : /* @__PURE__ */ _stringify(requirement)}`,
+    requirement,
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && !(dataset.value >= this.requirement)) _addIssue(this, "value", dataset, config$1, { received: dataset.value instanceof Date ? dataset.value.toJSON() : /* @__PURE__ */ _stringify(dataset.value) });
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function getFallback(schema6, dataset, config$1) {
+  return typeof schema6.fallback === "function" ? schema6.fallback(dataset, config$1) : schema6.fallback;
+}
+// @__NO_SIDE_EFFECTS__
+function getDefault(schema6, dataset, config$1) {
+  return typeof schema6.default === "function" ? schema6.default(dataset, config$1) : schema6.default;
+}
+// @__NO_SIDE_EFFECTS__
+function number(message$1) {
+  return {
+    kind: "schema",
+    type: "number",
+    reference: number,
+    expects: "number",
+    async: false,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (typeof dataset.value === "number" && !isNaN(dataset.value)) dataset.typed = true;
+      else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function object(entries$1, message$1) {
+  return {
+    kind: "schema",
+    type: "object",
+    reference: object,
+    expects: "Object",
+    async: false,
+    entries: entries$1,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        dataset.typed = true;
+        dataset.value = {};
+        for (const key in this.entries) {
+          const valueSchema = this.entries[key];
+          if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
+            const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
+            const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
+            if (valueDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "value",
+                input,
+                key,
+                value: value$1
+              };
+              for (const issue of valueDataset.issues) {
+                if (issue.path) issue.path.unshift(pathItem);
+                else issue.path = [pathItem];
+                dataset.issues?.push(issue);
+              }
+              if (!dataset.issues) dataset.issues = valueDataset.issues;
+              if (config$1.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            if (!valueDataset.typed) dataset.typed = false;
+            dataset.value[key] = valueDataset.value;
+          } else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+          else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+            _addIssue(this, "key", dataset, config$1, {
+              input: void 0,
+              expected: `"${key}"`,
+              path: [{
+                type: "object",
+                origin: "key",
+                input,
+                key,
+                value: input[key]
+              }]
+            });
+            if (config$1.abortEarly) break;
+          }
+        }
+      } else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function optional(wrapped, default_) {
+  return {
+    kind: "schema",
+    type: "optional",
+    reference: optional,
+    expects: `(${wrapped.expects} | undefined)`,
+    async: false,
+    wrapped,
+    default: default_,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (dataset.value === void 0) {
+        if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
+        if (dataset.value === void 0) {
+          dataset.typed = true;
+          return dataset;
+        }
+      }
+      return this.wrapped["~run"](dataset, config$1);
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function picklist(options, message$1) {
+  return {
+    kind: "schema",
+    type: "picklist",
+    reference: picklist,
+    expects: /* @__PURE__ */ _joinExpects(options.map(_stringify), "|"),
+    async: false,
+    options,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (this.options.includes(dataset.value)) dataset.typed = true;
+      else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function string(message$1) {
+  return {
+    kind: "schema",
+    type: "string",
+    reference: string,
+    expects: "string",
+    async: false,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (typeof dataset.value === "string") dataset.typed = true;
+      else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function pipe(...pipe$1) {
+  return {
+    ...pipe$1[0],
+    pipe: pipe$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      for (const item of pipe$1) if (item.kind !== "metadata") {
+        if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
+          dataset.typed = false;
+          break;
+        }
+        if (!dataset.issues || !config$1.abortEarly && !config$1.abortPipeEarly) dataset = item["~run"](dataset, config$1);
+      }
+      return dataset;
+    }
+  };
+}
+
+// ../mcp-server/src/mcp/handlers/tools/list-components.ts
+import { tool } from "tmcp/utils";
+
+// ../mcp-server/src/constants.ts
+import { resolve } from "path";
+import { fileURLToPath } from "url";
+var PKG_DIR = fileURLToPath(new URL("..", import.meta.url));
+var ALUS_ROOT = process.env.ALUS_ROOT ?? resolve(PKG_DIR, "../..");
+var COMPONENTS_DIR = `${ALUS_ROOT}/packages/alus/src/lib/components`;
+var ROUTES_DIR = `${ALUS_ROOT}/src/routes/components`;
+var UTILS_ROOT = `${ALUS_ROOT}/packages/alus/src/lib/utils`;
+var CHARACTER_LIMIT = 25e3;
+var CATEGORIES = [
+  "form",
+  "navigation",
+  "feedback",
+  "display",
+  "overlay",
+  "layout",
+  "interactive",
+  "utility"
+];
+
+// ../mcp-server/src/lib/fs.ts
+import { readdir, readFile } from "fs/promises";
+async function list_all_components() {
+  const entries = [];
+  for (const category of CATEGORIES) {
+    const cat_dir = `${COMPONENTS_DIR}/${category}`;
+    let items;
+    try {
+      items = await readdir(cat_dir);
+    } catch {
+      continue;
+    }
+    for (const item of items) {
+      const comp_dir = `${cat_dir}/${item}`;
+      let files;
+      try {
+        files = await readdir(comp_dir);
+      } catch {
+        continue;
+      }
+      const source_files = files.filter((f) => f.endsWith(".svelte") || f.endsWith(".ts"));
+      if (!source_files.length) continue;
+      const name = item.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+      entries.push({ name, category, dir: comp_dir, files: source_files });
+    }
+  }
+  return entries;
+}
+async function read_component_source(entry) {
+  const parts = [];
+  for (const file of entry.files) {
+    const content = await readFile(`${entry.dir}/${file}`, "utf-8");
+    parts.push(`// FILE: ${file}
+${content}`);
+  }
+  return parts.join("\n\n");
+}
+function truncate(text, hint) {
+  if (text.length <= CHARACTER_LIMIT) return text;
+  return text.slice(0, CHARACTER_LIMIT) + `
+
+[... truncated. ${hint}]`;
+}
+
+// ../mcp-server/src/mcp/handlers/tools/list-components.ts
+var schema = object({
+  category: optional(
+    picklist(CATEGORIES, "Must be one of the alus-ui component categories")
+  ),
+  response_format: optional(picklist(["markdown", "json"]), "markdown")
+});
+async function list_components_handler(params) {
+  const { category, response_format = "markdown" } = params;
+  const all = await list_all_components();
+  const filtered = category ? all.filter((c) => c.category === category) : all;
+  if (response_format === "json") {
+    return JSON.stringify(
+      {
+        total: filtered.length,
+        components: filtered.map((c) => ({
+          name: c.name,
+          category: c.category,
+          dir: c.dir.replace(`${COMPONENTS_DIR}/`, "")
+        }))
+      },
+      null,
+      2
+    );
+  }
+  const grouped = {};
+  for (const c of filtered) {
+    (grouped[c.category] ??= []).push(c.name);
+  }
+  const lines = [`# alus-ui Components (${filtered.length} total)`, ""];
+  for (const [cat, names] of Object.entries(grouped)) {
+    lines.push(`## ${cat}`, "", names.map((n) => `- ${n}`).join("\n"), "");
+  }
+  return lines.join("\n");
+}
+function list_components(server2) {
+  server2.tool(
+    {
+      name: "alus_list_components",
+      description: "List all components in the alus-ui Svelte 5 library grouped by category. Call this first to discover component names before using alus_get_component. Optionally filter by category.",
+      schema,
+      annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false }
+    },
+    async (params) => {
+      try {
+        return tool.text(await list_components_handler(params));
+      } catch (e) {
+        return tool.error(e.message);
+      }
+    }
+  );
+}
+
+// ../mcp-server/src/mcp/handlers/tools/get-component.ts
+import { tool as tool2 } from "tmcp/utils";
+var schema2 = object({
+  name: pipe(
+    string(),
+    description("Component name, case-insensitive (e.g. 'Button', 'accordion', 'date-picker')")
+  ),
+  category: optional(picklist(CATEGORIES, "Narrow search when name is ambiguous"))
+});
+function get_component(server2) {
+  server2.tool(
+    {
+      name: "alus_get_component",
+      description: "Read the full source of an alus-ui component (.svelte + index.ts). Use alus_list_components first to find valid names. Supports partial, case-insensitive matching (e.g. 'button', 'Button', 'date-picker').",
+      schema: schema2,
+      annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false }
+    },
+    async ({ name, category }) => {
+      try {
+        const all = await list_all_components();
+        const needle = name.toLowerCase().replace(/[-_\s]/g, "");
+        let matches = all.filter(
+          (c) => c.name.toLowerCase().replace(/[-_\s]/g, "") === needle
+        );
+        if (category) matches = matches.filter((c) => c.category === category);
+        if (!matches.length) {
+          const similar = all.filter(
+            (c) => c.name.toLowerCase().includes(needle) || needle.includes(c.name.toLowerCase())
+          ).map((c) => `${c.name} (${c.category})`).slice(0, 5).join(", ");
+          return tool2.text(
+            `Component '${name}' not found.${similar ? ` Similar: ${similar}` : " Use alus_list_components to browse."}`
+          );
+        }
+        const entry = matches[0];
+        const src = await read_component_source(entry);
+        return tool2.text(
+          truncate(
+            `# ${entry.name} (${entry.category})
+
+${src}`,
+            "Use alus_search_components for targeted lookup."
+          )
+        );
+      } catch (e) {
+        return tool2.error(e.message);
+      }
+    }
+  );
+}
+
+// ../mcp-server/src/mcp/handlers/tools/search-components.ts
+import { tool as tool3 } from "tmcp/utils";
+import { readFile as readFile2 } from "fs/promises";
+var schema3 = object({
+  query: pipe(string(), minLength(2), description("Case-insensitive search string")),
+  category: optional(picklist(CATEGORIES)),
+  limit: optional(pipe(number(), integer(), minValue(1), maxValue(50)), 20),
+  response_format: optional(picklist(["markdown", "json"]), "markdown")
+});
+function search_components(server2) {
+  server2.tool(
+    {
+      name: "alus_search_components",
+      description: "Full-text search across all alus-ui component source files. Useful for finding which component uses a specific prop, ARIA pattern, utility function, or type. Returns matches with \xB12 lines of context.",
+      schema: schema3,
+      annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false }
+    },
+    async ({ query, category, limit = 20, response_format = "markdown" }) => {
+      try {
+        const all = await list_all_components();
+        const pool = category ? all.filter((c) => c.category === category) : all;
+        const needle = query.toLowerCase();
+        const hits = [];
+        for (const entry of pool) {
+          if (hits.length >= limit) break;
+          for (const file of entry.files) {
+            if (hits.length >= limit) break;
+            const content = await readFile2(`${entry.dir}/${file}`, "utf-8");
+            const lines2 = content.split("\n");
+            for (let i = 0; i < lines2.length; i++) {
+              if (lines2[i].toLowerCase().includes(needle)) {
+                const start = Math.max(0, i - 2);
+                const end = Math.min(lines2.length - 1, i + 2);
+                hits.push({
+                  component: entry.name,
+                  category: entry.category,
+                  file,
+                  line: i + 1,
+                  context: lines2.slice(start, end + 1).join("\n")
+                });
+                if (hits.length >= limit) break;
+              }
+            }
+          }
+        }
+        if (!hits.length) return tool3.text(`No results for '${query}'.`);
+        if (response_format === "json") {
+          return tool3.text(JSON.stringify({ query, total: hits.length, hits }, null, 2));
+        }
+        const lines = [`# Search: '${query}' \u2014 ${hits.length} hit(s)`, ""];
+        for (const h of hits) {
+          lines.push(
+            `## ${h.component} (${h.category}) \xB7 ${h.file}:${h.line}`,
+            "```svelte",
+            h.context,
+            "```",
+            ""
+          );
+        }
+        return tool3.text(truncate(lines.join("\n"), "Narrow with category or a more specific query."));
+      } catch (e) {
+        return tool3.error(e.message);
+      }
+    }
+  );
+}
+
+// ../mcp-server/src/mcp/handlers/tools/get-component-demo.ts
+import { tool as tool4 } from "tmcp/utils";
+import { readFile as readFile3, readdir as readdir2 } from "fs/promises";
+var schema4 = object({
+  name: pipe(
+    string(),
+    description("Component route folder name, lowercase hyphenated (e.g. 'button', 'date-picker')")
+  )
+});
+function get_component_demo(server2) {
+  server2.tool(
+    {
+      name: "alus_get_component_demo",
+      description: "Read the SvelteKit showcase demo page for a component. Shows real usage with props, events, and the Japanese Creative aesthetic. Path: src/routes/components/{name}/+page.svelte.",
+      schema: schema4,
+      annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false }
+    },
+    async ({ name }) => {
+      try {
+        const demo_path = `${ROUTES_DIR}/${name.toLowerCase()}/+page.svelte`;
+        let content;
+        try {
+          content = await readFile3(demo_path, "utf-8");
+        } catch {
+          let available = [];
+          try {
+            available = await readdir2(ROUTES_DIR);
+          } catch {
+          }
+          const hint = available.length ? ` Available: ${available.slice(0, 10).join(", ")}${available.length > 10 ? "\u2026" : ""}` : "";
+          return tool4.text(`Demo not found for '${name}'.${hint}`);
+        }
+        return tool4.text(
+          truncate(
+            `# Demo: ${name}
+\`\`\`svelte
+${content}
+\`\`\``,
+            "Use alus_get_component for source."
+          )
+        );
+      } catch (e) {
+        return tool4.error(e.message);
+      }
+    }
+  );
+}
+
+// ../mcp-server/src/mcp/handlers/tools/list-exports.ts
+import { tool as tool5 } from "tmcp/utils";
+import { readFile as readFile4 } from "fs/promises";
+function list_exports(server2) {
+  server2.tool(
+    {
+      name: "alus_list_exports",
+      description: "Return the full contents of packages/alus/src/lib/components/index.ts \u2014 the canonical public API of alus-ui with exact import paths, exported types, and context helpers.",
+      annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false }
+    },
+    async () => {
+      try {
+        const content = await readFile4(`${COMPONENTS_DIR}/index.ts`, "utf-8");
+        return tool5.text(`\`\`\`typescript
+${content}
+\`\`\``);
+      } catch (e) {
+        return tool5.error(e.message);
+      }
+    }
+  );
+}
+
+// ../mcp-server/src/mcp/handlers/tools/get-utils.ts
+import { tool as tool6 } from "tmcp/utils";
+import { readFile as readFile5 } from "fs/promises";
+var MODULES = ["aria", "focus", "id", "keyboard", "index", "form/state"];
+var schema5 = object({
+  module: picklist(MODULES, "Utility module \u2014 one of: aria, focus, id, keyboard, index, form/state")
+});
+function get_utils(server2) {
+  server2.tool(
+    {
+      name: "alus_get_utils",
+      description: "Read source of an alus-ui utility module (a11y helpers, form state). Available: aria, focus, id, keyboard, index, form/state.",
+      schema: schema5,
+      annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false }
+    },
+    async ({ module }) => {
+      try {
+        const path = module === "index" ? `${UTILS_ROOT}/a11y/index.ts` : module === "form/state" ? `${UTILS_ROOT}/form/state.ts` : `${UTILS_ROOT}/a11y/${module}.ts`;
+        const content = await readFile5(path, "utf-8");
+        return tool6.text(`\`\`\`typescript
+${content}
+\`\`\``);
+      } catch (e) {
+        return tool6.error(e.message);
+      }
+    }
+  );
+}
+
+// ../mcp-server/src/mcp/handlers/index.ts
+function setup_tools(server2) {
+  for (const tool7 in tools_exports) {
+    tools_exports[tool7](server2);
+  }
+}
+
+// ../mcp-server/src/mcp/index.ts
+var server = new McpServer(
+  {
+    name: "alus-ui MCP",
+    version: "0.0.1",
+    description: "MCP server for the alus-ui Svelte 5 component library"
+  },
+  {
+    adapter: new ValibotJsonSchemaAdapter(),
+    capabilities: { tools: {} },
+    instructions: "This MCP server provides direct access to alus-ui \u2014 an unstyled, accessible Svelte 5 component library. Use it to browse components, read source, search patterns, and find usage examples. Always call alus_list_components first to discover available components."
+  }
+).withContext();
+setup_tools(server);
+
+// src/index.ts
+import { StdioTransport } from "@tmcp/transport-stdio";
+var transport = new StdioTransport(server);
+transport.listen();

package/package.json

@@ -0,0 +1,71 @@
+{
+	"name": "alus-ui-mcp",
+	"version": "0.1.0",
+	"description": "MCP stdio server for the alus-ui Svelte 5 component library — gives LLMs direct access to component source, demos, exports, and utilities",
+	"license": "MIT",
+	"type": "module",
+	"author": {
+		"name": "Hanivan Rizky",
+		"email": "hanivan20@gmail.com"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/Hanivan/alus.git"
+	},
+	"homepage": "https://github.com/Hanivan/alus#readme",
+	"bugs": {
+		"url": "https://github.com/Hanivan/alus/issues"
+	},
+	"keywords": [
+		"mcp",
+		"model-context-protocol",
+		"svelte",
+		"svelte5",
+		"ui-components",
+		"alus-ui",
+		"llm",
+		"claude",
+		"cursor",
+		"ai"
+	],
+	"bin": {
+		"alus-mcp": "./dist/index.js"
+	},
+	"files": [
+		"dist",
+		"!dist/**/*.test.*",
+		"!dist/**/*.spec.*"
+	],
+	"scripts": {
+		"build": "tsup",
+		"dev:build": "tsup --watch",
+		"dev": "tsx watch src/index.ts",
+		"start": "tsx src/index.ts",
+		"prepublishOnly": "npm run build",
+		"release": "release-it",
+		"release:dry": "release-it --dry-run",
+		"release:patch": "release-it patch",
+		"release:minor": "release-it minor",
+		"release:major": "release-it major"
+	},
+	"dependencies": {
+		"@alus-ui/mcp-server": "workspace:*",
+		"@tmcp/transport-stdio": "latest",
+		"tmcp": "latest"
+	},
+	"devDependencies": {
+		"@release-it/conventional-changelog": "latest",
+		"publint": "latest",
+		"release-it": "latest",
+		"tsup": "latest",
+		"tsx": "latest",
+		"typescript": "^6.0.2"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"engines": {
+		"node": ">=18.0.0",
+		"pnpm": ">=8.0.0"
+	}
+}