@plitzi/sdk-server 0.30.19 → 0.31.0

package/dist/modules/mcp/resources/glossary/styleSelector.js

@@ -0,0 +1,77 @@
+//#region src/modules/mcp/resources/glossary/styleSelector.ts
+var styleSelectorResource = {
+	uri: "plitzi://docs/style-selector",
+	name: "Plitzi Docs: Style Selector",
+	description: "A CSS selector entry in the Plitzi style system — holds all visual rules for one selector across states and variants.",
+	mimeType: "text/markdown",
+	content: `# Style Selector (StyleItem)
+
+A **style selector** is a single entry in \`style.platform[displayMode]\`. It represents one CSS selector (class, element, or ID) and stores all its CSS rules organized by sub-selector, state, and variant.
+
+## TypeScript Shape
+
+\`\`\`typescript
+type StyleItem = {
+  name: string;                        // The CSS selector (e.g. '.hero-section')
+  type: 'class' | 'element' | 'id';
+  variables?: Partial<StyleVariables>; // Design tokens scoped to this selector
+  attributes: Record<string, StyleBlock>;  // CSS per sub-selector slot
+  cache: string;                       // Pre-compiled CSS (auto-managed)
+  componentType?: string;              // Plugin type that created this selector
+};
+
+type StyleBlock = {
+  default?: StyleObject;                            // Normal state CSS
+  states?: Partial<Record<StyleState, StyleObject>>;// Pseudo-class overrides
+  variants?: Record<string, Omit<StyleBlock, 'variants'>>;  // Named variants
+};
+
+type StyleState = 'hover' | 'active' | 'focus' | 'disabled' | 'checked' | 'visited';
+type StyleObject = Partial<Record<StyleCategory, string | number>>;
+\`\`\`
+
+## Sub-selector Slots
+
+The \`attributes\` object is keyed by **slot names**, not raw CSS selectors. Each slot maps to a structural part of the component:
+
+- \`base\` — always present; targets the root DOM element of the component.
+- Other slots (e.g. \`header\`, \`body\`, \`icon\`, \`label\`) target internal parts defined by the plugin.
+
+The mapping from slot name → CSS selector is managed by the plugin renderer.
+
+## Variants
+
+Variants allow a single selector to have multiple named visual appearances (e.g. \`primary\`, \`danger\`, \`sm\`, \`lg\`). An element activates a variant through \`definition.initialState.styleVariant\`:
+
+\`\`\`typescript
+// element.definition.initialState.styleVariant
+{
+  base: { base: 'primary' }        // Apply 'primary' variant on the 'base' slot
+}
+\`\`\`
+
+## Relationship to Elements
+
+Elements reference style selectors via \`definition.styleSelectors\`:
+
+\`\`\`typescript
+// element.definition.styleSelectors
+{
+  base: '.hero-section',    // Points to style.platform.desktop['.hero-section']
+  title: '.hero-title'      // Points to style.platform.desktop['.hero-title']
+}
+\`\`\`
+
+## Display Modes
+
+A style selector can exist in multiple display modes (\`desktop\`, \`tablet\`, \`mobile\`). Rules in \`tablet\` and \`mobile\` override the desktop base at their respective breakpoints.
+
+## Common Operations
+
+- \`create_style_selector\` — add a new StyleItem to a display mode.
+- \`update_style_selector\` — modify \`attributes\` for an existing selector.
+- \`delete_style_selector\` — remove a selector from a display mode.
+`
+};
+//#endregion
+export { styleSelectorResource };

package/dist/modules/mcp/resources/glossary/styleVariable.js

@@ -0,0 +1,72 @@
+//#region src/modules/mcp/resources/glossary/styleVariable.ts
+var styleVariableResource = {
+	uri: "plitzi://docs/style-variable",
+	name: "Plitzi Docs: Style Variable",
+	description: "Design tokens in the Plitzi style system — reusable values for colors, spacing, shadows, and custom properties.",
+	mimeType: "text/markdown",
+	content: `# Style Variable
+
+**Style variables** are design tokens stored in the \`Style\` object. They define reusable values (colors, spacing units, shadows, custom properties) that can be referenced across all CSS rules in the space.
+
+## TypeScript Shape
+
+\`\`\`typescript
+enum StyleVariableCategory {
+  COLOR = 'color',
+  SPACING = 'spacing',
+  SHADOW = 'shadow',
+  CUSTOM = 'custom'
+}
+
+type StyleVariables = Record<StyleVariableCategory, StyleVariableGroup>;
+type StyleVariableGroup = Record<string, StyleVariableValue>;
+
+// Value can be a plain string/number or theme-aware (different per light/dark)
+type StyleVariableValue =
+  | string
+  | number
+  | {
+      light?: string;
+      dark?: string;
+      default?: string;
+    };
+\`\`\`
+
+## Categories
+
+- **\`color\`** — color tokens (e.g. \`primary\`, \`background\`, \`text-muted\`). Values can be theme-aware (different for light vs. dark).
+- **\`spacing\`** — spacing units (e.g. \`sm\`, \`md\`, \`lg\`). Plain numbers or CSS values.
+- **\`shadow\`** — box-shadow definitions (e.g. \`card\`, \`modal\`).
+- **\`custom\`** — any other token (border radius, font size, z-index, etc.).
+
+## Theme-Aware Values
+
+When a design system supports multiple themes, a variable value can vary:
+
+\`\`\`typescript
+{ light: '#ffffff', dark: '#1a1a1a', default: '#ffffff' }
+\`\`\`
+
+The \`default\` key is used when no theme preference is detected.
+
+## Scope
+
+Variables can be scoped at two levels:
+
+1. **Style-level** (\`style.variables\`) — global tokens available everywhere in the space.
+2. **Selector-level** (\`styleItem.variables\`) — tokens scoped to one CSS selector (override global for that component).
+
+## Common Operations
+
+- \`create_style_variable\` — add a new token with a category and name.
+- \`update_style_variable\` — change a token's value.
+- \`delete_style_variable\` — remove a token.
+
+## Relationships
+
+- Referenced by **Style Selectors** via CSS variable syntax or direct value interpolation.
+- **Schema Variables** are different — they are schema-level data variables, not CSS design tokens.
+`
+};
+//#endregion
+export { styleVariableResource };

package/dist/modules/mcp/resources/index.js

@@ -0,0 +1,71 @@
+import { bindingResource } from "./glossary/binding.js";
+import { collectionResource } from "./glossary/collection.js";
+import { displayModeResource } from "./glossary/displayMode.js";
+import { elementResource } from "./glossary/element.js";
+import { environmentResource } from "./glossary/environment.js";
+import { interactionResource } from "./glossary/interaction.js";
+import { pageResource } from "./glossary/page.js";
+import { pluginResource } from "./glossary/plugin.js";
+import { resourceResource } from "./glossary/resource.js";
+import { schemaResource } from "./glossary/schema.js";
+import { schemaVariableResource } from "./glossary/schemaVariable.js";
+import { segmentResource } from "./glossary/segment.js";
+import { spaceResource } from "./glossary/space.js";
+import { styleResource } from "./glossary/style.js";
+import { styleSelectorResource } from "./glossary/styleSelector.js";
+import { styleVariableResource } from "./glossary/styleVariable.js";
+import { workflowDataResource } from "./workflows/data.js";
+import { workflowElementsResource } from "./workflows/elements.js";
+import { workflowSegmentsResource } from "./workflows/segments.js";
+import { workflowStylesResource } from "./workflows/styles.js";
+//#region src/modules/mcp/resources/index.ts
+var glossaryResources = [
+	schemaResource,
+	elementResource,
+	pageResource,
+	styleResource,
+	styleSelectorResource,
+	styleVariableResource,
+	segmentResource,
+	pluginResource,
+	collectionResource,
+	spaceResource,
+	environmentResource,
+	schemaVariableResource,
+	resourceResource,
+	bindingResource,
+	interactionResource,
+	displayModeResource
+];
+var workflowResources = [
+	workflowElementsResource,
+	workflowStylesResource,
+	workflowSegmentsResource,
+	workflowDataResource
+];
+var registerResources = (server, custom = [], onRead) => {
+	for (const r of [
+		...glossaryResources,
+		...workflowResources,
+		...custom
+	]) server.registerResource(r.name, r.uri, {
+		description: r.description,
+		mimeType: r.mimeType
+	}, () => {
+		onRead?.(r.name, r.uri);
+		return { contents: [{
+			uri: r.uri,
+			mimeType: r.mimeType,
+			text: r.content
+		}] };
+	});
+};
+var allResources = [...glossaryResources, ...workflowResources];
+var getResourceList = () => allResources.map(({ uri, name, description }) => ({
+	uri,
+	name,
+	description
+}));
+var getResourceByUri = (uri) => allResources.find((r) => r.uri === uri);
+//#endregion
+export { getResourceByUri, getResourceList, registerResources };

package/dist/modules/mcp/resources/workflows/data.js

@@ -0,0 +1,49 @@
+//#region src/modules/mcp/resources/workflows/data.ts
+var workflowDataResource = {
+	uri: "plitzi://workflows/data",
+	name: "Plitzi Workflow: Data",
+	description: "Step-by-step guide for schema variables, collection records, and data bindings.",
+	mimeType: "text/markdown",
+	content: `# Workflow: Data — Variables, Collections, Bindings
+
+## Schema variables (space-level named values)
+
+Variables are typed, named values that elements can bind to.
+
+1. Create a variable with \`create_variable\`:
+   \`\`\`json
+   { "variable": { "name": "heroTitle", "type": "text", "value": "Welcome", "category": "Content" } }
+   \`\`\`
+2. Update it with \`update_variable\` (identified by name).
+3. Delete with \`delete_variable\` — any element bindings referencing it will break.
+
+## Collection records (CMS data)
+
+1. List collections: \`get_collections\` → pick the target \`id\`.
+2. Inspect the collection's field definitions: \`get_collection\` → \`fields\`.
+3. Create a record with \`create_collection_record\`:
+   \`\`\`json
+   { "collectionId": "<id>", "values": { "title": "My Product", "price": 99 }, "status": "published" }
+   \`\`\`
+4. Update a record with \`update_collection_record\` (by \`recordId\`).
+5. List records with \`get_collection_records\` — supports optional \`filter\` and \`limit\`.
+
+## Bindings (connecting data to elements)
+
+A binding maps a data source (variable or collection field) to an element's attribute or style at runtime.
+Read \`plitzi://docs/binding\` for the full binding structure before working with bindings.
+
+General flow:
+1. Ensure the variable or collection exists.
+2. Get the target element via \`get_element\` to inspect its current \`definition.bindings\`.
+3. Use \`update_element\` with the updated \`props\` that include the binding reference.
+
+## Reading the current state
+
+- \`get_schema\` → \`variables\` — all space-level variables with types and values.
+- \`get_collections\` — all collections in the space.
+- \`get_collection_records\` — records from a specific collection.
+`
+};
+//#endregion
+export { workflowDataResource };

package/dist/modules/mcp/resources/workflows/elements.js

@@ -0,0 +1,53 @@
+//#region src/modules/mcp/resources/workflows/elements.ts
+var workflowElementsResource = {
+	uri: "plitzi://workflows/elements",
+	name: "Plitzi Workflow: Elements",
+	description: "Step-by-step guide for adding, nesting, moving, and removing elements on a page.",
+	mimeType: "text/markdown",
+	content: `# Workflow: Working with Elements
+
+## Add an element to a page
+
+1. Get the target page ID:
+   - \`get_builder_context\` → \`currentPageId\` (active page in the builder), OR
+   - \`get_schema\` → \`pages[]\` (all page IDs)
+2. Get valid element types: \`get_builder_context\` → \`elementDefaults\` keys.
+3. Call \`create_element\`:
+   \`\`\`json
+   { "element": { "type": "container", "label": "Hero" }, "parentId": "<pageId>" }
+   \`\`\`
+4. The response contains the created element with \`definition.styleSelectors\` (e.g. \`{ "base": ".el-abc123" }\`).
+5. Use those selectors to style the element → see **plitzi://workflows/styles**.
+
+## Nest elements (container → children)
+
+Repeat \`create_element\` using the container's \`id\` as \`parentId\`:
+\`\`\`json
+{ "element": { "type": "text", "label": "Heading" }, "parentId": "<containerId>" }
+\`\`\`
+
+## Read the current element tree
+
+- \`get_schema\` → \`flat\` — full map of all elements keyed by ID, with \`definition.parentId\` and \`definition.items\`.
+- \`list_elements\` — lighter; returns id, label, type, parentId for every element.
+- \`get_element\` — full detail for a single element (attributes, bindings, interactions).
+
+## Move an element
+
+\`move_element\` with \`elementId\`, \`toParentId\`, and \`dropPosition\`:
+- \`"inside"\` — appends as last child of the target (default).
+- \`"top"\` / \`"bottom"\` — inserts before/after the target's siblings.
+
+## Update an element
+
+\`update_element\` — change \`label\`, \`props\` (component attributes), or \`runtime\`.
+For style changes use \`update_style_selector\`, not \`props\`.
+
+## Delete an element
+
+\`delete_element\` removes the element and all its descendants. This cannot be undone.
+Always confirm with the user before calling this.
+`
+};
+//#endregion
+export { workflowElementsResource };

package/dist/modules/mcp/resources/workflows/segments.js

@@ -0,0 +1,55 @@
+//#region src/modules/mcp/resources/workflows/segments.ts
+var workflowSegmentsResource = {
+	uri: "plitzi://workflows/segments",
+	name: "Plitzi Workflow: Segments",
+	description: "Step-by-step guide for creating and populating reusable segment templates.",
+	mimeType: "text/markdown",
+	content: `# Workflow: Working with Segments
+
+A segment is a reusable UI template with its own isolated schema and style.
+It is NOT placed on a page directly — it is defined once and referenced by elements across the space.
+
+## Create a segment and populate it
+
+1. Call \`create_segment\`:
+   \`\`\`json
+   { "name": "Product Card", "description": "Reusable card for product listings" }
+   \`\`\`
+   The response contains:
+   - \`id\` — segment ID (used by all subsequent segment calls)
+   - \`definition.baseElementId\` — the root element ID inside the segment
+
+2. Add elements to the segment root using \`create_segment_element\`:
+   \`\`\`json
+   { "segmentId": "<id>", "element": { "type": "container", "label": "Card" }, "parentId": "<baseElementId>" }
+   \`\`\`
+
+3. Nest elements inside by using the returned element \`id\` as the next \`parentId\`:
+   \`\`\`json
+   { "segmentId": "<id>", "element": { "type": "text", "label": "Title" }, "parentId": "<cardId>" }
+   \`\`\`
+
+4. Style segment elements the same way as page elements:
+   - Get the element's \`definition.styleSelectors\` from the \`create_segment_element\` response.
+   - Call \`update_style_selector\` with the selector and CSS rules.
+
+5. For segment-scoped design tokens (not shared with the space), use \`create_segment_style_variable\`.
+
+## Update segment metadata
+
+\`update_segment\` — rename the segment or update its description.
+
+## Delete a segment
+
+\`delete_segment\` removes the segment, its entire schema, and its style. Cannot be undone.
+Always confirm with the user before calling this.
+
+## Segment variables
+
+Segments can have their own typed variables (scoped to the segment):
+- \`create_segment_variable\` — add a variable to the segment.
+- \`update_segment_variable\` / \`delete_segment_variable\` — manage existing ones.
+`
+};
+//#endregion
+export { workflowSegmentsResource };

package/dist/modules/mcp/resources/workflows/styles.js

@@ -0,0 +1,91 @@
+//#region src/modules/mcp/resources/workflows/styles.ts
+var workflowStylesResource = {
+	uri: "plitzi://workflows/styles",
+	name: "Plitzi Workflow: Styles",
+	description: "Step-by-step guide for styling elements, using design tokens, and working across breakpoints.",
+	mimeType: "text/markdown",
+	content: `# Workflow: Styling Elements
+
+## Style an element after creating it
+
+Every element has a \`definition.styleSelectors\` map (e.g. \`{ "base": ".el-abc123", "icon": ".el-abc123-icon" }\`).
+These are the CSS class strings registered in the space style system.
+
+1. Get the element's \`styleSelectors\` — from the \`create_element\` / \`get_element\` response.
+2. Call \`update_style_selector\`:
+   \`\`\`json
+   {
+     "displayMode": "desktop",
+     "selector": ".el-abc123",
+     "type": "class",
+     "style": { "base": { "backgroundColor": "#3b82f6", "padding": "16px" } }
+   }
+   \`\`\`
+3. To style other breakpoints, repeat with \`"displayMode": "tablet"\` or \`"mobile"\`.
+4. To style sub-slots (e.g. icon, header, body): use the corresponding selector from \`styleSelectors\` and the slot name as the style key.
+
+## Update a specific CSS property (path parameter)
+
+The \`path\` parameter in \`update_style_selector\` controls the scope of the update:
+
+| path | style value | result |
+|------|------------|--------|
+| omitted | \`{ base: { color: "#fff" } }\` | Replaces **all** attributes of the selector |
+| \`"base.color"\` | \`"#fff"\` | Updates only \`color\` inside the \`base\` slot |
+| \`"base.color"\` | \`undefined\` / omitted | **Deletes** the \`color\` property from \`base\` |
+| omitted | \`undefined\` / omitted | **Clears** all attributes from the selector |
+
+Example — update only the background color without touching other properties:
+\`\`\`json
+{
+  "displayMode": "desktop",
+  "selector": ".el-abc123",
+  "type": "class",
+  "path": "base.backgroundColor",
+  "style": { "base": { "backgroundColor": "#ef4444" } }
+}
+\`\`\`
+
+## Create a new selector from scratch
+
+Use \`create_style_selector\` when you need a CSS class that isn't tied to a specific element (shared utility class):
+\`\`\`json
+{
+  "displayMode": "desktop",
+  "selector": ".hero-banner",
+  "type": "class",
+  "style": { "base": { "minHeight": "400px" } }
+}
+\`\`\`
+
+## Use design tokens (CSS variables)
+
+Tokens let you reuse values across many selectors.
+
+1. Create a token with \`create_style_variable\`:
+   \`\`\`json
+   { "category": "color", "name": "brand", "value": { "light": "#3b82f6", "dark": "#60a5fa", "default": "#3b82f6" } }
+   \`\`\`
+2. Reference the token by name in any style rule:
+   \`\`\`json
+   { "base": { "color": "var(--plitzi-brand)" } }
+   \`\`\`
+
+## Responsive styles
+
+Apply the same selector at different display modes to override values:
+1. Desktop (default): \`update_style_selector\` with \`"displayMode": "desktop"\`.
+2. Tablet overrides: \`update_style_selector\` with \`"displayMode": "tablet"\`.
+3. Mobile overrides: \`update_style_selector\` with \`"displayMode": "mobile"\`.
+
+Only the overriding properties need to be included in each breakpoint call.
+
+## Preview and inspect current styles
+
+- To see how a saved element currently looks: use \`preview_element\` — it returns its schema+style for display.
+- The \`style.platform\` in the response is keyed by displayMode, then by selector, and shows the actual CSS rules applied.
+- \`get_schema\` does not include style data — use \`preview_element\` to read an element's live styles.
+`
+};
+//#endregion
+export { workflowStylesResource };

package/dist/modules/mcp/server.js

@@ -1,119 +1,29 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod";
+import { bindTools } from "./helpers.js";
+import { registerResources } from "./resources/index.js";
+import { tools_exports } from "./tools/index.js";
+import package_default from "../../package.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp";
 //#region src/modules/mcp/server.ts
-var ok = (data) => ({ content: [{
-	type: "text",
-	text: JSON.stringify(data, null, 2)
-}] });
-var err = (message) => ({
-	content: [{
-		type: "text",
-		text: message
-	}],
-	isError: true
-});
-var createMcpServer = (adapters) => {
+var createMcpServer = (adapters = {}, engine, tools, prompts, resources) => {
+	const boundTools = bindTools([...Object.values(tools_exports), ...tools ?? []], adapters);
 	const server = new McpServer({
-		name: "plitzi-schema-agent",
-		version: "1.0.0"
-	});
-	server.tool("list_spaces", "List all spaces available in the system", {}, async () => {
-		return ok(await adapters.listSpaces());
-	});
-	server.tool("get_schema", "Get the full element tree for a space and environment", {
-		spaceId: z.number().describe("Space ID"),
-		environment: z.string().describe("Environment name (e.g. main, production)")
-	}, async ({ spaceId, environment }) => {
-		const schema = await adapters.getSchema(spaceId, environment);
-		if (!schema) return err(`Schema not found for space ${spaceId} / ${environment}`);
-		return ok(schema);
-	});
-	server.tool("list_elements", "List all element IDs, types and labels for a space and environment", {
-		spaceId: z.number(),
-		environment: z.string()
-	}, async ({ spaceId, environment }) => {
-		const schema = await adapters.getSchema(spaceId, environment);
-		if (!schema) return err(`Schema not found for space ${spaceId} / ${environment}`);
-		return ok(Object.values(schema.elements).map(({ id, type, label, parentId, runtime }) => ({
-			id,
-			type,
-			label,
-			parentId,
-			runtime
-		})));
-	});
-	server.tool("get_element", "Get the full details of a single element by ID", {
-		spaceId: z.number(),
-		environment: z.string(),
-		elementId: z.string().describe("Element ID")
-	}, async ({ spaceId, environment, elementId }) => {
-		const schema = await adapters.getSchema(spaceId, environment);
-		if (!schema) return err(`Schema not found for space ${spaceId} / ${environment}`);
-		const element = schema.elements[elementId];
-		if (!element) return err(`Element ${elementId} not found`);
-		return ok(element);
-	});
-	server.tool("create_element", "Add a new element to the schema. Returns the created element with its generated ID.", {
-		spaceId: z.number(),
-		environment: z.string(),
-		type: z.string().describe("Component type (e.g. Container, Text, Button, Image)"),
-		label: z.string().describe("Human-readable name for the element"),
-		props: z.record(z.string(), z.unknown()).optional().describe("Component props/attributes"),
-		runtime: z.enum([
-			"server",
-			"client",
-			"shared"
-		]).optional().describe("Rendering runtime"),
-		parentId: z.string().optional().describe("Parent element ID; omit to place at root"),
-		position: z.number().optional().describe("Zero-based insertion index within the parent")
-	}, async ({ spaceId, environment, type, label, props, runtime, parentId, position }) => {
-		return ok(await adapters.createElement(spaceId, environment, {
-			type,
-			label,
-			props,
-			runtime
-		}, parentId, position));
-	});
-	server.tool("update_element", "Update an existing element — label, props, styles, or runtime", {
-		spaceId: z.number(),
-		environment: z.string(),
-		elementId: z.string(),
-		label: z.string().optional(),
-		props: z.record(z.string(), z.unknown()).optional(),
-		styles: z.record(z.string(), z.unknown()).optional(),
-		runtime: z.enum([
-			"server",
-			"client",
-			"shared"
-		]).optional()
-	}, async ({ spaceId, environment, elementId, label, props, styles, runtime }) => {
-		return ok(await adapters.updateElement(spaceId, environment, elementId, {
-			label,
-			props,
-			styles,
-			runtime
-		}));
-	});
-	server.tool("delete_element", "Remove an element and all its descendants from the schema", {
-		spaceId: z.number(),
-		environment: z.string(),
-		elementId: z.string()
-	}, async ({ spaceId, environment, elementId }) => {
-		await adapters.deleteElement(spaceId, environment, elementId);
-		return ok({ deleted: elementId });
-	});
-	server.tool("publish_schema", "Publish the current draft schema as a new immutable revision", {
-		spaceId: z.number(),
-		environment: z.string()
-	}, async ({ spaceId, environment }) => {
-		return ok(await adapters.publishSchema(spaceId, environment));
-	});
-	if (adapters.listPlugins) {
-		const listPlugins = adapters.listPlugins;
-		server.tool("list_plugins", "List all plugins registered in the system", {}, async () => {
-			return ok(await listPlugins());
-		});
+		name: "plitzi-mcp",
+		version: package_default.version
+	});
+	engine.setToolsAvailables(boundTools);
+	registerResources(server, resources, engine.readResource);
+	for (const tool of boundTools) {
+		if (!engine.can(tool.name)) continue;
+		const { title, description, inputSchema, annotations } = tool.mcpDefinition;
+		const definition = {
+			title,
+			description,
+			inputSchema,
+			annotations
+		};
+		server.registerTool(tool.name, definition, engine.execute(tool.name, tool.handler));
 	}
+	if (prompts) for (const prompt of prompts) server.registerPrompt(prompt.name, prompt.definition, engine.executePrompt(prompt.name, prompt.handler));
 	return server;
 };
 //#endregion

package/dist/modules/mcp/tools/collections/createCollection.js

@@ -0,0 +1,25 @@
+import { getAllowedModes } from "../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/collections/createCollection.ts
+var createCollectionTool = {
+	name: "create_collection",
+	adapterName: "createCollection",
+	mcpDefinition: {
+		title: "Create Collection",
+		description: "Create a new collection — a structured data store for the space.\n\nProvide field definitions in fields as a map of field name to field config. Records can be created afterwards via create_collection_record.",
+		inputSchema: z.object({
+			name: z.string().describe("Singular collection name (e.g. \"Product\")"),
+			namePlural: z.string().describe("Plural collection name (e.g. \"Products\")"),
+			description: z.string().optional().describe("Short description of what this collection stores"),
+			privacy: z.enum(["public", "private"]).optional().describe("\"public\" allows unauthenticated reads; \"private\" requires auth"),
+			fields: z.record(z.string(), z.unknown()).describe("Field definitions keyed by field name — each value is a field config object")
+		}),
+		outputSchema: z.object({
+			id: z.string().describe("Collection ID"),
+			name: z.string().describe("Collection name")
+		}).catchall(z.unknown()).describe("The created collection")
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { createCollectionTool as default };

package/dist/modules/mcp/tools/collections/createCollectionRecord.js

@@ -0,0 +1,27 @@
+import { getAllowedModes } from "../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/collections/createCollectionRecord.ts
+var createCollectionRecordTool = {
+	name: "create_collection_record",
+	adapterName: "createCollectionRecord",
+	mcpDefinition: {
+		title: "Create Collection Record",
+		description: "Create a new record in a collection. Pass field values matching the collection's field definitions.",
+		inputSchema: z.object({
+			collectionId: z.string().describe("Collection ID"),
+			values: z.record(z.string(), z.union([
+				z.string(),
+				z.number(),
+				z.boolean()
+			])).describe("Field values keyed by field name — keys must match the collection field definitions (see get_collection)"),
+			status: z.enum(["draft", "published"]).optional().describe("Publication status; defaults to \"draft\"")
+		}),
+		outputSchema: z.object({
+			id: z.string().describe("Record ID"),
+			collectionId: z.string().describe("Collection ID")
+		}).catchall(z.unknown()).describe("The created record")
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { createCollectionRecordTool as default };