@cplace/test-mcp-server 0.1.15 → 1.0.0

package/dist/tools/csv-export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csv-export.d.ts","sourceRoot":"","sources":["../../src/tools/csv-export.ts"],"names":[],"mappings":"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"}

package/dist/tools/csv-export.js

@@ -0,0 +1,61 @@
+import { z } from "zod";
+import SearchFilterSchema from "../searchSchema.js";
+import { convertSearchFilterToCplaceFormat } from "../searchConversion.js";
+import { debugLogWithTag } from "../logger.js";
+import { convertPagesToCsv } from "../csvUtils.js";
+const TOOL_SEARCH_PAGES_CSV = 'cplace_search_pages_csv';
+export const CSV_EXPORT_TOOL_DEFINITIONS = {
+    [TOOL_SEARCH_PAGES_CSV]: {
+        description: "Same as cplace_search_pages but returns results in CSV format instead of JSON. Only use this tool after first calling cplace_search_pages to establish and validate the search parameters. The CSV result should always be stored as an artifact.\n\nIMPORTANT: Date filter values must use date-only format (YYYY-MM-DD). Datetime formats are not supported. See cplace_search_pages for full details.",
+        inputSchema: {
+            workspaceId: z.string().optional().describe("Same as cplace_search_pages"),
+            internalTypeName: z.string().describe("Same as cplace_search_pages"),
+            search_filter: SearchFilterSchema.describe("Same as cplace_search_pages"),
+            limit: z.number().min(1).max(1000).default(50).describe("Same as cplace_search_pages"),
+            offset: z.number().min(0).max(10000).default(0).describe("Same as cplace_search_pages"),
+            attributes: z.array(z.string()).optional().describe("Same as cplace_search_pages"),
+        },
+        annotations: { title: "Search Pages (CSV Export)" }
+    }
+};
+export function registerCsvExportTools(server, client) {
+    server.registerTool(TOOL_SEARCH_PAGES_CSV, CSV_EXPORT_TOOL_DEFINITIONS[TOOL_SEARCH_PAGES_CSV], async ({ workspaceId, internalTypeName, search_filter, limit = 50, offset = 0, attributes, }) => {
+        debugLogWithTag('CSV_SEARCH', `Starting CSV search with params: workspaceId=${workspaceId || 'none'}, type=${internalTypeName}, filter=${JSON.stringify(search_filter)}, limit=${limit}, offset=${offset}`);
+        try {
+            const cplaceFilter = convertSearchFilterToCplaceFormat(search_filter);
+            debugLogWithTag('CSV_SEARCH', `Converted filter: ${JSON.stringify(cplaceFilter)}`);
+            if (workspaceId) {
+                cplaceFilter.filters.unshift({
+                    type: "Workspace",
+                    workspaceIds: [workspaceId]
+                });
+            }
+            if (internalTypeName) {
+                cplaceFilter.filters.unshift({
+                    type: "Type",
+                    types: [internalTypeName]
+                });
+            }
+            debugLogWithTag('CSV_SEARCH', `Final cplace filter: ${JSON.stringify(cplaceFilter)}`);
+            const result = await client.makeApiRequest('json/search', 'GET', {
+                filter: JSON.stringify(cplaceFilter),
+                limit,
+                offset
+            });
+            const searchResults = result.results || [];
+            debugLogWithTag('CSV_SEARCH', `Retrieved ${searchResults.length} results for CSV conversion`);
+            const csvContent = await convertPagesToCsv(searchResults, client, attributes);
+            return {
+                content: [{ type: "text", text: csvContent }]
+            };
+        }
+        catch (error) {
+            debugLogWithTag('CSV_SEARCH', `Error during CSV search: ${error instanceof Error ? error.message : String(error)}`);
+            return {
+                content: [{ type: "text", text: `Error converting or executing CSV search: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
+}
+//# sourceMappingURL=csv-export.js.map

package/dist/tools/csv-export.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"csv-export.js","sourceRoot":"","sources":["../../src/tools/csv-export.ts"],"names":[],"mappings":"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"}

package/dist/tools/generic-layouts.d.ts

@@ -26,5 +26,307 @@ export declare const LayoutContextSchema: z.ZodUnion<[z.ZodObject<{
     typeInternalName: string;
     alternativeLayoutName?: string | undefined;
 }>]>;
+export declare const GENERIC_LAYOUT_TOOL_DEFINITIONS: {
+    readonly cplace_layout_get_overview: {
+        readonly description: "Get layout structure for page or type. Provides an overview of the layout grid including rows, columns, and widget summaries for both page and type layouts.";
+        readonly inputSchema: {
+            readonly context: z.ZodUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"page">;
+                pageUID: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: "page";
+                pageUID: string;
+            }, {
+                type: "page";
+                pageUID: string;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"type">;
+                workspaceId: z.ZodString;
+                typeInternalName: z.ZodString;
+                alternativeLayoutName: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                type: "type";
+                workspaceId: string;
+                typeInternalName: string;
+                alternativeLayoutName?: string | undefined;
+            }, {
+                type: "type";
+                workspaceId: string;
+                typeInternalName: string;
+                alternativeLayoutName?: string | undefined;
+            }>]>;
+        };
+        readonly annotations: {
+            readonly title: "Get Layout Overview";
+        };
+    };
+    readonly cplace_layout_add_widget: {
+        readonly description: "Add widget to page or type layout. Works with both page and type layouts using the same interface and behavior.\n\n⚠️ REQUIRED BEFORE USE:\n- ALWAYS call cplace_get_widget_definition FIRST to understand required fields\n- Many widgets have non-obvious required attributes that will cause validation errors\n- Widget configurations must match the schema exactly\n\nCRITICAL BEHAVIOR:\n- Row creation: ❌ NOT automatic - use cplace_layout_add_row to create rows first\n- Column creation: ❌ NOT automatic - columnIndex only references existing columns\n- Invalid columnIndex: Falls back to last existing column (no error)\n\nTO CREATE SIDE-BY-SIDE LAYOUTS:\n1. First use cplace_layout_add_row to create multi-column structure\n2. Then add widgets to the created columns\n\nEXAMPLES:\n- Add to new row 0: Creates single-column row, widget goes to column 0\n- Add to column 1 when only column 0 exists: Widget goes to column 0 (fallback)\n- Add to pre-created 6/6 row: Works correctly if columns exist\n\nTIP: Always check current layout with cplace_layout_get_overview before adding widgets.";
+        readonly inputSchema: {
+            readonly context: z.ZodUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"page">;
+                pageUID: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: "page";
+                pageUID: string;
+            }, {
+                type: "page";
+                pageUID: string;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"type">;
+                workspaceId: z.ZodString;
+                typeInternalName: z.ZodString;
+                alternativeLayoutName: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                type: "type";
+                workspaceId: string;
+                typeInternalName: string;
+                alternativeLayoutName?: string | undefined;
+            }, {
+                type: "type";
+                workspaceId: string;
+                typeInternalName: string;
+                alternativeLayoutName?: string | undefined;
+            }>]>;
+            readonly widgetType: z.ZodString;
+            readonly position: z.ZodObject<{
+                rowIndex: z.ZodNumber;
+                columnIndex: z.ZodNumber;
+                widgetIndex: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                rowIndex: number;
+                columnIndex: number;
+                widgetIndex: number;
+            }, {
+                rowIndex: number;
+                columnIndex: number;
+                widgetIndex: number;
+            }>;
+            readonly configuration: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        };
+        readonly annotations: {
+            readonly title: "Add Widget to Layout";
+        };
+    };
+    readonly cplace_layout_remove_widget: {
+        readonly description: "Remove widget from page or type layout. Works with both page and type layouts using the same interface.";
+        readonly inputSchema: {
+            readonly context: z.ZodUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"page">;
+                pageUID: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: "page";
+                pageUID: string;
+            }, {
+                type: "page";
+                pageUID: string;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"type">;
+                workspaceId: z.ZodString;
+                typeInternalName: z.ZodString;
+                alternativeLayoutName: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                type: "type";
+                workspaceId: string;
+                typeInternalName: string;
+                alternativeLayoutName?: string | undefined;
+            }, {
+                type: "type";
+                workspaceId: string;
+                typeInternalName: string;
+                alternativeLayoutName?: string | undefined;
+            }>]>;
+            readonly widgetId: z.ZodString;
+        };
+        readonly annotations: {
+            readonly title: "Remove Widget from Layout";
+        };
+    };
+    readonly cplace_layout_add_row: {
+        readonly description: "Add row structure to page or type layout. Creates new row with specific column layout. Essential for multi-column structures as widget placement alone cannot create columns.";
+        readonly inputSchema: {
+            readonly context: z.ZodUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"page">;
+                pageUID: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: "page";
+                pageUID: string;
+            }, {
+                type: "page";
+                pageUID: string;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"type">;
+                workspaceId: z.ZodString;
+                typeInternalName: z.ZodString;
+                alternativeLayoutName: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                type: "type";
+                workspaceId: string;
+                typeInternalName: string;
+                alternativeLayoutName?: string | undefined;
+            }, {
+                type: "type";
+                workspaceId: string;
+                typeInternalName: string;
+                alternativeLayoutName?: string | undefined;
+            }>]>;
+            readonly rowIndex: z.ZodNumber;
+            readonly columnProportions: z.ZodArray<z.ZodNumber, "many">;
+        };
+        readonly annotations: {
+            readonly title: "Add Row to Layout";
+        };
+    };
+    readonly cplace_layout_get_widget_details: {
+        readonly description: "Get detailed widget configuration from page or type layout. Extracts specific widget information from the layout structure.";
+        readonly inputSchema: {
+            readonly context: z.ZodUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"page">;
+                pageUID: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: "page";
+                pageUID: string;
+            }, {
+                type: "page";
+                pageUID: string;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"type">;
+                workspaceId: z.ZodString;
+                typeInternalName: z.ZodString;
+                alternativeLayoutName: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                type: "type";
+                workspaceId: string;
+                typeInternalName: string;
+                alternativeLayoutName?: string | undefined;
+            }, {
+                type: "type";
+                workspaceId: string;
+                typeInternalName: string;
+                alternativeLayoutName?: string | undefined;
+            }>]>;
+            readonly widgetId: z.ZodString;
+        };
+        readonly annotations: {
+            readonly title: "Get Widget Details from Layout";
+        };
+    };
+    readonly cplace_layout_update_widget: {
+        readonly description: "Update widget configuration or collapse state in page or type layout. Allows modification of widget properties and display settings.\n\nUSE CASES:\n- Restore configuration after widget moves (configurations may be lost during moves)\n- Update widget connections (e.g., change tableWidgetId after layout modifications)\n- Modify display properties (titles, collapse state, etc.)\n\nTIP: Widget IDs may change after layout operations - always use current IDs from latest layout overview retrieved via cplace_layout_get_overview.";
+        readonly inputSchema: {
+            readonly context: z.ZodUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"page">;
+                pageUID: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: "page";
+                pageUID: string;
+            }, {
+                type: "page";
+                pageUID: string;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"type">;
+                workspaceId: z.ZodString;
+                typeInternalName: z.ZodString;
+                alternativeLayoutName: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                type: "type";
+                workspaceId: string;
+                typeInternalName: string;
+                alternativeLayoutName?: string | undefined;
+            }, {
+                type: "type";
+                workspaceId: string;
+                typeInternalName: string;
+                alternativeLayoutName?: string | undefined;
+            }>]>;
+            readonly widgetId: z.ZodString;
+            readonly newConfiguration: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            readonly collapsed: z.ZodOptional<z.ZodBoolean>;
+        };
+        readonly annotations: {
+            readonly title: "Update Widget in Layout";
+        };
+    };
+    readonly cplace_layout_move_widget: {
+        readonly description: "Move widget to different position in page or type layout. Relocates widget to specified grid position.\n\nMOVE BEHAVIOR:\n- ✅ Can move between existing rows and columns\n- ❌ Cannot create new columns (only references existing ones)\n- Invalid columnIndex: Falls back to last column in target row\n\nCRITICAL WARNINGS:\n- Widget configurations may be LOST during moves\n- Widget IDs may CHANGE - always get new IDs from response\n- Connected widgets (charts) may lose their tableWidgetId references\n\nPOST-MOVE CHECKLIST:\n1. Get new widget ID from response\n2. Use cplace_layout_get_widget_details to check if configuration was preserved\n3. If lost, use cplace_layout_update_widget to restore configuration\n4. Update any widgets that referenced the moved widget's old ID\n\nTIP: For complex layouts, consider removing and re-adding widgets instead of moving.";
+        readonly inputSchema: {
+            readonly context: z.ZodUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"page">;
+                pageUID: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: "page";
+                pageUID: string;
+            }, {
+                type: "page";
+                pageUID: string;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"type">;
+                workspaceId: z.ZodString;
+                typeInternalName: z.ZodString;
+                alternativeLayoutName: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                type: "type";
+                workspaceId: string;
+                typeInternalName: string;
+                alternativeLayoutName?: string | undefined;
+            }, {
+                type: "type";
+                workspaceId: string;
+                typeInternalName: string;
+                alternativeLayoutName?: string | undefined;
+            }>]>;
+            readonly widgetId: z.ZodString;
+            readonly newPosition: z.ZodObject<{
+                rowIndex: z.ZodNumber;
+                columnIndex: z.ZodNumber;
+                widgetIndex: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                rowIndex: number;
+                columnIndex: number;
+                widgetIndex: number;
+            }, {
+                rowIndex: number;
+                columnIndex: number;
+                widgetIndex: number;
+            }>;
+        };
+        readonly annotations: {
+            readonly title: "Move Widget in Layout";
+        };
+    };
+    readonly cplace_layout_compact: {
+        readonly description: "Remove empty rows from page or type layout. Compacts the layout by keeping only rows that contain widgets while preserving order and configurations.";
+        readonly inputSchema: {
+            readonly context: z.ZodUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"page">;
+                pageUID: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: "page";
+                pageUID: string;
+            }, {
+                type: "page";
+                pageUID: string;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"type">;
+                workspaceId: z.ZodString;
+                typeInternalName: z.ZodString;
+                alternativeLayoutName: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                type: "type";
+                workspaceId: string;
+                typeInternalName: string;
+                alternativeLayoutName?: string | undefined;
+            }, {
+                type: "type";
+                workspaceId: string;
+                typeInternalName: string;
+                alternativeLayoutName?: string | undefined;
+            }>]>;
+        };
+        readonly annotations: {
+            readonly title: "Compact Layout";
+        };
+    };
+};
 export declare function registerLayoutTools(server: McpServer, client: CplaceApiClient): void;
 //# sourceMappingURL=generic-layouts.d.ts.map

package/dist/tools/generic-layouts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generic-layouts.d.ts","sourceRoot":"","sources":["../../src/tools/generic-layouts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAuB5C,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;IAW+C,CAAC;AAmFhF,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,QAse7E"}
+{"version":3,"file":"generic-layouts.d.ts","sourceRoot":"","sources":["../../src/tools/generic-layouts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAuB5C,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;IAW+C,CAAC;AAgBhF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6ElC,CAAC;AAgFX,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,QAgb7E"}

package/dist/tools/generic-layouts.js

@@ -13,6 +13,92 @@ export const LayoutContextSchema = z.union([
         alternativeLayoutName: z.string().optional().describe("Alternative layout name (optional)")
     })
 ]).describe("Layout target - specify whether operating on page or type layout");
+const TOOL_LAYOUT_GET_OVERVIEW = 'cplace_layout_get_overview';
+const TOOL_LAYOUT_ADD_WIDGET = 'cplace_layout_add_widget';
+const TOOL_LAYOUT_REMOVE_WIDGET = 'cplace_layout_remove_widget';
+const TOOL_LAYOUT_ADD_ROW = 'cplace_layout_add_row';
+const TOOL_LAYOUT_GET_WIDGET_DETAILS = 'cplace_layout_get_widget_details';
+const TOOL_LAYOUT_UPDATE_WIDGET = 'cplace_layout_update_widget';
+const TOOL_LAYOUT_MOVE_WIDGET = 'cplace_layout_move_widget';
+const TOOL_LAYOUT_COMPACT = 'cplace_layout_compact';
+export const GENERIC_LAYOUT_TOOL_DEFINITIONS = {
+    [TOOL_LAYOUT_GET_OVERVIEW]: {
+        description: "Get layout structure for page or type. Provides an overview of the layout grid including rows, columns, and widget summaries for both page and type layouts.",
+        inputSchema: {
+            context: LayoutContextSchema
+        },
+        annotations: { title: "Get Layout Overview" }
+    },
+    [TOOL_LAYOUT_ADD_WIDGET]: {
+        description: "Add widget to page or type layout. Works with both page and type layouts using the same interface and behavior.\n\n⚠️ REQUIRED BEFORE USE:\n- ALWAYS call cplace_get_widget_definition FIRST to understand required fields\n- Many widgets have non-obvious required attributes that will cause validation errors\n- Widget configurations must match the schema exactly\n\nCRITICAL BEHAVIOR:\n- Row creation: ❌ NOT automatic - use cplace_layout_add_row to create rows first\n- Column creation: ❌ NOT automatic - columnIndex only references existing columns\n- Invalid columnIndex: Falls back to last existing column (no error)\n\nTO CREATE SIDE-BY-SIDE LAYOUTS:\n1. First use cplace_layout_add_row to create multi-column structure\n2. Then add widgets to the created columns\n\nEXAMPLES:\n- Add to new row 0: Creates single-column row, widget goes to column 0\n- Add to column 1 when only column 0 exists: Widget goes to column 0 (fallback)\n- Add to pre-created 6/6 row: Works correctly if columns exist\n\nTIP: Always check current layout with cplace_layout_get_overview before adding widgets.",
+        inputSchema: {
+            context: LayoutContextSchema,
+            widgetType: z.string().describe("Widget type identifier (e.g., 'cf.cplace.platform.table', 'cf.platform.wiki')"),
+            position: PositionSchema,
+            configuration: z.record(z.any()).optional().describe(`${WIDGET_CONFIG_DESCRIPTION}
+
+WIDGET-SPECIFIC PATTERNS:
+- Connected widgets (bar/pie charts): Use 'tableWidgetId' to connect to existing table widget
+  Example: {'tableWidgetId': 'id_abc123', 'title': {'en': 'Chart Title'}}
+- Attribute widgets: Use 'cf.platform.quotedAttributeName' with single quotes
+  Example: {'cf.platform.quotedAttributeName': "'cf.cplace.myAttribute'", 'cf.platform.withLabel': true}
+- Search widgets: Use 'search' with JSON search string
+  Example: {'search': '{"filters":[{"types":["test.project"]}]}', 'title': {'en': 'Results'}}`)
+        },
+        annotations: { title: "Add Widget to Layout" }
+    },
+    [TOOL_LAYOUT_REMOVE_WIDGET]: {
+        description: "Remove widget from page or type layout. Works with both page and type layouts using the same interface.",
+        inputSchema: {
+            context: LayoutContextSchema,
+            widgetId: z.string().describe("The unique identifier of the widget to remove")
+        },
+        annotations: { title: "Remove Widget from Layout" }
+    },
+    [TOOL_LAYOUT_ADD_ROW]: {
+        description: "Add row structure to page or type layout. Creates new row with specific column layout. Essential for multi-column structures as widget placement alone cannot create columns.",
+        inputSchema: {
+            context: LayoutContextSchema,
+            rowIndex: z.number().min(0).describe("Row index where to insert the new row (0-based). If rowIndex >= current row count, adds at the end. Otherwise, inserts at position and shifts existing rows down."),
+            columnProportions: z.array(z.number().min(1)).min(1).describe("Array of column width proportions that must sum to 12 (Bootstrap grid system). Examples: [12] (single column), [6,6] (two equal columns), [4,4,4] (three equal columns), [3,9] (sidebar + main)")
+        },
+        annotations: { title: "Add Row to Layout" }
+    },
+    [TOOL_LAYOUT_GET_WIDGET_DETAILS]: {
+        description: "Get detailed widget configuration from page or type layout. Extracts specific widget information from the layout structure.",
+        inputSchema: {
+            context: LayoutContextSchema,
+            widgetId: z.string().describe("The unique widget identifier to get details for")
+        },
+        annotations: { title: "Get Widget Details from Layout" }
+    },
+    [TOOL_LAYOUT_UPDATE_WIDGET]: {
+        description: "Update widget configuration or collapse state in page or type layout. Allows modification of widget properties and display settings.\n\nUSE CASES:\n- Restore configuration after widget moves (configurations may be lost during moves)\n- Update widget connections (e.g., change tableWidgetId after layout modifications)\n- Modify display properties (titles, collapse state, etc.)\n\nTIP: Widget IDs may change after layout operations - always use current IDs from latest layout overview retrieved via cplace_layout_get_overview.",
+        inputSchema: {
+            context: LayoutContextSchema,
+            widgetId: z.string().describe("The unique identifier of the widget to update"),
+            newConfiguration: z.record(z.any()).optional().describe(`Updated widget configuration as key-value pairs (optional). ${WIDGET_CONFIG_DESCRIPTION}`),
+            collapsed: z.boolean().optional().describe("Widget collapse state (optional)")
+        },
+        annotations: { title: "Update Widget in Layout" }
+    },
+    [TOOL_LAYOUT_MOVE_WIDGET]: {
+        description: "Move widget to different position in page or type layout. Relocates widget to specified grid position.\n\nMOVE BEHAVIOR:\n- ✅ Can move between existing rows and columns\n- ❌ Cannot create new columns (only references existing ones)\n- Invalid columnIndex: Falls back to last column in target row\n\nCRITICAL WARNINGS:\n- Widget configurations may be LOST during moves\n- Widget IDs may CHANGE - always get new IDs from response\n- Connected widgets (charts) may lose their tableWidgetId references\n\nPOST-MOVE CHECKLIST:\n1. Get new widget ID from response\n2. Use cplace_layout_get_widget_details to check if configuration was preserved\n3. If lost, use cplace_layout_update_widget to restore configuration\n4. Update any widgets that referenced the moved widget's old ID\n\nTIP: For complex layouts, consider removing and re-adding widgets instead of moving.",
+        inputSchema: {
+            context: LayoutContextSchema,
+            widgetId: z.string().describe("The unique identifier of the widget to move"),
+            newPosition: PositionSchema
+        },
+        annotations: { title: "Move Widget in Layout" }
+    },
+    [TOOL_LAYOUT_COMPACT]: {
+        description: "Remove empty rows from page or type layout. Compacts the layout by keeping only rows that contain widgets while preserving order and configurations.",
+        inputSchema: {
+            context: LayoutContextSchema
+        },
+        annotations: { title: "Compact Layout" }
+    }
+};
 function determineApiEndpoint(context, operation) {
     const baseEndpoint = context.type === "page" ? "json/pageLayout" : "json/typeLayout";
     return baseEndpoint;
@@ -68,13 +154,7 @@ function mapOperationName(context, operation) {
     return contextMapping[operation] || operation;
 }
 export function registerLayoutTools(server, client) {
-    server.registerTool("cplace_layout_get_overview", {
-        description: "Get layout structure for page or type. Provides an overview of the layout grid including rows, columns, and widget summaries for both page and type layouts.",
-        inputSchema: {
-            context: LayoutContextSchema
-        },
-        annotations: { title: "Get Layout Overview" }
-    }, async ({ context }) => {
+    server.registerTool(TOOL_LAYOUT_GET_OVERVIEW, GENERIC_LAYOUT_TOOL_DEFINITIONS[TOOL_LAYOUT_GET_OVERVIEW], async ({ context }) => {
         debugLogWithTag('LAYOUT', `Starting layout overview request for ${context.type} layout`);
         try {
             const result = await handleLayoutOperation(client, context, 'getOverview');
@@ -88,7 +168,8 @@ export function registerLayoutTools(server, client) {
                         widgets: column.widgets?.map((widget) => ({
                             id: widget.id,
                             widgetType: widget.widgetType,
-                            configurationCount: widget.configuration?.length || 0
+                            configurationCount: widget.configuration?.length || 0,
+                            validationStatus: widget.validationStatus || null
                         })) || []
                     })) || []
                 })) || []
@@ -109,16 +190,7 @@ export function registerLayoutTools(server, client) {
             };
         }
     });
-    server.registerTool("cplace_layout_add_widget", {
-        description: "Add widget to page or type layout. Works with both page and type layouts using the same interface and behavior.",
-        inputSchema: {
-            context: LayoutContextSchema,
-            widgetType: z.string().describe("Widget type identifier (e.g., 'cf.cplace.platform.table', 'cf.platform.wiki')"),
-            position: PositionSchema,
-            configuration: z.record(z.any()).optional().describe(WIDGET_CONFIG_DESCRIPTION)
-        },
-        annotations: { title: "Add Widget to Layout" }
-    }, async ({ context, widgetType, position, configuration }) => {
+    server.registerTool(TOOL_LAYOUT_ADD_WIDGET, GENERIC_LAYOUT_TOOL_DEFINITIONS[TOOL_LAYOUT_ADD_WIDGET], async ({ context, widgetType, position, configuration }) => {
         debugLogWithTag('LAYOUT', `Adding widget ${widgetType} to ${context.type} layout`);
         try {
             const operationType = mapOperationName(context, 'add_widget');
@@ -142,6 +214,8 @@ export function registerLayoutTools(server, client) {
                 context,
                 widgetType,
                 position,
+                validationStatus: result.status || null,
+                validationDetails: result.validationDetails || null,
                 message: `Widget added successfully to ${context.type} layout`
             };
             return {
@@ -165,14 +239,7 @@ export function registerLayoutTools(server, client) {
             };
         }
     });
-    server.registerTool("cplace_layout_remove_widget", {
-        description: "Remove widget from page or type layout. Works with both page and type layouts using the same interface.",
-        inputSchema: {
-            context: LayoutContextSchema,
-            widgetId: z.string().describe("The unique identifier of the widget to remove")
-        },
-        annotations: { title: "Remove Widget from Layout" }
-    }, async ({ context, widgetId }) => {
+    server.registerTool(TOOL_LAYOUT_REMOVE_WIDGET, GENERIC_LAYOUT_TOOL_DEFINITIONS[TOOL_LAYOUT_REMOVE_WIDGET], async ({ context, widgetId }) => {
         debugLogWithTag('LAYOUT', `Removing widget ${widgetId} from ${context.type} layout`);
         try {
             const operationType = mapOperationName(context, 'remove_widget');
@@ -205,15 +272,7 @@ export function registerLayoutTools(server, client) {
             };
         }
     });
-    server.registerTool("cplace_layout_add_row", {
-        description: "Add row structure to page or type layout. Creates new row with specific column layout. Essential for multi-column structures as widget placement alone cannot create columns.",
-        inputSchema: {
-            context: LayoutContextSchema,
-            rowIndex: z.number().min(0).describe("Row index where to insert the new row (0-based). If rowIndex >= current row count, adds at the end. Otherwise, inserts at position and shifts existing rows down."),
-            columnProportions: z.array(z.number().min(1)).min(1).describe("Array of column width proportions that must sum to 12 (Bootstrap grid system). Examples: [12] (single column), [6,6] (two equal columns), [4,4,4] (three equal columns), [3,9] (sidebar + main)")
-        },
-        annotations: { title: "Add Row to Layout" }
-    }, async ({ context, rowIndex, columnProportions }) => {
+    server.registerTool(TOOL_LAYOUT_ADD_ROW, GENERIC_LAYOUT_TOOL_DEFINITIONS[TOOL_LAYOUT_ADD_ROW], async ({ context, rowIndex, columnProportions }) => {
         debugLogWithTag('LAYOUT', `Adding row ${rowIndex} with proportions ${JSON.stringify(columnProportions)} to ${context.type} layout`);
         try {
             const operationType = mapOperationName(context, 'add_row');
@@ -252,14 +311,7 @@ export function registerLayoutTools(server, client) {
             };
         }
     });
-    server.registerTool("cplace_layout_get_widget_details", {
-        description: "Get detailed widget configuration from page or type layout. Extracts specific widget information from the layout structure.",
-        inputSchema: {
-            context: LayoutContextSchema,
-            widgetId: z.string().describe("The unique widget identifier to get details for")
-        },
-        annotations: { title: "Get Widget Details from Layout" }
-    }, async ({ context, widgetId }) => {
+    server.registerTool(TOOL_LAYOUT_GET_WIDGET_DETAILS, GENERIC_LAYOUT_TOOL_DEFINITIONS[TOOL_LAYOUT_GET_WIDGET_DETAILS], async ({ context, widgetId }) => {
         debugLogWithTag('LAYOUT', `Getting widget details for ${widgetId} from ${context.type} layout`);
         try {
             const layoutResult = await handleLayoutOperation(client, context, 'getOverview');
@@ -291,7 +343,8 @@ export function registerLayoutTools(server, client) {
             const response = {
                 context,
                 widgetId,
-                widget: foundWidget
+                widget: foundWidget,
+                validationStatus: foundWidget.validationStatus || null
             };
             return {
                 content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
@@ -308,16 +361,7 @@ export function registerLayoutTools(server, client) {
             };
         }
     });
-    server.registerTool("cplace_layout_update_widget", {
-        description: "Update widget configuration or collapse state in page or type layout. Allows modification of widget properties and display settings.",
-        inputSchema: {
-            context: LayoutContextSchema,
-            widgetId: z.string().describe("The unique identifier of the widget to update"),
-            newConfiguration: z.record(z.any()).optional().describe(`Updated widget configuration as key-value pairs (optional). ${WIDGET_CONFIG_DESCRIPTION}`),
-            collapsed: z.boolean().optional().describe("Widget collapse state (optional)")
-        },
-        annotations: { title: "Update Widget in Layout" }
-    }, async ({ context, widgetId, newConfiguration, collapsed }) => {
+    server.registerTool(TOOL_LAYOUT_UPDATE_WIDGET, GENERIC_LAYOUT_TOOL_DEFINITIONS[TOOL_LAYOUT_UPDATE_WIDGET], async ({ context, widgetId, newConfiguration, collapsed }) => {
         debugLogWithTag('LAYOUT', `Updating widget ${widgetId} in ${context.type} layout`);
         try {
             const operationType = mapOperationName(context, 'update_widget');
@@ -344,6 +388,8 @@ export function registerLayoutTools(server, client) {
                 status: "SUCCESS",
                 context,
                 widgetId,
+                validationStatus: result.status || null,
+                validationDetails: result.validationDetails || null,
                 message: `Widget updated successfully in ${context.type} layout`
             };
             return {
@@ -366,15 +412,7 @@ export function registerLayoutTools(server, client) {
             };
         }
     });
-    server.registerTool("cplace_layout_move_widget", {
-        description: "Move widget to different position in page or type layout. Relocates widget to specified grid position.",
-        inputSchema: {
-            context: LayoutContextSchema,
-            widgetId: z.string().describe("The unique identifier of the widget to move"),
-            newPosition: PositionSchema
-        },
-        annotations: { title: "Move Widget in Layout" }
-    }, async ({ context, widgetId, newPosition }) => {
+    server.registerTool(TOOL_LAYOUT_MOVE_WIDGET, GENERIC_LAYOUT_TOOL_DEFINITIONS[TOOL_LAYOUT_MOVE_WIDGET], async ({ context, widgetId, newPosition }) => {
         debugLogWithTag('LAYOUT', `Moving widget ${widgetId} in ${context.type} layout to position ${JSON.stringify(newPosition)}`);
         try {
             const operationType = mapOperationName(context, 'move_widget');
@@ -417,13 +455,7 @@ export function registerLayoutTools(server, client) {
             };
         }
     });
-    server.registerTool("cplace_layout_compact", {
-        description: "Remove empty rows from page or type layout. Compacts the layout by keeping only rows that contain widgets while preserving order and configurations.",
-        inputSchema: {
-            context: LayoutContextSchema
-        },
-        annotations: { title: "Compact Layout" }
-    }, async ({ context }) => {
+    server.registerTool(TOOL_LAYOUT_COMPACT, GENERIC_LAYOUT_TOOL_DEFINITIONS[TOOL_LAYOUT_COMPACT], async ({ context }) => {
         debugLogWithTag('LAYOUT', `Compacting ${context.type} layout`);
         try {
             const operationType = mapOperationName(context, 'compact');