@plitzi/sdk-server 0.32.4 → 0.32.5

package/dist/modules/mcp/tools/operations/schema/upsertElement.js

@@ -0,0 +1,59 @@
+import { findPageByRef, resolveRef } from "../../../helpers/space.js";
+import { empty, fail } from "../../../helpers/opResult.js";
+import { createElement, pageUri } from "./write.js";
+import { elementInput, position } from "./shared.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/schema/upsertElement.ts
+var upsertElementOp = z.object({
+	type: z.literal("upsertElement"),
+	pageRef: z.string().describe("Page ref or id"),
+	element: elementInput,
+	parentRef: z.string().optional().describe("Anchor ref/id; defaults to page root"),
+	position: position.optional()
+}).describe("Add an element to a page, or fully update it when element.ref already exists (props and style are REPLACED, not merged). To change only some fields of an existing element, use patchElement instead.");
+var upsertElement = (space, env, op) => {
+	const page = findPageByRef(space.schema, op.pageRef);
+	if (!page) return fail("pageRef", `Page "${op.pageRef}" not found`, "Read plitzi://schema/" + env + "/pages for valid refs");
+	const existing = resolveRef(space.schema, page, op.element.ref);
+	if (existing && existing.id !== page.id) {
+		if (op.element.label !== void 0) existing.definition.label = op.element.label;
+		if (op.element.props !== void 0 || op.element.subType !== void 0) {
+			const subType = op.element.subType ?? existing.attributes.subType;
+			existing.attributes = subType === void 0 ? { ...op.element.props } : {
+				subType,
+				...op.element.props
+			};
+		}
+		if (op.element.style !== void 0) {
+			const selectors = { base: (op.element.style.base ?? []).join(" ") };
+			for (const [slot, classes] of Object.entries(op.element.style.slots ?? {})) selectors[slot] = classes.join(" ");
+			existing.definition.styleSelectors = selectors;
+		}
+		return {
+			...empty(),
+			updated: 1,
+			staleResources: [pageUri(env, op.pageRef)],
+			elementRefs: [op.element.ref]
+		};
+	}
+	let parent = page;
+	let index;
+	if (op.parentRef) {
+		const anchor = resolveRef(space.schema, page, op.parentRef);
+		if (!anchor) return fail("parentRef", `Parent "${op.parentRef}" not found in page "${op.pageRef}"`, "Use an existing ref");
+		if (op.position === "before" || op.position === "after") {
+			parent = anchor.definition.parentId ? space.schema.flat[anchor.definition.parentId] : page;
+			const at = (parent.definition.items ?? []).indexOf(anchor.id);
+			index = at < 0 ? void 0 : op.position === "after" ? at + 1 : at;
+		} else parent = anchor;
+	}
+	createElement(space, page, op.element, parent, index);
+	return {
+		...empty(),
+		created: 1,
+		staleResources: [pageUri(env, op.pageRef)],
+		elementRefs: [op.element.ref]
+	};
+};
+//#endregion
+export { upsertElement, upsertElementOp };

package/dist/modules/mcp/tools/operations/schema/upsertFolder.js

@@ -0,0 +1,49 @@
+import { findFolderByRef, pageFoldersOf, slugify, sortFolders } from "../../../helpers/space.js";
+import { empty, fail } from "../../../helpers/opResult.js";
+import { folderUri, foldersUri } from "./write.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/schema/upsertFolder.ts
+var upsertFolderOp = z.object({
+	type: z.literal("upsertFolder"),
+	ref: z.string().describe("Folder ref: an existing folder id/name/slug to update, or a new id you choose"),
+	name: z.string().optional(),
+	slug: z.string().optional(),
+	parentId: z.string().nullable().optional().describe("Ref of the parent folder for nesting; null keeps it at root")
+}).describe("Create a sidebar page-folder, or update it when ref already exists. Nest it under another via parentId.");
+var upsertFolder = (space, env, op) => {
+	const folders = pageFoldersOf(space.schema);
+	let parentId;
+	if (op.parentId !== void 0 && op.parentId !== null) {
+		const parent = findFolderByRef(space.schema, op.parentId);
+		if (!parent) return fail("parentId", `Parent folder "${op.parentId}" not found`, "Create it with upsertFolder first");
+		parentId = parent.id;
+	}
+	const existing = findFolderByRef(space.schema, op.ref);
+	if (existing) {
+		if (op.name !== void 0) existing.name = op.name;
+		if (op.slug !== void 0) existing.slug = op.slug;
+		if (op.parentId === null) Reflect.deleteProperty(existing, "parentId");
+		else if (op.parentId !== void 0) existing.parentId = parentId;
+		space.schema.pageFolders = sortFolders(folders);
+		return {
+			...empty(),
+			updated: 1,
+			staleResources: [folderUri(env, existing.id), foldersUri(env)]
+		};
+	}
+	const folder = {
+		id: op.ref,
+		name: op.name ?? op.ref,
+		slug: op.slug ?? slugify(op.ref)
+	};
+	if (parentId !== void 0) folder.parentId = parentId;
+	folders.push(folder);
+	space.schema.pageFolders = sortFolders(folders);
+	return {
+		...empty(),
+		created: 1,
+		staleResources: [folderUri(env, folder.id), foldersUri(env)]
+	};
+};
+//#endregion
+export { upsertFolder, upsertFolderOp };

package/dist/modules/mcp/tools/operations/schema/upsertPage.js

@@ -0,0 +1,64 @@
+import { findFolderByRef, findPageByRef, generateObjectId } from "../../../helpers/space.js";
+import { empty, fail } from "../../../helpers/opResult.js";
+import { pageUri, pagesUri } from "./write.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/schema/upsertPage.ts
+var upsertPageOp = z.object({
+	type: z.literal("upsertPage"),
+	ref: z.string().describe("Page id/slug to update, or a new id you choose to create one"),
+	label: z.string().optional(),
+	slug: z.string().optional(),
+	folder: z.string().nullable().optional().describe("Ref of an existing folder to place this page in; \"\" or null moves it to the root. Unknown → error"),
+	default: z.boolean().optional()
+}).describe("Create a page, or update it when ref already exists (only the fields you pass change).");
+var upsertPage = (space, env, op) => {
+	let folderValue;
+	if (op.folder !== void 0) if (op.folder === null || op.folder === "") folderValue = "";
+	else {
+		const resolved = findFolderByRef(space.schema, op.folder);
+		if (!resolved) return fail("folder", `Folder "${op.folder}" not found`, "Create it with upsertFolder, or read plitzi://folders");
+		folderValue = resolved.id;
+	}
+	const existing = findPageByRef(space.schema, op.ref);
+	if (existing) {
+		existing.attributes = {
+			...existing.attributes,
+			...op.slug !== void 0 ? { slug: op.slug } : {},
+			...op.label !== void 0 ? { name: op.label } : {},
+			...op.default !== void 0 ? { default: op.default } : {},
+			...folderValue !== void 0 ? { folder: folderValue } : {}
+		};
+		return {
+			...empty(),
+			updated: 1,
+			staleResources: [pageUri(env, op.ref), pagesUri(env)]
+		};
+	}
+	const id = generateObjectId();
+	const attributes = {
+		slug: op.slug ?? "",
+		name: op.label ?? op.ref,
+		default: op.default ?? false,
+		folder: folderValue ?? ""
+	};
+	space.schema.flat[id] = {
+		id,
+		attributes,
+		definition: {
+			rootId: id,
+			label: op.label ?? op.ref,
+			type: "page",
+			items: [],
+			styleSelectors: { base: "" },
+			aiRef: op.ref
+		}
+	};
+	space.schema.pages.push(id);
+	return {
+		...empty(),
+		created: 1,
+		staleResources: [pageUri(env, op.ref), pagesUri(env)]
+	};
+};
+//#endregion
+export { upsertPage, upsertPageOp };

package/dist/modules/mcp/tools/operations/schema/upsertVariable.js

@@ -0,0 +1,42 @@
+import { empty } from "../../../helpers/opResult.js";
+import { schemaVarsUri } from "./write.js";
+import { scalar } from "./shared.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/schema/upsertVariable.ts
+var upsertVariableOp = z.object({
+	type: z.literal("upsertVariable"),
+	name: z.string().describe("Variable name; referenced in content as {{name}}"),
+	variableType: z.string().describe("Runtime type (text|number|...); NOT the `type` discriminator"),
+	value: scalar,
+	category: z.string().optional(),
+	subValues: z.array(z.object({
+		when: z.unknown(),
+		value: scalar
+	})).optional()
+}).describe("Create or update a space-level schema variable (a {{name}} value shared across the space).");
+var upsertVariable = (space, env, op) => {
+	const variable = {
+		name: op.name,
+		category: op.category ?? "general",
+		type: op.variableType,
+		value: op.value,
+		subValues: op.subValues ?? []
+	};
+	const idx = space.schema.variables.findIndex((v) => v.name === op.name);
+	if (idx >= 0) {
+		space.schema.variables[idx] = variable;
+		return {
+			...empty(),
+			updated: 1,
+			staleResources: [schemaVarsUri(env)]
+		};
+	}
+	space.schema.variables.push(variable);
+	return {
+		...empty(),
+		created: 1,
+		staleResources: [schemaVarsUri(env)]
+	};
+};
+//#endregion
+export { upsertVariable, upsertVariableOp };

package/dist/modules/mcp/tools/operations/schema/write.js

@@ -0,0 +1,44 @@
+import { generateObjectId } from "../../../helpers/space.js";
+//#region src/modules/mcp/tools/operations/schema/write.ts
+var pageUri = (env, ref) => `plitzi://schema/${env}/pages/${ref}`;
+var pagesUri = (env) => `plitzi://schema/${env}/pages`;
+var foldersUri = (env) => `plitzi://folders/${env}`;
+var folderUri = (env, ref) => `plitzi://folders/${env}/${ref}`;
+var schemaVarsUri = (env) => `plitzi://schema-variables/${env}`;
+var removeFromParent = (space, childId) => {
+	for (const el of Object.values(space.schema.flat)) if (el.definition.items?.includes(childId)) el.definition.items = el.definition.items.filter((id) => id !== childId);
+};
+var placeChild = (parent, childId, index) => {
+	const items = parent.definition.items ?? (parent.definition.items = []);
+	if (index === void 0 || index < 0 || index >= items.length) items.push(childId);
+	else items.splice(index, 0, childId);
+};
+var createElement = (space, page, input, parent, index) => {
+	const id = generateObjectId();
+	const { subType, ...props } = {
+		subType: input.subType,
+		...input.props
+	};
+	const styleSelectors = { base: (input.style?.base ?? []).join(" ") };
+	for (const [slot, classes] of Object.entries(input.style?.slots ?? {})) styleSelectors[slot] = classes.join(" ");
+	space.schema.flat[id] = {
+		id,
+		attributes: subType === void 0 ? props : {
+			subType,
+			...props
+		},
+		definition: {
+			rootId: page.id,
+			parentId: parent.id,
+			label: input.label ?? input.ref,
+			type: input.type,
+			items: [],
+			styleSelectors,
+			aiRef: input.ref
+		}
+	};
+	placeChild(parent, id, index);
+	for (const child of input.children ?? []) createElement(space, page, child, space.schema.flat[id], void 0);
+};
+//#endregion
+export { createElement, folderUri, foldersUri, pageUri, pagesUri, placeChild, removeFromParent, schemaVarsUri };

package/dist/modules/mcp/tools/operations/style/cssCatalog.js

@@ -0,0 +1,132 @@
+import styleConstants from "@plitzi/sdk-shared/style/styleConstants";
+//#region src/modules/mcp/tools/operations/style/cssCatalog.ts
+/** Every kebab-case CSS property Plitzi's style engine understands. Values written to a definition
+*  must use these exact keys — camelCase or unknown keys are rejected by the validator. */
+var cssProperties = Array.from(new Set(Object.values(styleConstants))).sort();
+var cssPropertySet = new Set(cssProperties);
+var isCssProperty = (key) => cssPropertySet.has(key);
+var toKebab = (key) => key.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+/** If a camelCase key maps to a known kebab-case property, return it — used to teach the agent the correct key. */
+var suggestCssProperty = (key) => {
+	const kebab = toKebab(key);
+	return cssPropertySet.has(kebab) ? kebab : void 0;
+};
+var splitTokens = (value) => {
+	const tokens = [];
+	let depth = 0;
+	let current = "";
+	for (const ch of value.trim()) {
+		if (ch === "(") depth += 1;
+		else if (ch === ")") depth = Math.max(0, depth - 1);
+		if (/\s/.test(ch) && depth === 0) {
+			if (current) {
+				tokens.push(current);
+				current = "";
+			}
+		} else current += ch;
+	}
+	if (current) tokens.push(current);
+	return tokens;
+};
+var SIDES = [
+	"top",
+	"right",
+	"bottom",
+	"left"
+];
+var box4 = (tokens) => {
+	const [a, b = a, c = a, d = b] = tokens;
+	return [
+		a,
+		b,
+		c,
+		d
+	];
+};
+var radius4 = (tokens) => {
+	const [a, b = a, c = a, d = b] = tokens;
+	return [
+		a,
+		b,
+		c,
+		d
+	];
+};
+var BORDER_STYLES = /* @__PURE__ */ new Set([
+	"none",
+	"hidden",
+	"dotted",
+	"dashed",
+	"solid",
+	"double",
+	"groove",
+	"ridge",
+	"inset",
+	"outset"
+]);
+var BORDER_WIDTH_KEYWORDS = /* @__PURE__ */ new Set([
+	"thin",
+	"medium",
+	"thick"
+]);
+var LENGTH_RE = /^-?[\d.]+([a-z%]*)$/;
+var classifyBorderToken = (token) => {
+	if (BORDER_STYLES.has(token)) return "style";
+	if (BORDER_WIDTH_KEYWORDS.has(token) || LENGTH_RE.test(token)) return "width";
+	return "color";
+};
+var expandBorder = (key, value, out) => {
+	const sides = key === "border" ? SIDES : [key.slice(7)];
+	for (const token of splitTokens(value)) {
+		const kind = classifyBorderToken(token);
+		for (const side of sides) out[`border-${side}-${kind}`] = token;
+	}
+};
+var BORDER_SIDE_KEYS = new Set(SIDES.map((s) => `border-${s}`));
+var expandOne = (key, raw, out) => {
+	const value = String(raw);
+	if (key === "padding" || key === "margin" || key === "inset") {
+		const [t, r, b, l] = box4(splitTokens(value));
+		const prefix = key === "inset" ? "" : `${key}-`;
+		out[`${prefix}top`] = t;
+		out[`${prefix}right`] = r;
+		out[`${prefix}bottom`] = b;
+		out[`${prefix}left`] = l;
+		return true;
+	}
+	if (key === "border-radius" && !value.includes("/")) {
+		const [tl, tr, br, bl] = radius4(splitTokens(value));
+		const corners = [
+			["top-left", tl],
+			["top-right", tr],
+			["bottom-right", br],
+			["bottom-left", bl]
+		];
+		for (const [corner, v] of corners) out[`border-${corner}-radius`] = v;
+		return true;
+	}
+	if (key === "gap") {
+		const [row, col = row] = splitTokens(value);
+		out["row-gap"] = row;
+		out["column-gap"] = col;
+		return true;
+	}
+	if (key === "border" || BORDER_SIDE_KEYS.has(key)) {
+		expandBorder(key, value, out);
+		return true;
+	}
+	return false;
+};
+/** Expand supported CSS shorthands to their longhand keys. Explicit longhands in the same map win over any
+*  expansion (so `{ padding: 8, padding-left: 0 }` keeps padding-left: 0). Unrecognized keys pass through. */
+var expandShorthand = (css) => {
+	const expanded = {};
+	const direct = {};
+	for (const [key, value] of Object.entries(css)) if (!expandOne(key, value, expanded)) direct[key] = value;
+	return {
+		...expanded,
+		...direct
+	};
+};
+//#endregion
+export { cssProperties, expandShorthand, isCssProperty, suggestCssProperty };

package/dist/modules/mcp/tools/operations/style/deleteDefinition.js

@@ -0,0 +1,20 @@
+import { empty } from "../../../helpers/opResult.js";
+import { MODES, defUri, defsUri, guardKind } from "./write.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/style/deleteDefinition.ts
+var deleteDefinitionOp = z.object({
+	type: z.literal("deleteDefinition"),
+	ref: z.string().describe("Class ref of the definition to delete")
+}).describe("Delete a style class definition by ref (does not detach it from elements that still list it).");
+var deleteDefinition = (space, env, op) => {
+	const guard = guardKind(space.style, op.ref, "class");
+	if (guard) return guard;
+	for (const mode of MODES) Reflect.deleteProperty(space.style.platform[mode], op.ref);
+	return {
+		...empty(),
+		deleted: 1,
+		staleResources: [defUri(env, op.ref), defsUri(env)]
+	};
+};
+//#endregion
+export { deleteDefinition, deleteDefinitionOp };

package/dist/modules/mcp/tools/operations/style/deleteGlobalStyle.js

@@ -0,0 +1,20 @@
+import { empty } from "../../../helpers/opResult.js";
+import { MODES, globalUri, globalsUri, guardKind } from "./write.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/style/deleteGlobalStyle.ts
+var deleteGlobalStyleOp = z.object({
+	type: z.literal("deleteGlobalStyle"),
+	componentType: z.string().describe("Element type whose site-wide style to remove")
+}).describe("Remove the site-wide style for an element type (elements of that type keep their own classes).");
+var deleteGlobalStyle = (space, env, op) => {
+	const guard = guardKind(space.style, op.componentType, "element");
+	if (guard) return guard;
+	for (const mode of MODES) Reflect.deleteProperty(space.style.platform[mode], op.componentType);
+	return {
+		...empty(),
+		deleted: 1,
+		staleResources: [globalUri(env, op.componentType), globalsUri(env)]
+	};
+};
+//#endregion
+export { deleteGlobalStyle, deleteGlobalStyleOp };

package/dist/modules/mcp/tools/operations/style/deleteStyleVariable.js

@@ -0,0 +1,21 @@
+import { empty } from "../../../helpers/opResult.js";
+import { styleVarUri, styleVarsUri } from "./write.js";
+import { styleCategory } from "./shared.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/style/deleteStyleVariable.ts
+var deleteStyleVariableOp = z.object({
+	type: z.literal("deleteStyleVariable"),
+	category: styleCategory,
+	name: z.string().describe("Token name without the -- prefix")
+}).describe("Delete a design token by category + name.");
+var deleteStyleVariable = (space, env, op) => {
+	const group = space.style.variables[op.category];
+	if (group) Reflect.deleteProperty(group, op.name);
+	return {
+		...empty(),
+		deleted: 1,
+		staleResources: [styleVarUri(env, op.category), styleVarsUri(env)]
+	};
+};
+//#endregion
+export { deleteStyleVariable, deleteStyleVariableOp };

package/dist/modules/mcp/tools/operations/style/operations.js

@@ -0,0 +1,21 @@
+import { deleteDefinitionOp } from "./deleteDefinition.js";
+import { deleteGlobalStyleOp } from "./deleteGlobalStyle.js";
+import { deleteStyleVariableOp } from "./deleteStyleVariable.js";
+import { patchDefinitionOp } from "./patchDefinition.js";
+import { patchGlobalStyleOp } from "./patchGlobalStyle.js";
+import { upsertDefinitionOp } from "./upsertDefinition.js";
+import { upsertGlobalStyleOp } from "./upsertGlobalStyle.js";
+import { upsertStyleVariableOp } from "./upsertStyleVariable.js";
+//#region src/modules/mcp/tools/operations/style/operations.ts
+var styleOps = {
+	upsertDefinition: upsertDefinitionOp,
+	patchDefinition: patchDefinitionOp,
+	deleteDefinition: deleteDefinitionOp,
+	upsertGlobalStyle: upsertGlobalStyleOp,
+	patchGlobalStyle: patchGlobalStyleOp,
+	deleteGlobalStyle: deleteGlobalStyleOp,
+	upsertStyleVariable: upsertStyleVariableOp,
+	deleteStyleVariable: deleteStyleVariableOp
+};
+//#endregion
+export { styleOps };

package/dist/modules/mcp/tools/operations/style/patchDefinition.js

@@ -0,0 +1,27 @@
+import { empty, fail } from "../../../helpers/opResult.js";
+import { definitionToAI } from "./translator.js";
+import { defUri, defsUri, guardKind, mergePatch, writeStyleItem } from "./write.js";
+import { patchCssShape } from "./shared.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/style/patchDefinition.ts
+var patchDefinitionOp = z.object({
+	type: z.literal("patchDefinition"),
+	ref: z.string().describe("Existing class ref to patch"),
+	...patchCssShape
+}).describe("Partially update an existing style class: the CSS you pass is merged (a null value removes that property, others are kept). Never creates — use upsertDefinition for that.");
+var patchDefinition = (space, env, op) => {
+	const guard = guardKind(space.style, op.ref, "class");
+	if (guard) return guard;
+	const existing = definitionToAI(space.style, op.ref);
+	if (!existing) return fail("ref", `Definition "${op.ref}" not found`, "patchDefinition only updates an existing definition; use upsertDefinition to create one");
+	const { type, ref, slots: slotsPatch, ...basePatch } = op;
+	const { base, slots } = mergePatch(existing, basePatch, slotsPatch);
+	writeStyleItem(space.style, ref, base, slots, "class", void 0);
+	return {
+		...empty(),
+		updated: 1,
+		staleResources: [defUri(env, ref), defsUri(env)]
+	};
+};
+//#endregion
+export { patchDefinition, patchDefinitionOp };

package/dist/modules/mcp/tools/operations/style/patchGlobalStyle.js

@@ -0,0 +1,27 @@
+import { empty, fail } from "../../../helpers/opResult.js";
+import { globalStyleToAI } from "./translator.js";
+import { globalUri, globalsUri, guardKind, mergePatch, writeStyleItem } from "./write.js";
+import { patchCssShape } from "./shared.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/style/patchGlobalStyle.ts
+var patchGlobalStyleOp = z.object({
+	type: z.literal("patchGlobalStyle"),
+	componentType: z.string().describe("Element type whose global style to merge into; affects ALL of that type"),
+	...patchCssShape
+}).describe("Partially update the site-wide style for an element type: CSS is merged (a null value removes a property). Never creates — use upsertGlobalStyle for that.");
+var patchGlobalStyle = (space, env, op) => {
+	const guard = guardKind(space.style, op.componentType, "element");
+	if (guard) return guard;
+	const existing = globalStyleToAI(space.style, op.componentType);
+	if (!existing) return fail("componentType", `No global style for "${op.componentType}"`, "patchGlobalStyle only updates an existing global; use upsertGlobalStyle to create one");
+	const { type, componentType, slots: slotsPatch, ...basePatch } = op;
+	const { base, slots } = mergePatch(existing, basePatch, slotsPatch);
+	writeStyleItem(space.style, componentType, base, slots, "element", componentType);
+	return {
+		...empty(),
+		updated: 1,
+		staleResources: [globalUri(env, componentType), globalsUri(env)]
+	};
+};
+//#endregion
+export { patchGlobalStyle, patchGlobalStyleOp };

package/dist/modules/mcp/tools/operations/style/shared.js

@@ -0,0 +1,59 @@
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/style/shared.ts
+var cssMap = z.record(z.string(), z.union([z.string(), z.number()])).describe("kebab-case CSS props; use var(--name) for tokens and {{name}} for schema vars");
+var displayModeCss = z.object({
+	desktop: cssMap.optional(),
+	tablet: cssMap.optional(),
+	mobile: cssMap.optional()
+});
+var definitionSlot = displayModeCss.extend({
+	states: z.record(z.string(), displayModeCss).optional(),
+	variants: z.record(z.string(), displayModeCss).optional()
+});
+var cssPatchMap = z.record(z.string(), z.union([
+	z.string(),
+	z.number(),
+	z.null()
+])).describe("kebab-case CSS props; a value of null removes the property, others are merged onto the existing CSS");
+var displayModeCssPatch = z.object({
+	desktop: cssPatchMap.optional(),
+	tablet: cssPatchMap.optional(),
+	mobile: cssPatchMap.optional()
+});
+var definitionSlotPatch = displayModeCssPatch.extend({
+	states: z.record(z.string(), displayModeCssPatch).optional(),
+	variants: z.record(z.string(), displayModeCssPatch).optional()
+});
+var styleCategory = z.enum([
+	"color",
+	"spacing",
+	"shadow",
+	"custom"
+]);
+var themeValue = z.union([
+	z.string(),
+	z.number(),
+	z.object({
+		light: z.string().optional(),
+		dark: z.string().optional(),
+		default: z.string().optional()
+	})
+]);
+var upsertCssShape = {
+	desktop: cssMap.optional(),
+	tablet: cssMap.optional(),
+	mobile: cssMap.optional(),
+	states: z.record(z.string(), displayModeCss).optional(),
+	variants: z.record(z.string(), displayModeCss).optional(),
+	slots: z.record(z.string(), definitionSlot).optional()
+};
+var patchCssShape = {
+	desktop: cssPatchMap.optional(),
+	tablet: cssPatchMap.optional(),
+	mobile: cssPatchMap.optional(),
+	states: z.record(z.string(), displayModeCssPatch).optional(),
+	variants: z.record(z.string(), displayModeCssPatch).optional(),
+	slots: z.record(z.string(), definitionSlotPatch).optional()
+};
+//#endregion
+export { displayModeCss, displayModeCssPatch, patchCssShape, styleCategory, themeValue, upsertCssShape };

package/dist/modules/mcp/tools/operations/style/translator.js

@@ -0,0 +1,77 @@
+//#region src/modules/mcp/tools/operations/style/translator.ts
+var DISPLAY_MODES = [
+	"desktop",
+	"tablet",
+	"mobile"
+];
+var isClassDefinition = (item) => item.type === "class";
+var definitionRefs = (style) => {
+	const refs = /* @__PURE__ */ new Set();
+	for (const mode of DISPLAY_MODES) for (const [name, item] of Object.entries(style.platform[mode])) if (isClassDefinition(item)) refs.add(name);
+	return Array.from(refs).sort();
+};
+var fillSlot = (target, mode, block) => {
+	if (block.default && Object.keys(block.default).length > 0) target[mode] = block.default;
+	if (block.states) {
+		for (const [state, obj] of Object.entries(block.states)) if (Object.keys(obj).length > 0) {
+			(target.states ??= {})[state] ??= {};
+			target.states[state][mode] = obj;
+		}
+	}
+	if (block.variants) {
+		for (const [name, variant] of Object.entries(block.variants)) if (variant.default && Object.keys(variant.default).length > 0) {
+			(target.variants ??= {})[name] ??= {};
+			target.variants[name][mode] = variant.default;
+		}
+	}
+};
+var projectItem = (style, ref, accept) => {
+	const def = { ref };
+	let found = false;
+	for (const mode of DISPLAY_MODES) {
+		const item = style.platform[mode][ref];
+		if (!item || !accept(item)) continue;
+		found = true;
+		for (const [slot, block] of Object.entries(item.attributes)) if (slot === "base") fillSlot(def, mode, block);
+		else fillSlot((def.slots ??= {})[slot] ??= {}, mode, block);
+	}
+	return found ? def : void 0;
+};
+var definitionToAI = (style, ref) => projectItem(style, ref, isClassDefinition);
+var globalStylesForType = (style, componentType) => {
+	const isGlobal = (item) => item.type === "element" && item.componentType === componentType;
+	const refs = /* @__PURE__ */ new Set();
+	for (const mode of DISPLAY_MODES) for (const [name, item] of Object.entries(style.platform[mode])) if (isGlobal(item)) refs.add(name);
+	const globals = [];
+	for (const ref of Array.from(refs).sort()) {
+		const def = projectItem(style, ref, isGlobal);
+		if (def) globals.push({
+			...def,
+			appliesToType: componentType
+		});
+	}
+	return globals;
+};
+var globalStyleToAI = (style, componentType) => {
+	const def = projectItem(style, componentType, (item) => item.type === "element" && item.componentType === componentType);
+	return def ? {
+		...def,
+		appliesToType: componentType
+	} : void 0;
+};
+var globalStyleTypes = (style) => {
+	const types = /* @__PURE__ */ new Set();
+	for (const mode of DISPLAY_MODES) for (const item of Object.values(style.platform[mode])) if (item.type === "element" && item.componentType) types.add(item.componentType);
+	return Array.from(types).sort();
+};
+var styleVariablesToAI = (style) => {
+	const data = {};
+	for (const [category, group] of Object.entries(style.variables)) data[category] = Object.entries(group).map(([name, value]) => ({
+		name,
+		reference: `var(--${name})`,
+		value
+	}));
+	return data;
+};
+//#endregion
+export { definitionRefs, definitionToAI, globalStyleToAI, globalStyleTypes, globalStylesForType, isClassDefinition, styleVariablesToAI };