@dowel-ui/mcp 0.7.0

package/dist/index.js

@@ -0,0 +1,1076 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync } from "node:fs";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/branding.ts
+/**
+* Branding, mirrored from the repository root config.
+*
+* Duplicated deliberately: the published server cannot import from the monorepo
+* root, and `pnpm rebrand` rewrites every copy in the same pass.
+*/
+const branding = {
+	libraryName: "Dowel",
+	cliPackage: "@dowel-ui/cli",
+	packageScope: "@dowel-ui",
+	registryUrl: "https://dowel-eight.vercel.app/r"
+};
+//#endregion
+//#region ../registry/dist/generate.js
+/**
+* Turning a description of a screen into a plan made of components that exist.
+*
+* The hard part of generating UI is not writing JSX. It is not inventing: a
+* model asked for a billing page will cheerfully produce `<PricingTable>` and
+* `<InvoiceList>` and a `variant="subtle"` that was never implemented, and the
+* result reads perfectly and compiles nowhere.
+*
+* So this resolves a prompt against the registry first, and everything it
+* emits afterwards is drawn from what came back. It cannot name a component
+* that is not installable, because it only ever repeats names the registry
+* gave it.
+*
+* It does not guess at props. The registry publishes what a component *is* and
+* what it depends on, not the shape of its arguments, so the output stops at
+* the composition and points at the page where the props are documented.
+* Emitting a plausible prop is worse than emitting none — one is a gap, the
+* other is a bug that looks like working code.
+*/
+/** Words that carry no signal about which component is wanted. */
+const STOPWORDS = /* @__PURE__ */ new Set([
+	"a",
+	"an",
+	"the",
+	"and",
+	"or",
+	"of",
+	"for",
+	"with",
+	"to",
+	"in",
+	"on",
+	"at",
+	"by",
+	"is",
+	"are",
+	"be",
+	"make",
+	"build",
+	"create",
+	"want",
+	"need",
+	"add",
+	"show",
+	"page",
+	"screen",
+	"app",
+	"application",
+	"ui",
+	"interface",
+	"component",
+	"components",
+	"me",
+	"my",
+	"our",
+	"i",
+	"it",
+	"that",
+	"this",
+	"some",
+	"using",
+	"use",
+	"like"
+]);
+/**
+* Words a reader would use that are not the words the registry uses.
+*
+* Hand-written, and deliberately so. "Sign in" is what someone types and
+* `login` is what the item is called; no amount of string similarity bridges
+* that, and pretending otherwise produces a matcher that works on the examples
+* it was tuned against and nothing else.
+*/
+const SYNONYMS = {
+	"sign in": ["login"],
+	signin: ["login"],
+	"log in": ["login"],
+	"sign up": ["signup"],
+	register: ["signup"],
+	registration: ["signup"],
+	"forgot password": ["forgot-password"],
+	"reset password": ["forgot-password"],
+	chat: [
+		"ai-chat",
+		"ai-conversation",
+		"ai-prompt-input"
+	],
+	conversation: ["ai-chat"],
+	assistant: ["ai-chat"],
+	copilot: ["ai-chat"],
+	agent: [
+		"agent-console",
+		"ai-agent-status",
+		"ai-agent-plan"
+	],
+	agents: ["agent-console"],
+	tool: ["ai-tool"],
+	approval: ["ai-approval-request"],
+	approve: ["ai-approval-request"],
+	undo: ["ai-action-ledger"],
+	audit: ["ai-action-ledger", "activity-feed"],
+	tokens: ["ai-token-usage"],
+	spend: ["ai-dashboard", "billing"],
+	cost: ["ai-dashboard", "billing"],
+	usage: ["ai-dashboard", "billing"],
+	subscription: ["billing", "pricing"],
+	invoice: ["billing"],
+	invoices: ["billing"],
+	payment: ["billing"],
+	plan: ["pricing", "billing"],
+	plans: ["pricing"],
+	metrics: [
+		"analytics",
+		"dashboard",
+		"metric-delta"
+	],
+	chart: ["analytics"],
+	charts: ["analytics"],
+	graph: ["analytics"],
+	stats: ["dashboard", "analytics"],
+	overview: ["dashboard"],
+	grid: ["data-table", "table"],
+	spreadsheet: ["data-table"],
+	list: ["table", "data-table"],
+	search: ["command", "combobox"],
+	palette: ["command"],
+	shortcut: ["command", "shortcut-recorder"],
+	modal: ["dialog"],
+	popup: ["dialog", "popover"],
+	dropdown: ["dropdown-menu", "select"],
+	toast: ["toast"],
+	notification: ["toast", "activity-feed"],
+	notifications: ["toast", "settings"],
+	upload: ["file-upload"],
+	file: ["file-upload"],
+	date: ["date-picker", "calendar"],
+	time: ["time-range-picker"],
+	schedule: ["cron-editor"],
+	cron: ["cron-editor"],
+	team: ["admin-users", "settings"],
+	members: ["admin-users"],
+	users: ["admin-users"],
+	admin: ["admin-users"],
+	permissions: ["permission-matrix"],
+	roles: ["permission-matrix"],
+	profile: ["settings"],
+	preferences: ["settings"],
+	account: ["settings", "billing"],
+	setup: ["onboarding"],
+	checklist: ["onboarding"],
+	wizard: ["onboarding"],
+	logs: ["log-viewer"],
+	log: ["log-viewer"],
+	diff: ["diff-viewer", "record-diff"],
+	secret: ["secret-field"],
+	"api key": ["secret-field"],
+	key: ["secret-field"],
+	dns: ["dns-record"]
+};
+function normalise(prompt) {
+	return prompt.toLowerCase().replace(/[^a-z0-9\s-]/g, " ");
+}
+function words(prompt) {
+	return normalise(prompt).split(/\s+/).filter((word) => word.length > 2 && !STOPWORDS.has(word));
+}
+function synonymHits(prompt) {
+	const text = normalise(prompt);
+	const hits = /* @__PURE__ */ new Map();
+	const consumed = /* @__PURE__ */ new Set();
+	for (const [phrase, names] of Object.entries(SYNONYMS)) {
+		if (!new RegExp(`(^|\\s)${phrase.replace(/\s+/g, "\\s+")}(\\s|$)`).test(text)) continue;
+		for (const word of phrase.split(/\s+/)) consumed.add(word);
+		for (const name of names) if (!hits.has(name)) hits.set(name, phrase);
+	}
+	return {
+		hits,
+		consumed
+	};
+}
+/** Below this a match is coincidence rather than intent. */
+const MINIMUM_SCORE = 20;
+function scoreEntry(entry, terms, synonyms) {
+	const name = entry.name.toLowerCase();
+	const title = entry.title.toLowerCase();
+	const description = entry.description.toLowerCase();
+	let score = 0;
+	const reasons = [];
+	const synonym = synonyms.get(entry.name);
+	if (synonym) {
+		score += 60;
+		reasons.push(`"${synonym}"`);
+	}
+	for (const term of terms) if (name === term) {
+		score += 50;
+		reasons.push(`named "${term}"`);
+	} else if (name.split("-").includes(term)) {
+		score += 30;
+		reasons.push(`"${term}" in its name`);
+	} else if (title.includes(term)) {
+		score += 20;
+		reasons.push(`"${term}" in its title`);
+	} else if (entry.category === term) {
+		score += 12;
+		reasons.push(`the ${term} category`);
+	} else if (description.includes(term)) {
+		score += 8;
+		reasons.push(`"${term}" in its description`);
+	}
+	if (score === 0) return void 0;
+	const rank = score + (entry.type === "registry:block" ? 25 : 0);
+	return {
+		entry,
+		score,
+		rank,
+		because: [...new Set(reasons)].slice(0, 3).join(", ")
+	};
+}
+function planUi(prompt, index, options = {}) {
+	const { maxBlocks = 3, maxComponents = 6 } = options;
+	const { hits: synonyms, consumed } = synonymHits(prompt);
+	const terms = words(prompt).filter((term) => !consumed.has(term));
+	const scored = index.items.filter((entry) => entry.type === "registry:ui" || entry.type === "registry:block").map((entry) => scoreEntry(entry, terms, synonyms)).filter((candidate) => candidate !== void 0).filter((candidate) => candidate.score >= MINIMUM_SCORE).sort((a, b) => b.rank - a.rank || a.entry.name.localeCompare(b.entry.name));
+	const blocks = scored.filter((candidate) => candidate.entry.type === "registry:block").slice(0, maxBlocks);
+	const covered = new Set(blocks.flatMap((candidate) => [candidate.entry.name, ...candidate.entry.registryDependencies]));
+	const components = scored.filter((candidate) => candidate.entry.type === "registry:ui" && !covered.has(candidate.entry.name)).slice(0, maxComponents);
+	const toEntry = (candidate) => ({
+		entry: candidate.entry,
+		because: candidate.because
+	});
+	return {
+		prompt,
+		blocks: blocks.map(toEntry),
+		components: components.map(toEntry),
+		install: [...blocks, ...components].map((candidate) => candidate.entry.name),
+		empty: blocks.length === 0 && components.length === 0
+	};
+}
+/** PascalCase export name for a registry name, e.g. "ai-tool" -> "AiTool". */
+function tag(name) {
+	return name.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+/** Blocks export a `…Block` component; components export their own name. */
+function componentName(entry) {
+	const base = tag(entry.name);
+	return entry.type === "registry:block" ? `${base}Block` : base;
+}
+/**
+* Where an installed block lives.
+*
+* A project alias like `@/components/ui` has a sibling `@/components/blocks`. A
+* bare package specifier has no block path at all, so the conventional install
+* location is used instead of inventing one under the package.
+*/
+function blocksPathFor(importFrom) {
+	if (importFrom.endsWith("/ui")) return `${importFrom.slice(0, -3)}/blocks`;
+	if (importFrom.startsWith("@/") || importFrom.startsWith("~/")) return `${importFrom}/blocks`;
+	return "@/components/blocks";
+}
+/**
+* The plan as a starting file.
+*
+* Imports and composition only. Every element carries the page its props are
+* documented on, because the registry does not publish prop shapes and a
+* plausible invented prop is worse than an obvious gap — one is a TODO, the
+* other is a bug wearing the costume of working code.
+*/
+function renderPlan(plan, options = {}) {
+	const { importFrom = "@/components/ui", docsUrl = "https://dowel-eight.vercel.app", blocksImportFrom = blocksPathFor(importFrom) } = options;
+	if (plan.empty) return `// Nothing in the registry matched "${plan.prompt}".\n`;
+	const chosen = [...plan.blocks, ...plan.components];
+	const imports = chosen.map((item) => {
+		const from = item.entry.type === "registry:block" ? `${blocksImportFrom}/${item.entry.name}` : `${importFrom}/${item.entry.name}`;
+		return `import { ${componentName(item.entry)} } from "${from}";`;
+	}).sort();
+	const body = chosen.map((item) => {
+		const name = componentName(item.entry);
+		return [`      {/* ${item.entry.title} — props: ${docsUrl}/docs/${item.entry.type === "registry:block" ? "blocks" : "components"}/${item.entry.name} */}`, `      <${name} />`].join("\n");
+	}).join("\n\n");
+	return `${imports.join("\n")}
+
+export default function Page() {
+  return (
+    <div className="flex flex-col gap-6">
+${body}
+    </div>
+  );
+}
+`;
+}
+/**
+* The plan as a brief for a coding agent.
+*
+* The most useful thing this can produce. The agent has the project, the
+* editor and the ability to write the props; what it lacks is the knowledge
+* that these components exist and that it must not invent others. That is
+* exactly what a grounded plan supplies.
+*/
+function renderBrief(plan, options = {}) {
+	const { cliPackage = "@dowel-ui/cli", docsUrl = "https://dowel-eight.vercel.app", importFrom = "@/components/ui" } = options;
+	if (plan.empty) return `Nothing in the registry matched "${plan.prompt}". Search the catalogue at ${docsUrl}/docs/components before building anything by hand.`;
+	const lines = [
+		`Build: ${plan.prompt}`,
+		"",
+		"Use these, which are already in the registry. Do not write your own versions,",
+		"and do not use any component not listed here without checking the catalogue first.",
+		""
+	];
+	if (plan.blocks.length > 0) {
+		lines.push("Blocks (whole sections — each installs its own components):");
+		for (const item of plan.blocks) lines.push(`- ${item.entry.name} — ${item.entry.description}`);
+		lines.push("");
+	}
+	if (plan.components.length > 0) {
+		lines.push("Components:");
+		for (const item of plan.components) lines.push(`- ${item.entry.name} — ${item.entry.description}`);
+		lines.push("");
+	}
+	lines.push("Install first:", "", `    npx ${cliPackage} add ${plan.install.join(" ")}`, "", `Import from \`${importFrom}\`. Each component's props are on its page under`, `${docsUrl}/docs/components — read the page rather than guessing a prop name.`, "", "Style with semantic tokens only (bg-background, text-muted-foreground). Never raw", "hex, never Tailwind's own palette — those do not follow the theme.");
+	return lines.join("\n");
+}
+//#endregion
+//#region ../registry/dist/schema-BbyNjH6Q.js
+const registryFileTypeSchema = z.enum([
+	"registry:ui",
+	"registry:lib",
+	"registry:hook",
+	"registry:block",
+	"registry:style"
+]);
+const registryItemTypeSchema = z.enum([
+	"registry:ui",
+	"registry:lib",
+	"registry:hook",
+	"registry:theme",
+	"registry:block"
+]);
+/**
+* Whether an item's source is public.
+*
+* `free` is the default and stays the default: an item that has ever been
+* installable without a licence must never quietly become one that is not.
+* Existing registries carry no `access` field at all, which parses as `free` —
+* so an older registry read by a newer CLI behaves exactly as it did.
+*/
+const registryAccessSchema = z.enum(["free", "pro"]).default("free");
+const registryFileSchema = z.object({
+	/**
+	* Logical path within the registry, e.g. `ui/button.tsx`, `lib/utils.ts`.
+	*
+	* The leading segment selects which of the consumer's aliases the file is
+	* written under. The registry deliberately does not know the destination —
+	* that depends on a project layout it has never seen.
+	*/
+	path: z.string().min(1),
+	type: registryFileTypeSchema,
+	content: z.string(),
+	/**
+	* `sha256:<hex>` of `content` as published.
+	*
+	* Recorded at install time so `update` can tell an untouched file from one
+	* the user has edited. This cannot be added later: an install that did not
+	* record a hash leaves no way to know what it originally wrote.
+	*/
+	hash: z.string().regex(/^sha256:[0-9a-f]{64}$/)
+});
+const registryItemSchema = z.object({
+	$schema: z.string().optional(),
+	registryVersion: z.literal(1),
+	name: z.string().regex(/^[a-z][a-z0-9-]*$/),
+	type: registryItemTypeSchema,
+	title: z.string().min(1),
+	description: z.string().min(10),
+	category: z.string().min(1),
+	status: z.enum([
+		"stable",
+		"beta",
+		"experimental"
+	]),
+	/** npm packages to install alongside the files. */
+	dependencies: z.array(z.string()),
+	/** Other registry items to install first. */
+	registryDependencies: z.array(z.string()),
+	files: z.array(registryFileSchema).min(1),
+	a11y: z.string().optional(),
+	access: registryAccessSchema
+});
+/**
+* The index entry.
+*
+* Carries `access` so a licensed item is *listed* — with its title, what it
+* depends on and how many files it has — while its source is not. Hiding paid
+* items entirely would mean nobody could discover them; including their source
+* would mean nobody needed to buy them. The index is the catalogue; the item
+* body is the goods.
+*/
+const registryIndexEntrySchema = registryItemSchema.pick({
+	name: true,
+	type: true,
+	title: true,
+	description: true,
+	category: true,
+	status: true,
+	dependencies: true,
+	registryDependencies: true,
+	access: true
+}).extend({ fileCount: z.number().int().positive() });
+const registryIndexSchema = z.object({
+	$schema: z.string().optional(),
+	registryVersion: z.literal(1),
+	/** Version of the package the registry was generated from. */
+	generatedFrom: z.string().min(1),
+	items: z.array(registryIndexEntrySchema)
+});
+//#endregion
+//#region ../registry/dist/index.js
+/**
+* Building a registry of your own components.
+*
+* The CLI has always been able to install from any registry — `--registry`
+* takes a URL or a directory — but producing one meant reimplementing this
+* package. So an organisation that wanted its own components installed the same
+* way had the consumer half and none of the producer half.
+*
+* The authoring shape is declared here rather than imported from the component
+* package, because the registry *is* the contract. A team publishing their own
+* components should not have to depend on somebody else's component library to
+* describe their own.
+*/
+/** Where an item's files are written in the consuming project. */
+const itemGroupSchema = z.enum([
+	"ui",
+	"blocks",
+	"lib",
+	"hooks"
+]);
+const itemSourceSchema = z.object({
+	name: z.string().regex(/^[a-z][a-z0-9-]*$/),
+	title: z.string().min(1),
+	description: z.string().min(10),
+	category: z.string().min(1),
+	status: z.enum([
+		"stable",
+		"beta",
+		"experimental"
+	]).default("stable"),
+	/** Where the files land. Defaults to `ui`. */
+	group: itemGroupSchema.default("ui"),
+	/** npm packages the source imports. */
+	dependencies: z.array(z.string()).default([]),
+	/** Other registry items this one imports, upstream ones included. */
+	registryDependencies: z.array(z.string()).default([]),
+	/** Files to publish, relative to the item's own directory. */
+	files: z.array(z.string().min(1)).min(1),
+	a11y: z.string().optional(),
+	access: registryAccessSchema,
+	/**
+	* Overrides where the item's directory is, relative to the registry root.
+	* Defaults to `<group>/<name>`, which is the layout this repository uses.
+	*/
+	directory: z.string().optional()
+});
+z.object({
+	/** Absolute path the item directories are resolved against. */
+	root: z.string().min(1),
+	items: z.array(itemSourceSchema).min(1),
+	/**
+	* A registry to layer on top of — a URL, or a directory on disk.
+	*
+	* The reason a private registry is worth having at all: one URL that serves
+	* both the upstream components and yours, so a consumer configures one place
+	* and `add` resolves across both.
+	*/
+	extends: z.string().min(1).optional(),
+	/** Written into the index, so a consumer can see what produced it. */
+	generatedFrom: z.string().min(1).default("custom-registry")
+});
+const CATEGORY_LABELS = {
+	foundation: "Foundation",
+	form: "Forms",
+	overlay: "Overlays",
+	navigation: "Navigation",
+	display: "Display",
+	data: "Data",
+	feedback: "Feedback",
+	layout: "Layout",
+	ai: "AI"
+};
+const CATEGORY_ORDER = [
+	"foundation",
+	"form",
+	"overlay",
+	"navigation",
+	"display",
+	"data",
+	"feedback",
+	"layout",
+	"ai"
+];
+function label(category) {
+	return CATEGORY_LABELS[category] ?? category;
+}
+/** Ordered by curation where curated, alphabetical for anything new. */
+function categoriesOf(entries) {
+	const present = new Set(entries.map((entry) => entry.category));
+	const known = CATEGORY_ORDER.filter((category) => present.has(category));
+	const rest = [...present].filter((category) => !CATEGORY_ORDER.includes(category)).sort();
+	return [...known, ...rest];
+}
+function byType(index, type) {
+	return index.items.filter((entry) => entry.type === type).sort((a, b) => a.name.localeCompare(b.name));
+}
+function components(index) {
+	return byType(index, "registry:ui");
+}
+function blocks(index) {
+	return byType(index, "registry:block");
+}
+/**
+* Accessibility rules that differ from what a model has seen elsewhere.
+*
+* An agent trained on every other React library will reach for `disabled` on a
+* loading button and a live region on every alert. Stating only the deltas is
+* deliberate: a general accessibility lecture is ignored, a short list of
+* "here this is different" is followed.
+*/
+const ACCESSIBILITY_DELTAS = [
+	"A loading `Button` uses `aria-disabled` + `aria-busy` and guards its own click handler. Never add `disabled` to it — disabling a control mid-action strands keyboard focus.",
+	"`Alert` is not a live region by default. One that exists on first paint announces for no reason. Opt in with `live=\"polite\"` or `live=\"assertive\"` only when the alert appears in response to something.",
+	"`Separator`, `Skeleton` and `Spinner` are decorative and stay out of the accessibility tree unless given a label. Do not add `role` or `aria-label` to them by reflex.",
+	"`PopoverContent` carries `role=\"dialog\"` and warns in development without an accessible name. Always give it `aria-label` or `aria-labelledby`.",
+	"Never use colour as the only signal. The `monochrome` preset exists as a standing check on exactly this — if a state is unreadable under it, the component is wrong."
+];
+const TOKEN_RULES = [
+	"Use semantic tokens (`bg-background`, `text-foreground`, `border-border`, `ring-ring`, `bg-primary`, `text-muted-foreground`). Never raw hex, and never Tailwind's own palette (`bg-slate-900`, `text-gray-500`) — those do not follow the theme and break every preset and dark mode.",
+	"Spacing, radius and type come from the scale. `rounded-md` and `rounded-lg` re-proportion with `--radius-scale`; an arbitrary `rounded-[7px]` does not.",
+	"Durations derive from `--motion-scale`. Do not hardcode transition timings.",
+	"Compose class names with `cn()` from the project's utils, so consumer overrides win over defaults."
+];
+function conventionsDoc(context) {
+	const { libraryName, cliPackage, importFrom, docsUrl } = context;
+	return `# ${libraryName} — conventions
+
+Rules for writing code in this project. ${libraryName} is **source-first**: its
+components are files in this repository, not a dependency you can reason about
+from its README. They are yours to edit, and edits are preserved across updates.
+
+## The rule that matters most
+
+**Do not hand-write a component that ${libraryName} already has.** Check the
+catalogue in \`components.md\` first. Writing a second Button — with different
+focus rings, different disabled semantics, different tokens — is the single
+most common and most damaging thing to do here.
+
+## Adding a component
+
+\`\`\`bash
+npx ${cliPackage} add <name>
+\`\`\`
+
+This writes the source into the project and installs whatever it depends on.
+\`add\` is safe to re-run: an untouched file is left alone, an edited one is
+never overwritten without \`--overwrite\`.
+
+Do not \`npm install\` a component. Do not copy source out of the documentation
+by hand — the CLI resolves the dependency graph and rewrites imports to this
+project's path alias, and doing it manually gets both wrong.
+
+## Importing
+
+\`\`\`tsx
+import { Button, Card, CardContent } from "${importFrom}";
+\`\`\`
+
+## Styling
+
+${TOKEN_RULES.map((rule) => `- ${rule}`).join("\n")}
+
+## Accessibility
+
+Targeted at WCAG 2.2 AA, verified with axe per component. Where ${libraryName}
+differs from what you have seen in other libraries:
+
+${ACCESSIBILITY_DELTAS.map((rule) => `- ${rule}`).join("\n")}
+
+## Before you build a page
+
+Check \`components.md\` for a **block** that already covers it. A block is a
+whole section — a login form, a settings page, a chat surface — and installing
+one brings every component it is assembled from. Building a dashboard out of
+individual primitives when \`add dashboard\` exists is wasted work.
+
+## Reference
+
+- Documentation: ${docsUrl}
+- Full text for models: ${docsUrl}/llms-full.txt
+`;
+}
+function componentsDoc(context) {
+	const { index, libraryName, cliPackage, installed } = context;
+	const have = new Set(installed ?? []);
+	const known = installed !== void 0;
+	const ui = components(index);
+	const blk = blocks(index);
+	const lines = [
+		`# ${libraryName} — catalogue`,
+		"",
+		`${String(ui.length)} components and ${String(blk.length)} blocks, generated from \`${index.generatedFrom}\`. This is the complete list — anything not here does not exist.`,
+		""
+	];
+	if (known) lines.push("`✓` marks what is already installed in this project. Everything else needs", `\`npx ${cliPackage} add <name>\` before it can be imported.`, "");
+	const mark = (entry) => known ? have.has(entry.name) ? "✓ " : "  " : "";
+	for (const category of categoriesOf(ui)) {
+		lines.push(`## ${label(category)}`, "");
+		for (const entry of ui.filter((item) => item.category === category)) {
+			const status = entry.status === "stable" ? "" : ` _(${entry.status})_`;
+			lines.push(`- ${mark(entry)}**${entry.name}** — ${entry.description}${status}`);
+		}
+		lines.push("");
+	}
+	lines.push("## Blocks", "", "Whole sections. Installing one installs every component it is built from.", "");
+	for (const entry of blk) {
+		const deps = entry.registryDependencies.length;
+		const resolves = deps > 0 ? ` _(resolves ${String(deps)} components)_` : "";
+		lines.push(`- ${mark(entry)}**${entry.name}** — ${entry.description}${resolves}`);
+	}
+	lines.push("");
+	return lines.join("\n");
+}
+function aiDoc(context) {
+	const { index, libraryName, cliPackage } = context;
+	const ai = components(index).filter((entry) => entry.category === "ai");
+	return `# ${libraryName} — AI components
+
+${String(ai.length)} surfaces for AI features. Reach for these before building
+anything custom for a model-facing interface.
+
+Most component sets ship a chat transcript and stop. Real AI features are
+extraction, enrichment, autofill and agents that *change things* — so the parts
+that matter are the ones around the transcript, not the transcript itself.
+
+${ai.map((entry) => `- **${entry.name}** — ${entry.description}`).join("\n")}
+
+## Choosing between them
+
+- Rendering a conversation → \`ai-conversation\` with \`ai-message\` and \`ai-response\`.
+- The composer → \`ai-prompt-input\`, with \`ai-model-selector\` if the model is switchable.
+- A tool the model called → \`ai-tool\`. Its arguments and result belong there, not in prose.
+- Asking permission *before* a tool runs → \`ai-approval-request\`.
+- Reporting what it did *after* → \`ai-action-ledger\`, which is also where reversibility belongs. A deletion can be undone, a refund can only be offset, a sent email cannot be taken back — the ledger is where that distinction is shown.
+- An object streaming in field by field → \`ai-structured-output\`, which reserves layout up front so nothing jumps.
+- Ghost text in a real textarea → \`ai-inline-completion\`. Escape always returns Tab to focus management, so a keyboard user is never trapped.
+- A value the model proposes for a form field → \`ai-suggested-value\`.
+- Reviewing what was pulled out of a document → \`ai-extraction-review\`.
+- Long-running work → \`ai-agent-status\` and \`ai-agent-plan\`.
+- Where an answer came from → \`ai-sources\`. Cost → \`ai-token-usage\`. Chain of thought → \`ai-reasoning\`.
+
+## Whole surface at once
+
+\`\`\`bash
+npx ${cliPackage} add ai-chat
+\`\`\`
+`;
+}
+function themesDoc(context) {
+	const { libraryName } = context;
+	return `# ${libraryName} — theming
+
+Tokens are two-tier. **Tier 1** is raw scales: an OKLCH neutral ramp, a radius
+ladder, a 15px-base type scale, elevation, motion. **Tier 2** is semantic
+aliases — \`--primary\`, \`--background\`, \`--border\`, \`--ring\` — and components
+consume Tier 2 *exclusively*.
+
+Re-skinning the system means reassigning Tier 2. It never means editing a
+component file. If you find yourself changing a colour inside a component, the
+change belongs in the token layer instead.
+
+## Presets
+
+\`default\`, \`ocean\`, \`emerald\`, \`violet\`, \`rose\`, \`amber\`, \`monochrome\`.
+
+\`\`\`html
+<html data-theme="ocean" class="dark">
+\`\`\`
+
+\`data-theme\` selects the preset; the \`dark\` class selects the mode. They are
+independent — every preset works in both.
+
+\`monochrome\` is not only a style. It is a standing check that no component uses
+colour as its only signal, so verify new work under it.
+
+## Two properties that re-proportion everything
+
+- \`--radius-scale\` — one multiplier behind every corner in the system. \`1\` is the designed default, \`0\` is fully square.
+- \`--motion-scale\` — one multiplier every duration derives from. Under \`prefers-reduced-motion\` it collapses, but indicators that report ongoing state are *slowed* rather than stopped via \`--motion-scale-indicator\`, because a frozen spinner reads as a hung application.
+
+## Contrast
+
+All semantic pairs are verified against WCAG 2.2 AA across both modes and every
+preset, in CI. A new token pair has to pass the same check — do not introduce
+one without running \`audit:contrast\`.
+`;
+}
+//#endregion
+//#region src/registry.ts
+/**
+* Reads the registry over HTTP, or from a directory on disk.
+*
+* A deliberate copy of the CLI's client rather than a shared module: this
+* process is long-lived and answers many questions about the same registry, so
+* it caches, while the CLI runs once and does not. Sharing the code would mean
+* one of the two carrying machinery it does not want.
+*/
+var RegistryClient = class {
+	baseUrl;
+	#index;
+	#items = /* @__PURE__ */ new Map();
+	constructor(baseUrl) {
+		this.baseUrl = baseUrl;
+	}
+	get #isHttp() {
+		return this.baseUrl.startsWith("http://") || this.baseUrl.startsWith("https://");
+	}
+	async #readJson(file) {
+		if (!this.#isHttp) {
+			const root = this.baseUrl.startsWith("file:") ? fileURLToPath(this.baseUrl) : this.baseUrl;
+			const path = join(root, file);
+			if (!existsSync(path)) throw new Error(`Not found in the registry: ${file}`);
+			return JSON.parse(readFileSync(path, "utf8"));
+		}
+		const url = `${this.baseUrl.replace(/\/$/, "")}/${file}`;
+		const response = await fetch(url);
+		if (response.status === 404) throw new Error(`Not found in the registry: ${file}`);
+		if (!response.ok) throw new Error(`Registry returned ${String(response.status)} for ${url}`);
+		return await response.json();
+	}
+	/**
+	* Cached for the life of the process.
+	*
+	* The registry is immutable for a given release, and an agent asks about it
+	* dozens of times in a session; refetching would add latency to every tool
+	* call for data that cannot have changed.
+	*/
+	index() {
+		this.#index ??= this.#readJson("index.json").then((raw) => {
+			const parsed = registryIndexSchema.safeParse(raw);
+			if (!parsed.success) throw new Error("The registry index does not match the format this server understands. Update @dowel-ui/mcp, or point it at a compatible registry.");
+			return parsed.data;
+		});
+		return this.#index;
+	}
+	item(name) {
+		let cached = this.#items.get(name);
+		if (!cached) {
+			cached = this.#readJson(`${name}.json`).then((raw) => {
+				const parsed = registryItemSchema.safeParse(raw);
+				if (!parsed.success) throw new Error(`Registry entry "${name}" is malformed.`);
+				return parsed.data;
+			});
+			cached.catch(() => this.#items.delete(name));
+			this.#items.set(name, cached);
+		}
+		return cached;
+	}
+	/** Items and everything they depend on, dependencies first. */
+	async resolve(names) {
+		const ordered = [];
+		const placed = /* @__PURE__ */ new Set();
+		const visiting = /* @__PURE__ */ new Set();
+		const visit = async (name) => {
+			if (placed.has(name) || visiting.has(name)) return;
+			visiting.add(name);
+			const item = await this.item(name);
+			for (const dependency of item.registryDependencies) await visit(dependency);
+			visiting.delete(name);
+			placed.add(name);
+			ordered.push(item);
+		};
+		for (const name of names) await visit(name);
+		return ordered;
+	}
+};
+//#endregion
+//#region src/server.ts
+function text(value) {
+	return { content: [{
+		type: "text",
+		text: value
+	}] };
+}
+function docsContext(options, index) {
+	return {
+		index,
+		registryUrl: options.registryUrl,
+		docsUrl: options.docsUrl,
+		cliPackage: options.cliPackage,
+		libraryName: options.libraryName,
+		importFrom: options.importFrom
+	};
+}
+function summarise(entry) {
+	const kind = entry.type === "registry:block" ? "block" : "component";
+	const status = entry.status === "stable" ? "" : ` (${entry.status})`;
+	return `${entry.name} — ${kind}, ${entry.category}${status}\n  ${entry.description}`;
+}
+/**
+* Levenshtein distance, iterative with a single row.
+*
+* Only ever run against a name the caller got wrong, over a list of fewer than
+* a hundred short strings, so the row-per-character allocation a clearer
+* implementation would make is not worth avoiding — and the full matrix is not
+* worth keeping, since only the distance is wanted.
+*/
+function distance(a, b) {
+	if (a === b) return 0;
+	if (a.length === 0) return b.length;
+	if (b.length === 0) return a.length;
+	let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+	for (let i = 1; i <= a.length; i += 1) {
+		const current = [i];
+		for (let j = 1; j <= b.length; j += 1) {
+			const substitution = (previous[j - 1] ?? 0) + (a[i - 1] === b[j - 1] ? 0 : 1);
+			const deletion = (previous[j] ?? 0) + 1;
+			const insertion = (current[j - 1] ?? 0) + 1;
+			current[j] = Math.min(substitution, deletion, insertion);
+		}
+		previous = current;
+	}
+	return previous[b.length] ?? 0;
+}
+/**
+* Names closest to one that does not exist.
+*
+* Substring matching alone answers nothing for a typo — "datatabel" shares no
+* run with "data-table" — and a typo is exactly the case where a suggestion is
+* worth most, because the agent already knows what it wants. Hyphens are
+* dropped before comparing so "datatable" reads as one edit from "data-table"
+* rather than two.
+*/
+function nearest(names, query, limit = 3) {
+	const needle = query.toLowerCase().replace(/-/g, "");
+	return names.map((name) => ({
+		name,
+		gap: distance(name.toLowerCase().replace(/-/g, ""), needle)
+	})).filter(({ gap }) => gap <= Math.max(2, Math.floor(needle.length / 3))).sort((a, b) => a.gap - b.gap || a.name.localeCompare(b.name)).slice(0, limit).map(({ name }) => name);
+}
+/**
+* Scores a query against one entry.
+*
+* Name matches outrank description matches because an agent that already knows
+* roughly what a thing is called should get it first, and a word common to
+* thirty descriptions should not bury the component actually named after it.
+* Zero means no match, and no-match is excluded rather than ranked last.
+*/
+function score(entry, query) {
+	const needle = query.toLowerCase().trim();
+	if (needle.length === 0) return 1;
+	const name = entry.name.toLowerCase();
+	if (name === needle) return 100;
+	if (name.startsWith(needle)) return 50;
+	if (name.includes(needle)) return 25;
+	if (entry.title.toLowerCase().includes(needle)) return 20;
+	if (entry.category.toLowerCase() === needle) return 15;
+	if (entry.description.toLowerCase().includes(needle)) return 10;
+	return 0;
+}
+function createServer(options) {
+	const registry = new RegistryClient(options.registryUrl);
+	const server = new McpServer({
+		name: "dowel-ui",
+		version: options.version
+	}, { instructions: `${options.libraryName} is a source-first React component system: components are installed into the project as editable files, not imported from a dependency.\n\nBefore writing any React UI, call search_components to check whether a component already exists — hand-writing a second Button is the most common mistake here. Call get_guide("conventions") once per session for the styling and accessibility rules, which differ from other libraries in ways worth knowing.` });
+	server.registerTool("search_components", {
+		title: "Search components",
+		description: "Search the component and block catalogue by name, description or category. Call this before building any UI, to find what already exists. Omit the query to list everything.",
+		inputSchema: {
+			query: z.string().optional().describe("What you need, e.g. \"date\", \"chat\", \"table\", \"agent approval\""),
+			category: z.string().optional().describe("Restrict to one category: ai, form, overlay, data, feedback, navigation, display, layout, foundation"),
+			kind: z.enum([
+				"component",
+				"block",
+				"any"
+			]).optional().describe("Blocks are whole sections assembled from components. Default: any")
+		}
+	}, async ({ query, category, kind }) => {
+		const index = await registry.index();
+		const wanted = kind === "component" ? ["registry:ui"] : kind === "block" ? ["registry:block"] : ["registry:ui", "registry:block"];
+		const matches = index.items.filter((entry) => wanted.includes(entry.type)).filter((entry) => !category || entry.category === category).map((entry) => ({
+			entry,
+			rank: score(entry, query ?? "")
+		})).filter(({ rank }) => rank > 0).sort((a, b) => b.rank - a.rank || a.entry.name.localeCompare(b.entry.name));
+		if (matches.length === 0) return text(`Nothing matches "${query ?? ""}". This registry has ${String(index.items.length)} items — call search_components with no query to see them all. If nothing fits, build it from primitives rather than assuming a component exists.`);
+		return text(`${String(matches.length)} match(es) in ${index.generatedFrom}:\n\n` + matches.map(({ entry }) => summarise(entry)).join("\n\n") + `\n\nCall get_component for usage and source. Install with \`npx ${options.cliPackage} add <name>\`.`);
+	});
+	server.registerTool("get_component", {
+		title: "Get a component",
+		description: "Everything about one component or block: description, accessibility notes, what it installs alongside, and optionally its full source. Use before writing code that consumes it, so the props and markup come from the registry rather than memory.",
+		inputSchema: {
+			name: z.string().describe("Registry name, e.g. \"button\", \"ai-prompt-input\", \"dashboard\""),
+			include_source: z.boolean().optional().describe("Include the component's full source. Large — ask for it only when editing or extending the component. Default: false")
+		}
+	}, async ({ name, include_source }) => {
+		const index = await registry.index();
+		const entry = index.items.find((item) => item.name === name);
+		if (!entry) {
+			const substring = index.items.map((item) => ({
+				item,
+				rank: score(item, name)
+			})).filter(({ rank }) => rank > 0).sort((a, b) => b.rank - a.rank).slice(0, 5).map(({ item }) => item.name);
+			const near = substring.length > 0 ? substring : nearest(index.items.map((item) => item.name), name);
+			return text(`No component named "${name}".` + (near.length > 0 ? ` Did you mean: ${near.join(", ")}?` : "") + ` Call search_components to see what exists — do not assume it does.`);
+		}
+		if (entry.access === "pro") return text([
+			`# ${entry.title} \`${entry.name}\``,
+			"",
+			entry.description,
+			"",
+			`Type: ${entry.type === "registry:block" ? "block" : "component"} · Category: ${entry.category} · Status: ${entry.status} · **Pro**`,
+			"",
+			`Install: \`npx ${options.cliPackage} add ${entry.name}\` — requires a licence. Sign in once with \`npx ${options.cliPackage} login\`, or set DOWEL_TOKEN in CI.`,
+			"",
+			entry.registryDependencies.length > 0 ? `Also installs: ${entry.registryDependencies.join(", ")}\n` : "",
+			`${String(entry.fileCount)} file(s). The source is served only to a licence holder, so this server cannot read it; once installed, read it from the project like any other file.`
+		].join("\n"));
+		const item = await registry.item(name);
+		const lines = [
+			`# ${item.title} \`${item.name}\``,
+			"",
+			item.description,
+			"",
+			`Type: ${item.type === "registry:block" ? "block" : "component"} · Category: ${item.category} · Status: ${item.status}`,
+			"",
+			`Install: \`npx ${options.cliPackage} add ${item.name}\``,
+			`Import:  \`import { ... } from "${options.importFrom}"\``,
+			""
+		];
+		if (item.registryDependencies.length > 0) lines.push(`Also installs: ${item.registryDependencies.join(", ")}`, "");
+		if (item.dependencies.length > 0) lines.push(`npm packages: ${item.dependencies.join(", ")}`, "");
+		if (item.a11y) lines.push("## Accessibility", "", item.a11y, "");
+		if (include_source === true) {
+			lines.push("## Source", "");
+			for (const file of item.files) lines.push(`### \`${file.path}\``, "", "```tsx", file.content, "```", "");
+		} else lines.push(`${String(item.files.length)} file(s): ${item.files.map((file) => file.path).join(", ")}.`, "Call again with include_source: true to read them.", "");
+		return text(lines.join("\n"));
+	});
+	server.registerTool("get_guide", {
+		title: "Get a guide",
+		description: "The rules for writing code with this system: conventions and accessibility, theming and tokens, the AI components, or the full catalogue. Read conventions once per session before writing UI.",
+		inputSchema: { topic: z.enum([
+			"conventions",
+			"theming",
+			"ai",
+			"catalogue"
+		]).describe("conventions: styling and accessibility rules that differ from other libraries. theming: tokens, presets, radius and motion scales. ai: the AI surfaces and when to use each. catalogue: every component and block.") }
+	}, async ({ topic }) => {
+		const context = docsContext(options, await registry.index());
+		const render = {
+			conventions: conventionsDoc,
+			theming: themesDoc,
+			ai: aiDoc,
+			catalogue: componentsDoc
+		}[topic];
+		return text(render(context));
+	});
+	server.registerTool("install_command", {
+		title: "Get the install command",
+		description: "The exact command to install components, and the full list of what it will write. Use this instead of composing an npm/pnpm install — these components are source, not a package, and the CLI resolves their dependency graph.",
+		inputSchema: { names: z.array(z.string()).min(1).describe("Registry names to install") }
+	}, async ({ names }) => {
+		let resolved;
+		try {
+			resolved = await registry.resolve(names);
+		} catch (error) {
+			return text(`${error instanceof Error ? error.message : String(error)}\n\nCall search_components to check the name.`);
+		}
+		const extra = resolved.filter((item) => !names.includes(item.name));
+		const npm = [...new Set(resolved.flatMap((item) => item.dependencies))];
+		return text([
+			`\`\`\`bash`,
+			`npx ${options.cliPackage} add ${names.join(" ")}`,
+			`\`\`\``,
+			"",
+			`Writes ${String(resolved.length)} registry item(s): ${resolved.map((item) => item.name).join(", ")}.`,
+			extra.length > 0 ? `${String(extra.length)} of those are dependencies pulled in automatically: ${extra.map((item) => item.name).join(", ")}.` : "Nothing extra is pulled in.",
+			npm.length > 0 ? `npm packages installed alongside: ${npm.join(", ")}.` : "",
+			"",
+			"Safe to re-run. A file the user has edited is never overwritten without `--overwrite`."
+		].filter(Boolean).join("\n"));
+	});
+	server.registerTool("plan_ui", {
+		title: "Plan a screen",
+		description: "Describe a screen and get the registry items that build it, the exact install command, and a starting file. Use this before writing UI from a description — it resolves against the catalogue, so it cannot suggest a component that does not exist.",
+		inputSchema: {
+			prompt: z.string().min(3).describe("What to build, e.g. \"a billing page with usage and invoices\""),
+			format: z.enum([
+				"plan",
+				"code",
+				"both"
+			]).optional().describe("plan: what to install and why. code: a starting file. Default: both")
+		}
+	}, async ({ prompt, format }) => {
+		const plan = planUi(prompt, await registry.index());
+		if (plan.empty) return text(`Nothing in the registry matches "${prompt}".\n\nCall search_components with a simpler term before building anything by hand — and if there genuinely is no component for it, build it from primitives rather than assuming one exists under another name.`);
+		const parts = [];
+		if (format !== "code") {
+			parts.push(renderBrief(plan, {
+				cliPackage: options.cliPackage,
+				docsUrl: options.docsUrl,
+				importFrom: options.importFrom
+			}));
+			parts.push("", "Why each was chosen:", ...[...plan.blocks, ...plan.components].map((item) => `- ${item.entry.name}: ${item.because}`));
+		}
+		if (format !== "plan") parts.push("", "A starting file:", "", "```tsx", renderPlan(plan, {
+			importFrom: options.importFrom,
+			docsUrl: options.docsUrl
+		}).trim(), "```");
+		parts.push("", "Call get_component for each of these before writing props. This plan does not include prop shapes, and a plausible invented prop is worse than none.");
+		return text(parts.join("\n"));
+	});
+	return server;
+}
+//#endregion
+//#region src/index.ts
+const { version } = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+/**
+* Reads a `--flag value` pair from argv.
+*
+* Hand-rolled rather than pulled from a parser: this binary is launched by an
+* MCP client from a JSON config, takes two options, and every dependency here
+* is a dependency of every agent session that starts the server.
+*/
+function flag(name) {
+	const index = process.argv.indexOf(`--${name}`);
+	if (index === -1) return void 0;
+	return process.argv[index + 1];
+}
+async function main() {
+	const registryUrl = flag("registry") ?? process.env.DOWEL_REGISTRY ?? branding.registryUrl;
+	const importFrom = flag("import-from") ?? process.env.DOWEL_IMPORT_FROM ?? `${branding.packageScope}/react`;
+	await createServer({
+		registryUrl,
+		docsUrl: branding.registryUrl.replace(/\/r$/, ""),
+		cliPackage: branding.cliPackage,
+		libraryName: branding.libraryName,
+		importFrom,
+		version
+	}).connect(new StdioServerTransport());
+}
+main().catch((error) => {
+	console.error(error instanceof Error ? error.stack : String(error));
+	process.exit(1);
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=index.js.map