@cascivo/mcp 0.1.0

package/dist/index.mjs

@@ -0,0 +1,721 @@
+#!/usr/bin/env node
+import { argv } from "node:process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { spawnSync } from "node:child_process";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+//#region src/registry.ts
+const HERE$2 = dirname(fileURLToPath(import.meta.url));
+/**
+* Resolve the registry.json location. Checks, in order: an explicit path, the
+* `CASCIVO_REGISTRY_PATH` env var, a copy bundled next to the built server
+* (published package), and the monorepo root (dev).
+*/
+function resolveRegistryPath(explicit) {
+	const candidates = [
+		explicit,
+		process.env.CASCIVO_REGISTRY_PATH,
+		join(HERE$2, "registry.json"),
+		join(HERE$2, "..", "..", "..", "registry.json"),
+		join(HERE$2, "..", "..", "registry.json")
+	].filter((p) => typeof p === "string" && p.length > 0);
+	return candidates.find((p) => existsSync(p)) ?? candidates[candidates.length - 1] ?? "registry.json";
+}
+function loadRegistry(path) {
+	const resolved = resolveRegistryPath(path);
+	const raw = JSON.parse(readFileSync(resolved, "utf8"));
+	if (!Array.isArray(raw.components)) throw new Error(`Invalid registry at ${resolved}: "components" must be an array`);
+	return raw;
+}
+/** List component manifests, optionally filtered by category and/or type. */
+function listComponents(registry, category, type) {
+	let entries = registry.components;
+	if (category) entries = entries.filter((c) => c.category === category);
+	if (type) entries = entries.filter((c) => c.type === type);
+	return entries.map((c) => c.meta);
+}
+/** Find one component manifest by name (matches registry name or meta name). */
+function getComponent(registry, name) {
+	const target = name.toLowerCase();
+	return registry.components.find((c) => c.name.toLowerCase() === target || c.meta.name.toLowerCase() === target)?.meta;
+}
+const DIRECTORY_URL = "https://cascivo.com/r/registries.json";
+const FETCH_TIMEOUT_MS = 15e3;
+const MAX_BODY_BYTES = 1048576;
+async function fetchWithGuards(url, fetchFn = fetch) {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+	try {
+		const res = await fetchFn(url, { signal: controller.signal });
+		if (!res.ok) return null;
+		const buf = await res.arrayBuffer();
+		if (buf.byteLength > MAX_BODY_BYTES) return null;
+		return new TextDecoder().decode(buf);
+	} catch {
+		return null;
+	} finally {
+		clearTimeout(timer);
+	}
+}
+/** Fetch the central cascade registry directory. Returns empty array on failure. */
+async function fetchDirectory(fetchFn) {
+	const raw = await fetchWithGuards(DIRECTORY_URL, fetchFn);
+	if (!raw) return [];
+	try {
+		const parsed = JSON.parse(raw);
+		if (!Array.isArray(parsed)) return [];
+		return parsed;
+	} catch {
+		return [];
+	}
+}
+/** Fetch the component index from a namespace's registryUrl. Returns null on failure. */
+async function fetchRegistryIndex(registryUrl, fetchFn) {
+	const raw = await fetchWithGuards(registryUrl.includes("{name}") ? registryUrl.replace("{name}", "registry").replace(/\/registry$/, "/registry.json") : registryUrl.replace(/\/?$/, "/registry.json").replace(/\/\/registry\.json$/, "/registry.json"), fetchFn);
+	if (!raw) return null;
+	try {
+		const parsed = JSON.parse(raw);
+		if (!Array.isArray(parsed.components)) return null;
+		return parsed;
+	} catch {
+		return null;
+	}
+}
+/** Parse CASCADE_REGISTRIES env var — returns empty array on failure. */
+function getEnvRegistries() {
+	const raw = process.env["CASCADE_REGISTRIES"];
+	if (!raw) return [];
+	try {
+		const parsed = JSON.parse(raw);
+		if (!Array.isArray(parsed)) return [];
+		return parsed;
+	} catch {
+		return [];
+	}
+}
+/** Merge directory entries with env entries (env wins on namespace collision). */
+function mergeRegistries(directory, env) {
+	const map = /* @__PURE__ */ new Map();
+	for (const entry of directory) map.set(entry.namespace, entry);
+	for (const entry of env) map.set(entry.namespace, entry);
+	return Array.from(map.values());
+}
+/** Fuzzy search over name, tags, and description. */
+function searchComponents(registry, query) {
+	const q = query.toLowerCase().trim();
+	if (q === "") return [];
+	return registry.components.filter((c) => c.name.toLowerCase().includes(q) || c.description.toLowerCase().includes(q) || c.tags.some((t) => t.toLowerCase().includes(q))).map((c) => c.meta);
+}
+//#endregion
+//#region src/theme.ts
+/** Darken a color by mixing in black (modern CSS, no preprocessor). */
+function darken(color, amount) {
+	return `color-mix(in oklab, ${color}, black ${amount}%)`;
+}
+/** Lighten a color by mixing in white. */
+function lighten(color, amount) {
+	return `color-mix(in oklab, ${color}, white ${amount}%)`;
+}
+/**
+* Generate a custom cascade theme as CSS. Maps the three input colors onto the
+* semantic token layer; component tokens inherit automatically.
+*/
+function generateThemeCss(colors, name = "custom") {
+	const { primary, neutral, accent } = colors;
+	return `/* Cascade — Generated theme: ${name} */
+
+@layer cascade.theme {
+  [data-theme='${name}'] {
+    color-scheme: light;
+
+    /* ── Surface (derived from neutral) ───────────────── */
+    --cascivo-color-bg: ${lighten(neutral, 96)};
+    --cascivo-color-bg-subtle: ${lighten(neutral, 92)};
+    --cascivo-color-surface: ${lighten(neutral, 98)};
+    --cascivo-color-surface-raised: ${lighten(neutral, 94)};
+    --cascivo-color-surface-overlay: ${lighten(neutral, 98)};
+    --cascivo-color-border: ${lighten(neutral, 80)};
+    --cascivo-color-border-strong: ${lighten(neutral, 65)};
+
+    /* ── Text (derived from neutral) ──────────────────── */
+    --cascivo-color-text: ${darken(neutral, 80)};
+    --cascivo-color-text-subtle: ${darken(neutral, 50)};
+    --cascivo-color-text-muted: ${lighten(neutral, 30)};
+    --cascivo-color-text-on-accent: #ffffff;
+    --cascivo-color-text-on-destructive: #ffffff;
+
+    /* ── Accent / primary interactive ─────────────────── */
+    --cascivo-color-accent: ${primary};
+    --cascivo-color-accent-hover: ${darken(primary, 12)};
+    --cascivo-color-accent-active: ${darken(primary, 24)};
+    --cascivo-color-accent-subtle: ${lighten(primary, 88)};
+    --cascivo-color-accent-muted: ${lighten(primary, 76)};
+
+    /* ── Secondary accent (info / focus) ──────────────── */
+    --cascivo-color-info: ${accent};
+    --cascivo-color-info-subtle: ${lighten(accent, 88)};
+    --cascivo-color-focus-ring: ${accent};
+    --cascivo-focus-ring: 0 0 0 3px ${lighten(accent, 20)};
+
+    /* ── Status ───────────────────────────────────────── */
+    --cascivo-color-destructive: #dc2626;
+    --cascivo-color-destructive-hover: ${darken("#dc2626", 12)};
+    --cascivo-color-destructive-subtle: ${lighten("#dc2626", 88)};
+    --cascivo-color-success: #16a34a;
+    --cascivo-color-success-subtle: ${lighten("#16a34a", 88)};
+    --cascivo-color-warning: #f59e0b;
+    --cascivo-color-warning-subtle: ${lighten("#f59e0b", 88)};
+  }
+}
+`;
+}
+//#endregion
+//#region src/scaffold.ts
+const DEFAULT_COMPONENTS = [
+	"card",
+	"input",
+	"button"
+];
+function pascalCase(name) {
+	return name.split(/[-_\s]+/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+/** A reasonable default usage snippet per component for the scaffold. */
+function usage(component, Tag) {
+	switch (component) {
+		case "button": return `      <${Tag}>Get started</${Tag}>`;
+		case "input": return `      <${Tag} label="Email" placeholder="you@example.com" />`;
+		case "card": return `      <${Tag}>\n        <h2>Card title</h2>\n        <p>Card content goes here.</p>\n      </${Tag}>`;
+		case "badge": return `      <${Tag}>New</${Tag}>`;
+		default: return `      <${Tag} />`;
+	}
+}
+/**
+* Generate a JSX page layout string from a natural-language description and an
+* optional list of cascade components to include.
+*/
+function scaffoldPage(options) {
+	const components = options.components?.length ? options.components : DEFAULT_COMPONENTS;
+	const unique = [...new Set(components.map((c) => c.toLowerCase()))];
+	const imports = unique.map((c) => `import { ${pascalCase(c)} } from './components/ui/${c}/${c}'`).join("\n");
+	const body = unique.map((c) => usage(c, pascalCase(c))).join("\n");
+	return `${imports}
+
+/* ${options.description} */
+export function Page() {
+  return (
+    <main
+      data-theme="light"
+      style={{ maxWidth: '48rem', margin: '0 auto', padding: '2rem', display: 'grid', gap: '1rem' }}
+    >
+${body}
+    </main>
+  )
+}
+`;
+}
+//#endregion
+//#region src/validate.ts
+const DATA_REF_RE = /^\$data\./;
+const ACTION_REF_RE = /^\$actions\./;
+function closestName(name, candidates) {
+	const target = name.toLowerCase();
+	let best;
+	let bestDist = 3;
+	for (const candidate of candidates) {
+		const dist = levenshtein(target, candidate.toLowerCase());
+		if (dist < bestDist) {
+			bestDist = dist;
+			best = candidate;
+		}
+	}
+	return best;
+}
+function levenshtein(a, b) {
+	const m = a.length;
+	const n = b.length;
+	const dp = Array.from({ length: m + 1 }, (_, i) => Array.from({ length: n + 1 }, (_, j) => i === 0 ? j : j === 0 ? i : 0));
+	for (let i = 1; i <= m; i++) for (let j = 1; j <= n; j++) dp[i][j] = a[i - 1] === b[j - 1] ? dp[i - 1][j - 1] : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+	return dp[m][n];
+}
+function validateNode(node, path, errors, componentNames) {
+	if (typeof node !== "object" || node === null) {
+		errors.push({
+			path,
+			message: "Expected a component node object"
+		});
+		return;
+	}
+	const n = node;
+	if (typeof n["component"] !== "string") {
+		errors.push({
+			path: `${path}.component`,
+			message: "component must be a string"
+		});
+		return;
+	}
+	const componentName = n["component"];
+	if (!componentNames.has(componentName)) {
+		const suggestion = closestName(componentName, [...componentNames]);
+		const hint = suggestion ? ` Did you mean "${suggestion}"?` : "";
+		errors.push({
+			path: `${path}.component`,
+			message: `Unknown component "${componentName}".${hint}`
+		});
+		return;
+	}
+	const nodeBind = n["bind"] ?? {};
+	for (const [key, value] of Object.entries(nodeBind)) if (typeof value !== "string" || !DATA_REF_RE.test(value)) errors.push({
+		path: `${path}.bind.${key}`,
+		message: `bind values must start with "$data." — got "${value}"`
+	});
+	const nodeEvents = n["events"] ?? {};
+	for (const [key, value] of Object.entries(nodeEvents)) if (typeof value !== "string" || !ACTION_REF_RE.test(value)) errors.push({
+		path: `${path}.events.${key}`,
+		message: `events values must start with "$actions." — got "${value}"`
+	});
+	if (Array.isArray(n["children"])) for (let i = 0; i < n["children"].length; i++) validateNode(n["children"][i], `${path}.children[${i}]`, errors, componentNames);
+}
+/** Validate a ViewConfig object. Component names are checked against the provided set. */
+function validateView(config, componentNames) {
+	const errors = [];
+	if (typeof config !== "object" || config === null) return {
+		valid: false,
+		errors: [{
+			path: "",
+			message: "Config must be an object"
+		}]
+	};
+	const view = config["view"];
+	if (typeof view !== "object" || view === null) return {
+		valid: false,
+		errors: [{
+			path: "view",
+			message: "view must be an object"
+		}]
+	};
+	const regions = view["regions"];
+	if (typeof regions !== "object" || regions === null) {
+		errors.push({
+			path: "view.regions",
+			message: "view.regions must be an object"
+		});
+		return {
+			valid: false,
+			errors
+		};
+	}
+	for (const [regionName, nodes] of Object.entries(regions)) {
+		if (!Array.isArray(nodes)) {
+			errors.push({
+				path: `view.regions.${regionName}`,
+				message: `Region "${regionName}" must be an array of component nodes`
+			});
+			continue;
+		}
+		for (let i = 0; i < nodes.length; i++) validateNode(nodes[i], `view.regions.${regionName}[${i}]`, errors, componentNames);
+	}
+	return {
+		valid: errors.length === 0,
+		errors
+	};
+}
+//#endregion
+//#region src/scaffold-view.ts
+/** Simple keyword matcher — returns region layout name based on description keywords. */
+function pickLayout(description) {
+	const d = description.toLowerCase();
+	if (d.includes("dashboard") || d.includes("stats") || d.includes("kpi")) return "dashboard";
+	if (d.includes("settings") || d.includes("preferences") || d.includes("config")) return "settings";
+	if (d.includes("login") || d.includes("auth") || d.includes("sign")) return "auth";
+	return "none";
+}
+/** Pick sensible components from the registry matching keywords in description. */
+function pickComponents(description, registry, explicit) {
+	if (explicit && explicit.length > 0) return explicit.map((c) => c.toLowerCase());
+	const d = description.toLowerCase();
+	const candidates = [];
+	for (const entry of registry.components) {
+		const name = entry.meta.name.toLowerCase();
+		const tags = entry.tags.join(" ").toLowerCase();
+		if (d.includes(name) || tags.split(" ").some((t) => d.includes(t))) candidates.push(entry.meta.name);
+	}
+	if (candidates.length === 0) candidates.push("Badge");
+	return candidates.slice(0, 4);
+}
+function makeNode(componentName, registry) {
+	const entry = registry.components.find((c) => c.meta.name.toLowerCase() === componentName.toLowerCase());
+	if (!entry) return { component: componentName };
+	const props = {};
+	for (const prop of entry.meta.props ?? []) if (prop.required && prop.default !== void 0) props[prop.name] = prop.default;
+	else if (prop.default !== void 0 && [
+		"string",
+		"number",
+		"boolean"
+	].includes(typeof prop.default)) {}
+	return Object.keys(props).length > 0 ? {
+		component: entry.meta.name,
+		props
+	} : { component: entry.meta.name };
+}
+function scaffoldView(input, registry) {
+	const layout = pickLayout(input.description);
+	const componentNames = pickComponents(input.description, registry, input.components);
+	const config = {
+		$schema: "https://raw.githubusercontent.com/urbanisierung/cascivo/main/packages/render/schema/view.v1.json",
+		version: 1,
+		view: {
+			...layout !== "none" ? { layout } : {},
+			regions: { main: componentNames.map((name) => makeNode(name, registry)) }
+		}
+	};
+	const { errors } = validateView(config, new Set(registry.components.map((c) => c.meta.name)));
+	return {
+		config,
+		errors
+	};
+}
+//#endregion
+//#region src/tokens.ts
+const HERE$1 = dirname(fileURLToPath(import.meta.url));
+const CATALOG_BASE_URL = "https://cascivo.com";
+async function loadTokenCatalog(fetchFn) {
+	const localPaths = [join(HERE$1, "..", "..", "..", "apps", "docs", "public", "tokens.catalog.json"), join(HERE$1, "tokens.catalog.json")];
+	for (const p of localPaths) if (existsSync(p)) return JSON.parse(readFileSync(p, "utf8"));
+	const res = await (fetchFn ?? fetch)(`${CATALOG_BASE_URL}/tokens.catalog.json`);
+	if (!res.ok) throw new Error(`Failed to fetch token catalog: ${res.status}`);
+	return res.json();
+}
+//#endregion
+//#region src/context.ts
+const HERE = dirname(fileURLToPath(import.meta.url));
+const CONTEXT_BASE_URL = "https://cascivo.com";
+async function loadContext(fetchFn) {
+	const localPaths = [join(HERE, "..", "..", "..", "apps", "docs", "public", "context.json"), join(HERE, "context.json")];
+	for (const p of localPaths) if (existsSync(p)) return JSON.parse(readFileSync(p, "utf8"));
+	const res = await (fetchFn ?? fetch)(`${CONTEXT_BASE_URL}/context.json`);
+	if (!res.ok) throw new Error(`Failed to fetch context bundle: ${res.status}`);
+	return res.json();
+}
+async function loadComponentMarkdown(name, fetchFn) {
+	const slug = name.toLowerCase().replace(/\s+/g, "-");
+	const localPaths = [join(HERE, "..", "..", "..", "apps", "docs", "public", "context", `${slug}.md`), join(HERE, "context", `${slug}.md`)];
+	for (const p of localPaths) if (existsSync(p)) return readFileSync(p, "utf8");
+	const url = `${CONTEXT_BASE_URL}/context/${slug}.md`;
+	const fn = fetchFn ?? fetch;
+	try {
+		const res = await fn(url);
+		if (!res.ok) return null;
+		return res.text();
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/select.ts
+const MIN_WORD_LEN = 3;
+function words(text) {
+	return (text.toLowerCase().match(/\b\w+\b/g) ?? []).filter((w) => w.length >= MIN_WORD_LEN);
+}
+function countMatches(needWords, text) {
+	const lower = text.toLowerCase();
+	return needWords.filter((w) => lower.includes(w));
+}
+function selectComponent(need, components) {
+	const needWords = words(need);
+	if (needWords.length === 0) return [];
+	const scored = components.map((c) => {
+		const whenToUseText = c.intent.whenToUse.join(" ");
+		const whenNotToUseText = c.intent.whenNotToUse.join(" ");
+		const whenToUseMatches = countMatches(needWords, whenToUseText);
+		const descMatches = countMatches(needWords, c.description);
+		const penaltyMatches = countMatches(needWords, whenNotToUseText);
+		const score = whenToUseMatches.length * 2 + descMatches.length - penaltyMatches.length * 3;
+		let why = "";
+		if (whenToUseMatches.length > 0) {
+			const bestSentence = c.intent.whenToUse.map((s) => ({
+				s,
+				count: countMatches(needWords, s).length
+			})).filter((x) => x.count > 0).sort((a, b) => b.count - a.count)[0]?.s;
+			why = bestSentence ? `Matched: ${whenToUseMatches.map((w) => `'${w}'`).join(", ")} in whenToUse — "${bestSentence}"` : `Matched: ${whenToUseMatches.map((w) => `'${w}'`).join(", ")} in description`;
+		} else if (descMatches.length > 0) why = `Matched: ${descMatches.map((w) => `'${w}'`).join(", ")} in description`;
+		return {
+			name: c.name,
+			score,
+			why,
+			related: c.intent.related ?? []
+		};
+	});
+	const top3Names = new Set([...scored].sort((a, b) => b.score - a.score || a.name.localeCompare(b.name)).slice(0, 3).map((r) => r.name));
+	const relatedBonus = /* @__PURE__ */ new Map();
+	for (const r of scored) {
+		if (!top3Names.has(r.name)) continue;
+		for (const rel of r.related) relatedBonus.set(rel.name, (relatedBonus.get(rel.name) ?? 0) + 1);
+	}
+	return scored.map((r) => ({
+		name: r.name,
+		score: r.score + (relatedBonus.get(r.name) ?? 0),
+		why: r.why
+	})).filter((r) => r.score >= 0).sort((a, b) => b.score - a.score || a.name.localeCompare(b.name)).slice(0, 5);
+}
+//#endregion
+//#region src/server.ts
+const json = (value) => ({ content: [{
+	type: "text",
+	text: JSON.stringify(value, null, 2)
+}] });
+const text = (value) => ({ content: [{
+	type: "text",
+	text: value
+}] });
+const error = (message) => ({
+	content: [{
+		type: "text",
+		text: message
+	}],
+	isError: true
+});
+/** Build a configured McpServer exposing the cascade component registry. */
+function createServer(options = {}) {
+	const registry = loadRegistry(options.registryPath);
+	const fetchFn = options.fetchFn;
+	const server = new McpServer({
+		name: "@cascivo/mcp",
+		version: options.version ?? "0.0.0"
+	});
+	server.registerTool("list_registries", {
+		title: "List registries",
+		description: "List available component registries: the cascade directory plus any configured via CASCADE_REGISTRIES env.",
+		inputSchema: {}
+	}, async () => {
+		const [directory] = await Promise.all([fetchDirectory(fetchFn)]);
+		return json(mergeRegistries(directory, getEnvRegistries()).map(({ namespace, name, description, verified, homepage }) => ({
+			namespace,
+			name,
+			description,
+			verified: verified ?? false,
+			homepage
+		})));
+	});
+	server.registerTool("list_components", {
+		title: "List components",
+		description: "List all cascade components, optionally filtered by category and/or type.",
+		inputSchema: {
+			category: z.enum([
+				"inputs",
+				"display",
+				"overlay",
+				"navigation",
+				"feedback",
+				"chart"
+			]).optional().describe("Filter by component category"),
+			type: z.enum([
+				"component",
+				"layout",
+				"block",
+				"chart"
+			]).optional().describe("Filter by entry type")
+		}
+	}, ({ category, type }) => json(listComponents(registry, category, type)));
+	server.registerTool("get_component", {
+		title: "Get component",
+		description: "Get the full manifest (props, states, tokens, a11y, examples) for one component.",
+		inputSchema: {
+			name: z.string().describe("Component name, e.g. \"button\""),
+			registry: z.string().optional().describe("Namespace of an external registry, e.g. \"@myns\". Omit for the default.")
+		}
+	}, async ({ name, registry: ns }) => {
+		if (ns) {
+			const env = getEnvRegistries();
+			const entry = mergeRegistries(await fetchDirectory(fetchFn), env).find((e) => e.namespace === ns);
+			if (!entry) return error(`Registry "${ns}" not found.`);
+			const remoteRegistry = await fetchRegistryIndex(entry.registryUrl, fetchFn);
+			if (!remoteRegistry) return error(`Failed to fetch registry index for "${ns}".`);
+			const meta = getComponent(remoteRegistry, name);
+			return meta ? json(meta) : error(`Component "${name}" not found in registry "${ns}".`);
+		}
+		const meta = getComponent(registry, name);
+		return meta ? json(meta) : error(`Component "${name}" not found.`);
+	});
+	server.registerTool("search_components", {
+		title: "Search components",
+		description: "Fuzzy search components by name, tags, or description.",
+		inputSchema: {
+			query: z.string().describe("Search query"),
+			registry: z.string().optional().describe("Namespace of an external registry, e.g. \"@myns\". Omit for the default.")
+		}
+	}, async ({ query, registry: ns }) => {
+		if (ns) {
+			const env = getEnvRegistries();
+			const entry = mergeRegistries(await fetchDirectory(fetchFn), env).find((e) => e.namespace === ns);
+			if (!entry) return error(`Registry "${ns}" not found.`);
+			const remoteRegistry = await fetchRegistryIndex(entry.registryUrl, fetchFn);
+			if (!remoteRegistry) return error(`Failed to fetch registry index for "${ns}".`);
+			return json(searchComponents(remoteRegistry, query));
+		}
+		return json(searchComponents(registry, query));
+	});
+	server.registerTool("add_to_project", {
+		title: "Add to project",
+		description: "Add a component to the current project by running the cascade CLI.",
+		inputSchema: {
+			name: z.string().describe("Component name to add"),
+			outputDir: z.string().optional().describe("Directory to write the component into")
+		}
+	}, ({ name, outputDir }) => {
+		const env = outputDir ? {
+			...process.env,
+			CASCIVO_OUTPUT_DIR: outputDir
+		} : process.env;
+		const result = spawnSync("npx", [
+			"-y",
+			"cascivo",
+			"add",
+			name
+		], {
+			encoding: "utf8",
+			env
+		});
+		if (result.status !== 0) return error(result.stderr || result.error?.message || `Failed to add "${name}".`);
+		return text(result.stdout || `Added ${name}.`);
+	});
+	server.registerTool("create_theme", {
+		title: "Create theme",
+		description: "Generate a cascade theme CSS file from three colors.",
+		inputSchema: {
+			primary: z.string().describe("Primary / interactive color (any CSS color)"),
+			neutral: z.string().describe("Base neutral color for surfaces and text"),
+			accent: z.string().describe("Secondary accent color (info / focus)"),
+			name: z.string().optional().describe("Theme name (default: \"custom\")")
+		}
+	}, ({ primary, neutral, accent, name }) => text(generateThemeCss({
+		primary,
+		neutral,
+		accent
+	}, name)));
+	server.registerTool("scaffold_page", {
+		title: "Scaffold page (deprecated)",
+		description: "[Deprecated — use scaffold_view instead] Generate a JSX page layout from a description.",
+		inputSchema: {
+			description: z.string().describe("What the page is for"),
+			components: z.array(z.string()).optional().describe("Components to include")
+		}
+	}, ({ description, components }) => {
+		const { config } = scaffoldView({
+			description,
+			...components ? { components } : {}
+		}, registry);
+		return text(`[Deprecated] Use scaffold_view for config-first output. JSX scaffold:\n\n${scaffoldPage(components ? {
+			description,
+			components
+		} : { description })}\n\n--- scaffold_view output ---\n${JSON.stringify(config, null, 2)}`);
+	});
+	server.registerTool("validate_view", {
+		title: "Validate view config",
+		description: "Validate a CascadeView JSON config against the registry. Returns errors with exact paths.",
+		inputSchema: { config: z.record(z.string(), z.unknown()).describe("The ViewConfig object to validate") }
+	}, ({ config }) => {
+		return json(validateView(config, new Set(registry.components.map((c) => c.meta.name))));
+	});
+	server.registerTool("scaffold_view", {
+		title: "Scaffold view config",
+		description: "Generate a valid starter ViewConfig from a description. Always validates before returning.",
+		inputSchema: {
+			description: z.string().describe("What the page/view is for"),
+			components: z.array(z.string()).optional().describe("Component names to include")
+		}
+	}, ({ description, components }) => {
+		const { config, errors } = scaffoldView({
+			description,
+			...components ? { components } : {}
+		}, registry);
+		if (errors.length > 0) return json({
+			valid: false,
+			errors,
+			config
+		});
+		return json({
+			valid: true,
+			config
+		});
+	});
+	server.registerTool("get_tokens", {
+		title: "Get tokens",
+		description: "Get the cascade token catalog (closed set). Agents must select from this catalog rather than hard-coding values.",
+		inputSchema: {
+			group: z.string().optional().describe("Filter by token group, e.g. \"color\", \"space\", \"radius\""),
+			layer: z.enum([
+				"primitive",
+				"semantic",
+				"component"
+			]).optional().describe("Filter by layer")
+		}
+	}, async ({ group, layer }) => {
+		try {
+			let tokens = (await loadTokenCatalog(fetchFn)).tokens;
+			if (group) tokens = tokens.filter((t) => t.group === group);
+			if (layer) tokens = tokens.filter((t) => t.layer === layer);
+			return json({
+				count: tokens.length,
+				tokens
+			});
+		} catch (e) {
+			return error(`Token catalog unavailable: ${e instanceof Error ? e.message : String(e)}`);
+		}
+	});
+	server.registerTool("get_context", {
+		title: "Get context",
+		description: "Get intent, whenToUse/whenNotToUse, and authoring guidance for one component by name.",
+		inputSchema: { name: z.string().describe("Component name, e.g. \"Toast\"") }
+	}, async ({ name }) => {
+		try {
+			const ctx = await loadContext(fetchFn);
+			const target = name.toLowerCase();
+			const component = ctx.components.find((c) => c.name.toLowerCase() === target);
+			if (!component) return error(`Component "${name}" not found. Available: ${ctx.components.map((c) => c.name).join(", ")}`);
+			const md = await loadComponentMarkdown(component.name, fetchFn);
+			return json({
+				name: component.name,
+				category: component.category,
+				description: component.description,
+				intent: component.intent,
+				contextUrl: component.contextUrl,
+				...md ? { markdown: md } : {}
+			});
+		} catch (e) {
+			return error(`Context bundle unavailable: ${e instanceof Error ? e.message : String(e)}`);
+		}
+	});
+	server.registerTool("select_component", {
+		title: "Select component",
+		description: "Heuristic ranking of cascade components by natural language need. Returns top matches with scores and reasons. Note: heuristic ranking, not a model call.",
+		inputSchema: { need: z.string().describe("Natural language description of what the component should do") }
+	}, async ({ need }) => {
+		try {
+			return json({
+				note: "Heuristic ranking — not a model call. Verify with get_context before using.",
+				results: selectComponent(need, (await loadContext(fetchFn)).components)
+			});
+		} catch (e) {
+			return error(`Context bundle unavailable: ${e instanceof Error ? e.message : String(e)}`);
+		}
+	});
+	return server;
+}
+//#endregion
+//#region src/index.ts
+const VERSION = "0.0.0";
+/** Start the MCP server over stdio. */
+async function main() {
+	await createServer({ version: VERSION }).connect(new StdioServerTransport());
+}
+if (argv[1] !== void 0 && import.meta.url === pathToFileURL(argv[1]).href) main().catch((err) => {
+	console.error(err instanceof Error ? err.message : String(err));
+	process.exitCode = 1;
+});
+//#endregion
+export { VERSION, createServer, generateThemeCss, getComponent, listComponents, loadRegistry, main, scaffoldPage, searchComponents };
+
+//# sourceMappingURL=index.mjs.map