@ahrowe/ui 0.35.0 → 0.37.0

package/dist/mcp.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import process from "node:process";
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 //#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -4959,7 +4959,7 @@ var Doc = class {
 };
 //#endregion
 //#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/versions.js
-var version = {
+var version$1 = {
 	major: 4,
 	minor: 6,
 	patch: 5
@@ -4971,7 +4971,7 @@ var $ZodType = /*@__PURE__*/ $constructor("$ZodType", (inst, def) => {
 	inst ?? (inst = {});
 	inst._zod.def = def;
 	inst._zod.bag = inst._zod.bag || {};
-	inst._zod.version = version;
+	inst._zod.version = version$1;
 	const defChecks = inst._zod.def.checks;
 	const checks = inst._zod.traits.has("$ZodCheck") ? [inst, ...defChecks ?? []] : defChecks?.length ? [...defChecks] : [];
 	for (const ch of checks) for (const fn of ch._zod.onattach) fn(inst);
@@ -20277,6 +20277,203 @@ var McpZodTypeKind;
 	McpZodTypeKind["Completable"] = "McpCompletable";
 })(McpZodTypeKind || (McpZodTypeKind = {}));
 //#endregion
+//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.30.0_zod@4.6.5/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/uriTemplate.js
+var MAX_TEMPLATE_LENGTH = 1e6;
+var MAX_VARIABLE_LENGTH = 1e6;
+var MAX_TEMPLATE_EXPRESSIONS = 1e4;
+var MAX_REGEX_LENGTH = 1e6;
+var UriTemplate = class UriTemplate {
+	/**
+	* Returns true if the given string contains any URI template expressions.
+	* A template expression is a sequence of characters enclosed in curly braces,
+	* like {foo} or {?bar}.
+	*/
+	static isTemplate(str) {
+		return /\{[^}\s]+\}/.test(str);
+	}
+	static validateLength(str, max, context) {
+		if (str.length > max) throw new Error(`${context} exceeds maximum length of ${max} characters (got ${str.length})`);
+	}
+	get variableNames() {
+		return this.parts.flatMap((part) => typeof part === "string" ? [] : part.names);
+	}
+	constructor(template) {
+		UriTemplate.validateLength(template, MAX_TEMPLATE_LENGTH, "Template");
+		this.template = template;
+		this.parts = this.parse(template);
+	}
+	toString() {
+		return this.template;
+	}
+	parse(template) {
+		const parts = [];
+		let currentText = "";
+		let i = 0;
+		let expressionCount = 0;
+		while (i < template.length) if (template[i] === "{") {
+			if (currentText) {
+				parts.push(currentText);
+				currentText = "";
+			}
+			const end = template.indexOf("}", i);
+			if (end === -1) throw new Error("Unclosed template expression");
+			expressionCount++;
+			if (expressionCount > MAX_TEMPLATE_EXPRESSIONS) throw new Error(`Template contains too many expressions (max ${MAX_TEMPLATE_EXPRESSIONS})`);
+			const expr = template.slice(i + 1, end);
+			const operator = this.getOperator(expr);
+			const exploded = expr.includes("*");
+			const names = this.getNames(expr);
+			const name = names[0];
+			for (const name of names) UriTemplate.validateLength(name, MAX_VARIABLE_LENGTH, "Variable name");
+			parts.push({
+				name,
+				operator,
+				names,
+				exploded
+			});
+			i = end + 1;
+		} else {
+			currentText += template[i];
+			i++;
+		}
+		if (currentText) parts.push(currentText);
+		return parts;
+	}
+	getOperator(expr) {
+		return [
+			"+",
+			"#",
+			".",
+			"/",
+			"?",
+			"&"
+		].find((op) => expr.startsWith(op)) || "";
+	}
+	getNames(expr) {
+		const operator = this.getOperator(expr);
+		return expr.slice(operator.length).split(",").map((name) => name.replace("*", "").trim()).filter((name) => name.length > 0);
+	}
+	encodeValue(value, operator) {
+		UriTemplate.validateLength(value, MAX_VARIABLE_LENGTH, "Variable value");
+		if (operator === "+" || operator === "#") return encodeURI(value);
+		return encodeURIComponent(value);
+	}
+	expandPart(part, variables) {
+		if (part.operator === "?" || part.operator === "&") {
+			const pairs = part.names.map((name) => {
+				const value = variables[name];
+				if (value === void 0) return "";
+				return `${name}=${Array.isArray(value) ? value.map((v) => this.encodeValue(v, part.operator)).join(",") : this.encodeValue(value.toString(), part.operator)}`;
+			}).filter((pair) => pair.length > 0);
+			if (pairs.length === 0) return "";
+			return (part.operator === "?" ? "?" : "&") + pairs.join("&");
+		}
+		if (part.names.length > 1) {
+			const values = part.names.map((name) => variables[name]).filter((v) => v !== void 0);
+			if (values.length === 0) return "";
+			return values.map((v) => Array.isArray(v) ? v[0] : v).join(",");
+		}
+		const value = variables[part.name];
+		if (value === void 0) return "";
+		const encoded = (Array.isArray(value) ? value : [value]).map((v) => this.encodeValue(v, part.operator));
+		switch (part.operator) {
+			case "": return encoded.join(",");
+			case "+": return encoded.join(",");
+			case "#": return "#" + encoded.join(",");
+			case ".": return "." + encoded.join(".");
+			case "/": return "/" + encoded.join("/");
+			default: return encoded.join(",");
+		}
+	}
+	expand(variables) {
+		let result = "";
+		let hasQueryParam = false;
+		for (const part of this.parts) {
+			if (typeof part === "string") {
+				result += part;
+				continue;
+			}
+			const expanded = this.expandPart(part, variables);
+			if (!expanded) continue;
+			if ((part.operator === "?" || part.operator === "&") && hasQueryParam) result += expanded.replace("?", "&");
+			else result += expanded;
+			if (part.operator === "?" || part.operator === "&") hasQueryParam = true;
+		}
+		return result;
+	}
+	escapeRegExp(str) {
+		return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	}
+	partToRegExp(part) {
+		const patterns = [];
+		for (const name of part.names) UriTemplate.validateLength(name, MAX_VARIABLE_LENGTH, "Variable name");
+		if (part.operator === "?" || part.operator === "&") {
+			for (let i = 0; i < part.names.length; i++) {
+				const name = part.names[i];
+				const prefix = i === 0 ? "\\" + part.operator : "&";
+				patterns.push({
+					pattern: prefix + this.escapeRegExp(name) + "=([^&]+)",
+					name
+				});
+			}
+			return patterns;
+		}
+		let pattern;
+		const name = part.name;
+		switch (part.operator) {
+			case "":
+				pattern = part.exploded ? "([^/,]+(?:,[^/,]+)*)" : "([^/,]+)";
+				break;
+			case "+":
+			case "#":
+				pattern = "(.+)";
+				break;
+			case ".":
+				pattern = "\\.([^/,]+)";
+				break;
+			case "/":
+				pattern = "/" + (part.exploded ? "([^/,]+(?:,[^/,]+)*)" : "([^/,]+)");
+				break;
+			default: pattern = "([^/]+)";
+		}
+		patterns.push({
+			pattern,
+			name
+		});
+		return patterns;
+	}
+	match(uri) {
+		UriTemplate.validateLength(uri, MAX_TEMPLATE_LENGTH, "URI");
+		let pattern = "^";
+		const names = [];
+		for (const part of this.parts) if (typeof part === "string") pattern += this.escapeRegExp(part);
+		else {
+			const patterns = this.partToRegExp(part);
+			for (const { pattern: partPattern, name } of patterns) {
+				pattern += partPattern;
+				names.push({
+					name,
+					exploded: part.exploded
+				});
+			}
+		}
+		pattern += "$";
+		UriTemplate.validateLength(pattern, MAX_REGEX_LENGTH, "Generated regex pattern");
+		const regex = new RegExp(pattern);
+		const match = uri.match(regex);
+		if (!match) return null;
+		const result = {};
+		for (let i = 0; i < names.length; i++) {
+			const { name, exploded } = names[i];
+			const value = match[i + 1];
+			const cleanName = name.replace("*", "");
+			if (exploded && value.includes(",")) result[cleanName] = value.split(",");
+			else result[cleanName] = value;
+		}
+		return result;
+	}
+};
+//#endregion
 //#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.30.0_zod@4.6.5/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/toolNameValidation.js
 /**
 * Tool name validation utilities according to SEP: Specify Format for Tool Names
@@ -20929,6 +21126,34 @@ var McpServer = class {
 		if (this.isConnected()) this.server.sendPromptListChanged();
 	}
 };
+/**
+* A resource template combines a URI pattern with optional functionality to enumerate
+* all resources matching that pattern.
+*/
+var ResourceTemplate = class {
+	constructor(uriTemplate, _callbacks) {
+		this._callbacks = _callbacks;
+		this._uriTemplate = typeof uriTemplate === "string" ? new UriTemplate(uriTemplate) : uriTemplate;
+	}
+	/**
+	* Gets the URI template pattern.
+	*/
+	get uriTemplate() {
+		return this._uriTemplate;
+	}
+	/**
+	* Gets the list callback, if one was provided.
+	*/
+	get listCallback() {
+		return this._callbacks.list;
+	}
+	/**
+	* Gets the callback for completing a specific URI template variable, if one was provided.
+	*/
+	completeCallback(variable) {
+		return this._callbacks.complete?.[variable];
+	}
+};
 var EMPTY_OBJECT_JSON_SCHEMA = {
 	type: "object",
 	properties: {}
@@ -21096,73 +21321,133 @@ var StdioServerTransport = class {
 	}
 };
 //#endregion
-//#region package/mcp/server.ts
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = path.dirname(__filename);
-var DOCS_DIR = path.join(__dirname, "..", "docs");
-function loadDocs() {
-	return fs.readdirSync(DOCS_DIR).filter((f) => f.endsWith(".md")).map((file) => {
-		const content = fs.readFileSync(path.join(DOCS_DIR, file), "utf-8");
-		const name = file.replace(".md", "");
-		const descMatch = content.match(/\*\*When to use:\*\*\s*(.+)/);
+//#region package/mcp/docs.ts
+/**
+* The folder holding `docs/` and `package.json`. It is one level up from `dist/mcp.js` and two
+* up from `package/mcp/server.ts`, so the server also runs from source under tsx.
+*/
+function findPackageRoot(from) {
+	for (const dir of [path.join(from, ".."), path.join(from, "..", "..")]) if (fs.existsSync(path.join(dir, "docs")) && fs.existsSync(path.join(dir, "package.json"))) return dir;
+	throw new Error(`No folder holding docs/ and package.json above ${from}`);
+}
+function line(content, label) {
+	return content.match(new RegExp(`^\\*\\*${label}:\\*\\*\\s*(.+)$`, "m"))?.[1].trim() ?? "";
+}
+function importedNames(importLine) {
+	return [...importLine.matchAll(/\{([^}]+)\}/g)].flatMap((m) => m[1].split(",")).map((n) => n.trim().replace(/^type\s+/, "")).filter((n) => /^[A-Za-z_$][\w$]*$/.test(n));
+}
+function parseDoc(name, content) {
+	const slots = [...content.matchAll(/^\*\*Slots(?: \([^)]*\))?:\*\*\s*(.+)$/gm)].flatMap((m) => [...m[1].matchAll(/`([\w-]+)`/g)].map((s) => s[1]));
+	return {
+		name,
+		imports: importedNames(line(content, "Import")),
+		types: importedNames(line(content, "Types")),
+		description: line(content, "When to use"),
+		keywords: line(content, "Keywords"),
+		slots: [...new Set(slots)],
+		content
+	};
+}
+function loadDocs(docsDir) {
+	return fs.readdirSync(docsDir).filter((file) => file.endsWith(".md") && file !== "CLAUDE.md").sort().map((file) => parseDoc(file.slice(0, -3), fs.readFileSync(path.join(docsDir, file), "utf-8")));
+}
+/** By doc name first, then by any exported name the doc covers (`ToastProvider` finds Toast.md). */
+function findDoc(docs, query) {
+	const q = query.trim().toLowerCase();
+	return docs.find((d) => d.name.toLowerCase() === q) ?? docs.find((d) => [...d.imports, ...d.types].some((n) => n.toLowerCase() === q));
+}
+/**
+* A hit in the name, the When to use line or the Keywords line outranks one buried in the body,
+* so "toast notification" lists Toast before Alert even though Alert's body mentions toasts.
+*/
+function searchDocs(docs, query) {
+	const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+	if (terms.length === 0) return {
+		full: [],
+		partial: []
+	};
+	const scored = docs.map((doc) => {
+		const names = [doc.name, ...doc.imports].join(" ").toLowerCase();
+		const summary = `${doc.description} ${doc.keywords}`.toLowerCase();
+		const body = doc.content.toLowerCase();
+		let matched = 0;
+		let score = 0;
+		for (const term of terms) {
+			const weight = names.includes(term) ? 5 : summary.includes(term) ? 3 : body.includes(term) ? 1 : 0;
+			if (weight > 0) matched++;
+			score += weight;
+		}
 		return {
-			name,
-			description: descMatch ? descMatch[1].trim() : "",
-			content
+			doc,
+			matched,
+			score
 		};
 	});
+	const byScore = (a, b) => b.matched - a.matched || b.score - a.score || a.doc.name.localeCompare(b.doc.name);
+	return {
+		full: scored.filter((s) => s.matched === terms.length).sort(byScore).map((s) => s.doc),
+		partial: scored.filter((s) => s.matched > 0 && s.matched < terms.length).sort(byScore).map((s) => s.doc)
+	};
 }
-var docs = loadDocs();
-var docsByName = new Map(docs.map((d) => [d.name.toLowerCase(), d]));
+//#endregion
+//#region package/mcp/server.ts
+var ROOT = findPackageRoot(path.dirname(fileURLToPath(import.meta.url)));
+var docs = loadDocs(path.join(ROOT, "docs"));
+var { version } = JSON.parse(fs.readFileSync(path.join(ROOT, "package.json"), "utf-8"));
 var server = new McpServer({
 	name: "ahrowe-ui",
-	version: "1.0.0"
+	version
 });
-server.registerTool("list_components", { description: "List all available ahrowe-ui components with a one-line description of what each one is for." }, async () => ({ content: [{
+var readOnly = {
+	readOnlyHint: true,
+	openWorldHint: false
+};
+var summary = (doc) => `**${doc.name}** — ${doc.description}`;
+var text = (value) => ({ content: [{
 	type: "text",
-	text: docs.map((d) => `**${d.name}** — ${d.description}`).join("\n")
-}] }));
+	text: value
+}] });
+server.registerTool("list_components", {
+	description: "List every @ahrowe/ui component with a one-line description of what it is for. Call this when choosing which component to use.",
+	annotations: readOnly
+}, async () => text(docs.map(summary).join("\n")));
 server.registerTool("get_component_docs", {
-	description: "Get full documentation for a specific ahrowe-ui component: props, types, and usage examples.",
-	inputSchema: { component: string().describe("Component name, e.g. \"Button\", \"Input\", \"KanbanBoard\"") }
+	description: "Full documentation for one @ahrowe/ui component: import line, runnable examples, key props, enums and slot names. Read it before writing JSX for a component. Accepts the doc name or any name it exports, e.g. \"Button\", \"ToastProvider\", \"CardHeader\".",
+	inputSchema: { component: string().describe("Component or export name, e.g. \"Input\", \"KanbanColumn\"") },
+	annotations: readOnly
 }, async ({ component }) => {
-	const doc = docsByName.get(component.toLowerCase());
+	const doc = findDoc(docs, component);
 	if (!doc) return {
-		content: [{
-			type: "text",
-			text: `Component "${component}" not found. Available components: ${docs.map((d) => d.name).join(", ")}`
-		}],
+		...text(`Component "${component}" not found. Available: ${docs.map((d) => d.name).join(", ")}`),
 		isError: true
 	};
-	return { content: [{
-		type: "text",
-		text: doc.content
-	}] };
+	return text(doc.content);
 });
 server.registerTool("search_components", {
-	description: "Search ahrowe-ui components by use case or keyword. Returns matching component names and descriptions.",
-	inputSchema: { query: string().describe("Use-case description or keyword, e.g. \"form input\", \"loading spinner\", \"drag and drop\"") }
+	description: "Find @ahrowe/ui components by use case or keyword. Returns matching component names and descriptions, best match first; follow up with get_component_docs.",
+	inputSchema: { query: string().describe("Use case or keywords, e.g. \"form input\", \"loading spinner\", \"drag and drop upload\"") },
+	annotations: readOnly
 }, async ({ query }) => {
-	const terms = query.toLowerCase().split(/\s+/);
-	const matches = docs.map((doc) => {
-		const haystack = `${doc.name} ${doc.description} ${doc.content}`.toLowerCase();
-		return {
-			doc,
-			matchCount: terms.filter((term) => haystack.includes(term)).length
-		};
-	}).filter(({ matchCount }) => matchCount > 0);
-	if (matches.length === 0) return { content: [{
-		type: "text",
-		text: `No components matched "${query}". Try broader terms.`
-	}] };
-	const fullMatches = matches.filter(({ matchCount }) => matchCount === terms.length);
-	const partialMatches = matches.filter(({ matchCount }) => matchCount < terms.length).sort((a, b) => b.matchCount - a.matchCount);
-	const formatLine = ({ doc }) => `**${doc.name}** — ${doc.description}`;
-	return { content: [{
-		type: "text",
-		text: [fullMatches.length > 0 && fullMatches.map(formatLine).join("\n"), partialMatches.length > 0 && `Partial matches:\n${partialMatches.map(formatLine).join("\n")}`].filter(Boolean).join("\n\n")
+	const { full, partial } = searchDocs(docs, query);
+	if (full.length === 0 && partial.length === 0) return text(`No components matched "${query}". Try broader terms.`);
+	return text([full.length > 0 && full.map(summary).join("\n"), partial.length > 0 && `Partial matches:\n${partial.map(summary).join("\n")}`].filter(Boolean).join("\n\n"));
+});
+server.registerResource("component-doc", new ResourceTemplate("ahrowe-ui://docs/{component}", { list: async () => ({ resources: docs.map((doc) => ({
+	uri: `ahrowe-ui://docs/${doc.name}`,
+	name: doc.name,
+	description: doc.description,
+	mimeType: "text/markdown"
+})) }) }), {
+	title: "Component documentation",
+	description: "One @ahrowe/ui component: props, examples, enums and slots."
+}, async (uri, { component }) => {
+	const doc = findDoc(docs, String(component));
+	if (!doc) throw new Error(`Unknown component "${String(component)}"`);
+	return { contents: [{
+		uri: uri.href,
+		mimeType: "text/markdown",
+		text: doc.content
 	}] };
 });
-var transport = new StdioServerTransport();
-await server.connect(transport);
+await server.connect(new StdioServerTransport());
 //#endregion