@plitzi/sdk-server 0.30.19 → 0.31.1

package/dist/modules/mcp/tools/segment/createSegment.js

@@ -0,0 +1,27 @@
+import { getAllowedModes } from "../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/segment/createSegment.ts
+var createSegmentTool = {
+	name: "create_segment",
+	adapterName: "createSegment",
+	mcpDefinition: {
+		title: "Create Segment",
+		description: "Create a new segment — a reusable UI template with its own isolated schema and style.\n\nAfter creating, use create_segment_element to add elements inside it. The output includes baseElementId — the root element ID for the segment.",
+		inputSchema: z.object({
+			name: z.string().describe("Name of the segment"),
+			description: z.string().describe("Description of the segment")
+		}),
+		outputSchema: z.object({
+			identifier: z.string().describe("Segment identifier"),
+			definition: z.object({
+				name: z.string().describe("Segment name"),
+				description: z.string().describe("Segment description"),
+				baseElementId: z.string().describe("Root element ID")
+			}).describe("Segment definition"),
+			id: z.string().optional().describe("Segment ID")
+		}).describe("The created segment")
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { createSegmentTool as default };

package/dist/modules/mcp/tools/segment/deleteSegment.js

@@ -0,0 +1,16 @@
+import { getAllowedModes } from "../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/segment/deleteSegment.ts
+var deleteSegmentTool = {
+	name: "delete_segment",
+	adapterName: "deleteSegment",
+	mcpDefinition: {
+		title: "Delete Segment",
+		description: "Delete a segment and its entire isolated schema and style. This action cannot be undone.",
+		inputSchema: z.object({ segmentId: z.string().describe("ID of the segment to delete") }),
+		outputSchema: z.literal(true).describe("Always true on successful deletion")
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { deleteSegmentTool as default };

package/dist/modules/mcp/tools/segment/getSegment.js

@@ -0,0 +1,19 @@
+import { getAllowedModes } from "../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/segment/getSegment.ts
+var getSegmentTool = {
+	name: "get_segment",
+	adapterName: "getSegment",
+	mcpDefinition: {
+		title: "Get Segment",
+		description: "Get the full details of a specific segment by ID or identifier — includes its schema (element tree) and style.\n\nUse get_segments to list available segments first if you do not know the ID or identifier.",
+		inputSchema: z.object({
+			segmentId: z.string().optional().describe("Segment ID (_id). Provide either segmentId or identifier."),
+			identifier: z.string().optional().describe("Segment identifier string. Provide either segmentId or identifier.")
+		}),
+		outputSchema: z.record(z.string(), z.unknown()).nullable().describe("Full segment object including schema and style, or null if not found")
+	},
+	definition: { allowedModes: getAllowedModes("read") }
+};
+//#endregion
+export { getSegmentTool as default };

package/dist/modules/mcp/tools/segment/getSegments.js

@@ -0,0 +1,27 @@
+import { getAllowedModes } from "../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/segment/getSegments.ts
+var getSegmentsTool = {
+	name: "get_segments",
+	adapterName: "getSegments",
+	mcpDefinition: {
+		title: "Get Segments",
+		description: "List all segments in the space — reusable UI templates with their own isolated schema and style.\n\nReturns name, identifier, and base element ID for each segment. Use get_segment with a segmentId to fetch the full schema and style of a specific segment.",
+		inputSchema: z.object({
+			cursor: z.string().optional().describe("Pagination cursor from a previous response"),
+			limit: z.number().int().min(1).max(100).optional().default(20).describe("Maximum number of segments to return")
+		}),
+		outputSchema: z.array(z.object({
+			id: z.string().optional().describe("Segment ID"),
+			identifier: z.string().describe("Segment identifier"),
+			definition: z.object({
+				name: z.string().describe("Segment name"),
+				description: z.string().optional().describe("Segment description"),
+				baseElementId: z.string().optional().describe("Root element ID")
+			}).describe("Segment metadata")
+		})).describe("List of segments")
+	},
+	definition: { allowedModes: getAllowedModes("read") }
+};
+//#endregion
+export { getSegmentsTool as default };

package/dist/modules/mcp/tools/segment/schema/elements/createSegmentElement.js

@@ -0,0 +1,24 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/segment/schema/elements/createSegmentElement.ts
+var createSegmentElementTool = {
+	name: "create_segment_element",
+	adapterName: "createSegmentElement",
+	mcpDefinition: {
+		title: "Create Segment Element",
+		description: "Add an element (component instance) to a segment schema.",
+		inputSchema: z.object({
+			segmentId: z.string().describe("ID of the segment"),
+			element: z.object({
+				type: z.string().describe("Element type identifier — same values as create_element. Get valid values from get_builder_context (elementDefaults keys)."),
+				label: z.string().describe("Human-readable name for the element"),
+				props: z.record(z.string(), z.unknown()).optional().describe("Component props")
+			}).describe("Element to add"),
+			parentId: z.string().describe("Parent element ID — use the segment baseElementId as the root parent, or any existing segment element ID")
+		}),
+		outputSchema: z.object({ id: z.string().describe("Generated element ID") }).catchall(z.unknown()).describe("The created segment element")
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { createSegmentElementTool as default };

package/dist/modules/mcp/tools/segment/schema/elements/deleteSegmentElement.js

@@ -0,0 +1,19 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/segment/schema/elements/deleteSegmentElement.ts
+var deleteSegmentElementTool = {
+	name: "delete_segment_element",
+	adapterName: "deleteSegmentElement",
+	mcpDefinition: {
+		title: "Delete Segment Element",
+		description: "Remove an element from a segment.",
+		inputSchema: z.object({
+			segmentId: z.string().describe("ID of the segment"),
+			elementId: z.string().describe("ID of the element to remove")
+		}),
+		outputSchema: z.literal(true).describe("Always true on successful deletion")
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { deleteSegmentElementTool as default };

package/dist/modules/mcp/tools/segment/schema/elements/moveSegmentElement.js

@@ -0,0 +1,28 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/segment/schema/elements/moveSegmentElement.ts
+var moveSegmentElementTool = {
+	name: "move_segment_element",
+	adapterName: "moveSegmentElement",
+	mcpDefinition: {
+		title: "Move Segment Element",
+		description: "Move an element to a different parent or reorder it within its current parent inside a segment.",
+		inputSchema: z.object({
+			segmentId: z.string().describe("ID of the segment"),
+			elementId: z.string().describe("ID of the element to move"),
+			toParentId: z.string().describe("ID of the new parent element"),
+			dropPosition: z.enum([
+				"top",
+				"bottom",
+				"left",
+				"right",
+				"inside",
+				"custom"
+			]).optional().describe("Where to drop relative to the target parent: \"inside\" appends as last child (default), \"top\"/\"bottom\" inserts before/after siblings")
+		}),
+		outputSchema: z.literal(true).describe("Always true on successful move")
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { moveSegmentElementTool as default };

package/dist/modules/mcp/tools/segment/schema/elements/updateSegmentElement.js

@@ -0,0 +1,23 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/segment/schema/elements/updateSegmentElement.ts
+var updateSegmentElementTool = {
+	name: "update_segment_element",
+	adapterName: "updateSegmentElement",
+	mcpDefinition: {
+		title: "Update Segment Element",
+		description: "Update an element inside a segment.",
+		inputSchema: z.object({
+			segmentId: z.string().describe("ID of the segment"),
+			elementId: z.string().describe("ID of the element to update"),
+			updates: z.object({
+				label: z.string().optional().describe("New label for the element"),
+				props: z.record(z.string(), z.unknown()).optional().describe("New props for the element")
+			}).describe("Fields to update")
+		}),
+		outputSchema: z.object({ id: z.string().describe("Element ID") }).catchall(z.unknown()).describe("The updated segment element")
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { updateSegmentElementTool as default };

package/dist/modules/mcp/tools/segment/schema/variables/createSegmentVariable.js

@@ -0,0 +1,41 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/segment/schema/variables/createSegmentVariable.ts
+var variableTypesSchema = z.enum([
+	"text",
+	"number",
+	"email",
+	"password",
+	"select",
+	"select2",
+	"checkbox",
+	"textarea",
+	"color",
+	"switch"
+]);
+var createSegmentVariableTool = {
+	name: "create_segment_variable",
+	adapterName: "createSegmentVariable",
+	mcpDefinition: {
+		title: "Create Segment Variable",
+		description: "Create a schema variable inside a segment — a typed, named value that segment elements can reference via data bindings.\n\nAll values are stored as strings regardless of type.",
+		inputSchema: z.object({
+			segmentId: z.string().describe("ID of the segment"),
+			variable: z.object({
+				name: z.string().describe("Variable name"),
+				type: variableTypesSchema.describe("Variable type"),
+				value: z.string().describe("Variable default value"),
+				category: z.string().describe("Grouping label shown in the builder UI (e.g. \"Colors\", \"Layout\")")
+			}).describe("Variable to create")
+		}),
+		outputSchema: z.object({
+			name: z.string().describe("Variable name"),
+			type: z.string().describe("Variable type"),
+			value: z.string().describe("Variable value"),
+			category: z.string().describe("Grouping label shown in the builder UI (e.g. \"Colors\", \"Layout\")")
+		}).describe("The created segment variable")
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { createSegmentVariableTool as default };

package/dist/modules/mcp/tools/segment/schema/variables/deleteSegmentVariable.js

@@ -0,0 +1,19 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/segment/schema/variables/deleteSegmentVariable.ts
+var deleteSegmentVariableTool = {
+	name: "delete_segment_variable",
+	adapterName: "deleteSegmentVariable",
+	mcpDefinition: {
+		title: "Delete Segment Variable",
+		description: "Delete a schema variable from a segment. Any element bindings referencing this variable will break.",
+		inputSchema: z.object({
+			segmentId: z.string().describe("ID of the segment"),
+			name: z.string().describe("Name of the variable to delete")
+		}),
+		outputSchema: z.literal(true).describe("Always true on successful deletion")
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { deleteSegmentVariableTool as default };

package/dist/modules/mcp/tools/segment/schema/variables/updateSegmentVariable.js

@@ -0,0 +1,41 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/segment/schema/variables/updateSegmentVariable.ts
+var variableTypesSchema = z.enum([
+	"text",
+	"number",
+	"email",
+	"password",
+	"select",
+	"select2",
+	"checkbox",
+	"textarea",
+	"color",
+	"switch"
+]);
+var updateSegmentVariableTool = {
+	name: "update_segment_variable",
+	adapterName: "updateSegmentVariable",
+	mcpDefinition: {
+		title: "Update Segment Variable",
+		description: "Update an existing schema variable inside a segment. Identified by name; only the provided fields are changed.",
+		inputSchema: z.object({
+			segmentId: z.string().describe("ID of the segment"),
+			variable: z.object({
+				name: z.string().describe("Variable name"),
+				type: variableTypesSchema.optional().describe("Variable type"),
+				value: z.string().optional().describe("Variable value"),
+				category: z.string().optional().describe("Grouping label shown in the builder UI")
+			}).describe("Variable fields to update")
+		}),
+		outputSchema: z.object({
+			name: z.string().describe("Variable name"),
+			type: z.string().describe("Variable type"),
+			value: z.string().describe("Variable value"),
+			category: z.string().describe("Grouping label shown in the builder UI")
+		}).describe("The updated segment variable")
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { updateSegmentVariableTool as default };

package/dist/modules/mcp/tools/segment/style/variables/createSegmentStyleVariable.js

@@ -0,0 +1,34 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { z } from "zod";
+import { StyleVariableCategory } from "@plitzi/sdk-shared";
+//#region src/modules/mcp/tools/segment/style/variables/createSegmentStyleVariable.ts
+var createSegmentStyleVariableTool = {
+	name: "create_segment_style_variable",
+	adapterName: "createSegmentStyleVariable",
+	mcpDefinition: {
+		title: "Create Segment Style Variable",
+		description: "Create a scoped CSS design token inside a segment — a named value for color, spacing, shadow, or a custom CSS property.\n\nColor values can be theme-aware: pass { light: \"#fff\", dark: \"#000\", default: \"#fff\" }. Scoped tokens only apply within this segment.",
+		inputSchema: z.object({
+			segmentId: z.string().describe("ID of the segment"),
+			category: z.nativeEnum(StyleVariableCategory).describe("Token category: \"color\" for hex/rgba values, \"spacing\" for size/spacing units, \"shadow\" for box-shadow values, \"custom\" for any other CSS property"),
+			name: z.string().describe("Token name — used as the CSS variable key (e.g. \"primary\", \"md\", \"card\")"),
+			value: z.union([
+				z.string(),
+				z.number(),
+				z.record(z.string(), z.unknown())
+			]).describe("Token value. Use a plain string/number for a fixed value, or { light: \"...\", dark: \"...\", default: \"...\" } for theme-aware values")
+		}),
+		outputSchema: z.object({
+			category: z.string().describe("Token category: \"color\", \"spacing\", \"shadow\", or \"custom\""),
+			name: z.string().describe("Token name"),
+			value: z.union([
+				z.string(),
+				z.number(),
+				z.record(z.string(), z.string())
+			]).describe("Token value")
+		}).describe("The created segment style variable")
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { createSegmentStyleVariableTool as default };

package/dist/modules/mcp/tools/segment/style/variables/deleteSegmentStyleVariable.js

@@ -0,0 +1,21 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { z } from "zod";
+import { StyleVariableCategory } from "@plitzi/sdk-shared";
+//#region src/modules/mcp/tools/segment/style/variables/deleteSegmentStyleVariable.ts
+var deleteSegmentStyleVariableTool = {
+	name: "delete_segment_style_variable",
+	adapterName: "deleteSegmentStyleVariable",
+	mcpDefinition: {
+		title: "Delete Segment Style Variable",
+		description: "Delete a scoped CSS design token from a segment. Any style rules inside the segment referencing this token will lose its value.",
+		inputSchema: z.object({
+			segmentId: z.string().describe("ID of the segment"),
+			category: z.nativeEnum(StyleVariableCategory).describe("Token category: \"color\", \"spacing\", \"shadow\", or \"custom\""),
+			name: z.string().describe("Token name to delete")
+		}),
+		outputSchema: z.literal(true).describe("Always true on successful deletion")
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { deleteSegmentStyleVariableTool as default };

package/dist/modules/mcp/tools/segment/style/variables/updateSegmentStyleVariable.js

@@ -0,0 +1,34 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { z } from "zod";
+import { StyleVariableCategory } from "@plitzi/sdk-shared";
+//#region src/modules/mcp/tools/segment/style/variables/updateSegmentStyleVariable.ts
+var updateSegmentStyleVariableTool = {
+	name: "update_segment_style_variable",
+	adapterName: "updateSegmentStyleVariable",
+	mcpDefinition: {
+		title: "Update Segment Style Variable",
+		description: "Update an existing scoped CSS design token inside a segment (color, spacing, shadow, or custom).",
+		inputSchema: z.object({
+			segmentId: z.string().describe("ID of the segment"),
+			category: z.nativeEnum(StyleVariableCategory).describe("Token category: \"color\" for hex/rgba values, \"spacing\" for size/spacing units, \"shadow\" for box-shadow values, \"custom\" for any other CSS property"),
+			name: z.string().describe("Token name to update"),
+			value: z.union([
+				z.string(),
+				z.number(),
+				z.record(z.string(), z.unknown())
+			]).describe("New token value. Use a plain string/number for a fixed value, or { light: \"...\", dark: \"...\", default: \"...\" } for theme-aware values")
+		}),
+		outputSchema: z.object({
+			category: z.string().describe("Token category: \"color\", \"spacing\", \"shadow\", or \"custom\""),
+			name: z.string().describe("Token name"),
+			value: z.union([
+				z.string(),
+				z.number(),
+				z.record(z.string(), z.string())
+			]).describe("Updated token value")
+		}).describe("The updated segment style variable")
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { updateSegmentStyleVariableTool as default };

package/dist/modules/mcp/tools/segment/updateSegment.js

@@ -0,0 +1,30 @@
+import { getAllowedModes } from "../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/segment/updateSegment.ts
+var updateSegmentTool = {
+	name: "update_segment",
+	adapterName: "updateSegment",
+	mcpDefinition: {
+		title: "Update Segment",
+		description: "Update a segment name or description.",
+		inputSchema: z.object({
+			segmentId: z.string().describe("ID of the segment to update"),
+			updates: z.object({
+				name: z.string().optional().describe("New name for the segment"),
+				description: z.string().optional().describe("New description for the segment")
+			}).describe("Fields to update")
+		}),
+		outputSchema: z.object({
+			identifier: z.string().describe("Segment identifier"),
+			definition: z.object({
+				name: z.string().describe("Segment name"),
+				description: z.string().describe("Segment description"),
+				baseElementId: z.string().describe("Root element ID")
+			}).describe("Segment definition"),
+			id: z.string().optional().describe("Segment ID")
+		}).describe("The updated segment")
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { updateSegmentTool as default };

package/dist/modules/mcp/tools/space/schema/applyPreview.js

@@ -0,0 +1,33 @@
+import { getAllowedModes } from "../../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/space/schema/applyPreview.ts
+var applyPreviewTool = {
+	name: "apply_preview",
+	adapterName: "applyPreview",
+	mcpDefinition: {
+		title: "Apply Preview",
+		description: "Insert a preview (from preview_concept or sketch_wireframe) into the actual space schema.\n\nTakes the schema and style from a previous preview result and writes them to the space. Use targetParentId to specify which existing element the preview should be inserted into (e.g. the current page ID). Optionally merges the preview style into the space style.",
+		inputSchema: z.object({
+			schema: z.object({ flat: z.record(z.string(), z.unknown()) }).describe("Preview schema containing the flat element map"),
+			style: z.record(z.string(), z.unknown()).optional().describe("Preview style to merge into the space style"),
+			baseElementId: z.string().describe("Root element ID of the preview to insert"),
+			targetParentId: z.string().describe("ID of the existing space element to insert the preview into"),
+			dropPosition: z.enum([
+				"inside",
+				"top",
+				"bottom",
+				"left",
+				"right",
+				"custom"
+			]).optional().default("inside").describe("Where to place the preview relative to the target (default: inside as a child)")
+		}),
+		outputSchema: z.object({
+			baseElementId: z.string().describe("Root element ID that was inserted"),
+			targetParentId: z.string().describe("Parent element where the preview was inserted"),
+			elementCount: z.number().describe("Total number of elements inserted")
+		})
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { applyPreviewTool as default };

package/dist/modules/mcp/tools/space/schema/elements/cloneElement.js

@@ -0,0 +1,34 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/space/schema/elements/cloneElement.ts
+var compactElementSchema = z.object({
+	id: z.string().describe("Element ID"),
+	label: z.string().describe("Element label"),
+	type: z.string().describe("Element type"),
+	parentId: z.string().nullish().describe("Parent element ID (null for root elements)"),
+	items: z.array(z.string()).optional().describe("Child element IDs")
+});
+var cloneElementTool = {
+	name: "clone_element",
+	adapterName: "cloneElement",
+	mcpDefinition: {
+		title: "Clone Element",
+		description: "Duplicate an element and all its children to a new location in the schema.\n\nThe server fetches the element and its full subtree automatically — just provide the elementId. Use get_element or list_elements first to find the element ID.",
+		inputSchema: z.object({
+			elementId: z.string().describe("ID of the element to clone"),
+			to: z.string().describe("Target element ID — where to place the clone"),
+			dropPosition: z.enum([
+				"inside",
+				"top",
+				"bottom",
+				"left",
+				"right",
+				"custom"
+			]).describe("Position relative to the target: inside as a child, top/bottom as a sibling")
+		}),
+		outputSchema: z.array(compactElementSchema).nullable().describe("Cloned elements as compact summaries, or null on failure")
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { cloneElementTool as default };

package/dist/modules/mcp/tools/space/schema/elements/createElement.js

@@ -0,0 +1,50 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/space/schema/elements/createElement.ts
+var elementSchema = z.object({
+	id: z.string().describe("Element ID"),
+	attributes: z.record(z.string(), z.unknown()).describe("Element attributes"),
+	definition: z.object({
+		rootId: z.string().describe("Root element ID"),
+		label: z.string().describe("Element label"),
+		type: z.string().describe("Element type"),
+		parentId: z.string().optional().describe("Parent element ID"),
+		items: z.array(z.string()).optional().describe("Child element IDs"),
+		runtime: z.enum([
+			"server",
+			"client",
+			"shared"
+		]).optional().describe("Rendering runtime"),
+		loadStrategy: z.enum([
+			"eager",
+			"lazy",
+			"visible"
+		]).optional().describe("Load strategy")
+	}).describe("Element definition")
+});
+var createElementTool = {
+	name: "create_element",
+	adapterName: "createElement",
+	mcpDefinition: {
+		title: "Create Element",
+		description: "Add a new element (component instance) to the schema.",
+		inputSchema: z.object({
+			element: z.object({
+				type: z.string().describe("Element type identifier — determines which component renders this element. Get valid values from get_builder_context (elementDefaults keys) or by inspecting existing elements via get_schema."),
+				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")
+			}).describe("Element to create"),
+			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")
+		}),
+		outputSchema: elementSchema.describe("The created element")
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { createElementTool as default };

package/dist/modules/mcp/tools/space/schema/elements/deleteElement.js

@@ -0,0 +1,16 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/space/schema/elements/deleteElement.ts
+var deleteElementTool = {
+	name: "delete_element",
+	adapterName: "deleteElement",
+	mcpDefinition: {
+		title: "Delete Element",
+		description: "Remove an element and all its descendants from the schema. This action cannot be undone.",
+		inputSchema: z.object({ elementId: z.string().describe("ID of the element to delete") }),
+		outputSchema: z.literal(true).describe("Always true on successful deletion")
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { deleteElementTool as default };

package/dist/modules/mcp/tools/space/schema/elements/getElement.js

@@ -0,0 +1,17 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { elementSchema } from "../schemas.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/space/schema/elements/getElement.ts
+var getElementTool = {
+	name: "get_element",
+	adapterName: "getElement",
+	mcpDefinition: {
+		title: "Get Element",
+		description: "Get the full details of a single element by ID — attributes, definition, style selectors, bindings, and interactions. Lighter than get_schema when you only need one element.",
+		inputSchema: z.object({ elementId: z.string().describe("Element ID") }),
+		outputSchema: elementSchema.nullable().describe("The full element details, or null if not found")
+	},
+	definition: { allowedModes: getAllowedModes("read") }
+};
+//#endregion
+export { getElementTool as default };

package/dist/modules/mcp/tools/space/schema/elements/getElements.js

@@ -0,0 +1,21 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { elementSchema } from "../schemas.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/space/schema/elements/getElements.ts
+var getElementsTool = {
+	name: "get_elements",
+	adapterName: "getElements",
+	mcpDefinition: {
+		title: "Get Elements",
+		description: "Get elements from the space with optional filters.\n\nFilters are combined with AND logic. Use pageId to scope to a specific page, type to find all elements of a certain kind, or parentId to get direct children of an element. For a full unfiltered element list use list_elements. For a single element use get_element.",
+		inputSchema: z.object({
+			pageId: z.string().optional().describe("Filter elements by page (rootId). Returns only elements belonging to this page"),
+			type: z.string().optional().describe("Filter elements by type (e.g. \"button\", \"box\", \"text\")"),
+			parentId: z.string().optional().describe("Filter elements by direct parent ID")
+		}),
+		outputSchema: z.array(elementSchema).describe("Elements matching the provided filters")
+	},
+	definition: { allowedModes: getAllowedModes("read") }
+};
+//#endregion
+export { getElementsTool as default };

package/dist/modules/mcp/tools/space/schema/elements/listElements.js

@@ -0,0 +1,28 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/space/schema/elements/listElements.ts
+var inputSchema = z.object({
+	rootId: z.string().optional().describe("Filter to elements belonging to a specific page (by page element ID)"),
+	parentId: z.string().optional().describe("Filter to direct children of a specific element"),
+	type: z.string().optional().describe("Filter by element type (e.g. \"button\", \"box\", \"text\")")
+});
+var compactElementSchema = z.object({
+	id: z.string().describe("Element ID"),
+	label: z.string().describe("Element label"),
+	type: z.string().describe("Element type"),
+	parentId: z.string().nullish().describe("Parent element ID (null for root elements)"),
+	items: z.array(z.string()).optional().describe("Child element IDs")
+});
+var listElementsTool = {
+	name: "list_elements",
+	adapterName: "listElements",
+	mcpDefinition: {
+		title: "List Elements",
+		description: "List elements in the space as compact summaries (id, label, type, parentId, items).\n\nUse rootId to scope to a specific page, parentId to get direct children of an element, or type to find all elements of a certain kind. Filters combine with AND logic. Use get_element for the full details of a specific element.",
+		inputSchema,
+		outputSchema: z.array(compactElementSchema).describe("Matching elements as compact summaries")
+	},
+	definition: { allowedModes: getAllowedModes("read") }
+};
+//#endregion
+export { listElementsTool as default };