@cplace/test-mcp-server 0.1.8 → 0.1.10

package/dist/index.js

@@ -2,967 +2,36 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import * as dotenv from 'dotenv';
-import { z } from "zod";
 import { CplaceApiClient } from './api.js';
-import SearchFilterSchema from "./searchSchema.js";
-import { convertSearchFilterToCplaceFormat } from "./searchConversion.js";
-import { filterSearchResult } from "./utils.js";
-import { debugLogWithTag } from "./logger.js";
-import { DEBUG_LOGGING } from "./logger.js";
-import { convertPagesToCsv } from "./csvUtils.js";
+import { registerWorkspaceTools } from './tools/workspace.js';
+import { registerPageTools } from './tools/pages.js';
+import { registerSearchTools } from './tools/search.js';
+import { registerUserTools } from './tools/users.js';
+import { registerReferenceTools } from './tools/references.js';
+import { registerWidgetTools } from './tools/widgets.js';
+import { registerTypeLayoutTools } from './tools/type-layouts.js';
+import { registerSystemTools } from './tools/system.js';
+import { registerVersionHistoryTools } from './tools/version-history.js';
 dotenv.config();
 const config = {
     url: process.env.CPLACE_URL || '',
     apiToken: process.env.API_TOKEN || '',
     registerSystemInfoTool: process.env.REGISTER_SYSTEM_INFO_TOOL === 'true' || false,
-    registerLayoutTools: process.env.REGISTER_LAYOUT_TOOLS === 'true' || false,
 };
 const client = new CplaceApiClient(config);
 const server = new McpServer({
     name: "cplace-mcp-server",
     version: "1.0.0"
 });
-if (config.registerSystemInfoTool) {
-    server.registerTool("cplace_system_info", {
-        description: "Get system information about the MCP server - including current working directory, CPLACE_URL setting, and debug state",
-        inputSchema: {},
-        annotations: { title: "System Information" }
-    }, async () => {
-        const systemInfo = {
-            currentWorkingDirectory: process.cwd(),
-            cplaceUrl: config.url || 'Not set',
-            debugLogging: DEBUG_LOGGING,
-            nodeVersion: process.version,
-            platform: process.platform
-        };
-        return {
-            content: [{ type: "text", text: JSON.stringify(systemInfo, null, 2) }]
-        };
-    });
-}
-server.registerTool("cplace_list_workspaces", {
-    description: "Get a list of all workspaces with essential properties (id, name, displayName, totalPages, isFavorite, installed apps)",
-    inputSchema: {},
-    annotations: { title: "List Workspaces" }
-}, async () => {
-    debugLogWithTag('WORKSPACES', 'Starting workspace list request');
-    try {
-        const workspaces = await client.makeApiRequest('json/workspaces');
-        const filteredWorkspaces = workspaces.map((workspace) => ({
-            id: workspace.id,
-            name: workspace.name,
-            displayName: workspace.displayName,
-            totalPages: workspace.totalPages,
-            isFavorite: workspace.isFavorite,
-            installedApps: workspace.apps?.installed?.map(app => app.name) || []
-        }));
-        debugLogWithTag('WORKSPACES', `Retrieved ${filteredWorkspaces.length} workspaces`);
-        return {
-            content: [{ type: "text", text: JSON.stringify(filteredWorkspaces, null, 2) }]
-        };
-    }
-    catch (error) {
-        return {
-            content: [{ type: "text", text: `Error retrieving workspaces: ${error instanceof Error ? error.message : String(error)}` }]
-        };
-    }
-});
-server.registerTool("cplace_get_types_in_workspace", {
-    description: "Get a list of all types available in a certain workspace",
-    inputSchema: {
-        workspaceId: z.string().describe("The ID of the workspace to get types for")
-    },
-    annotations: { title: "Get Types in Workspace" }
-}, async ({ workspaceId }) => {
-    try {
-        const workspaces = await client.makeApiRequest('json/workspaces');
-        const workspace = workspaces.find((w) => w.id === workspaceId);
-        if (workspace) {
-            const types = workspace.typeDefinitions?.types || [];
-            return {
-                content: [{ type: "text", text: JSON.stringify(types, null, 2) }]
-            };
-        }
-        return {
-            content: [{ type: "text", text: `Workspace ${workspaceId} not found` }]
-        };
-    }
-    catch (error) {
-        return {
-            content: [{ type: "text", text: `Error retrieving types: ${error instanceof Error ? error.message : String(error)}` }]
-        };
-    }
-});
-server.registerTool("cplace_get_type_datamodel", {
-    description: "Get the datamodel of a type including its attributes, constraints, and permissions. Use this before performing a search to understand the type structure.",
-    inputSchema: {
-        workspaceId: z.string().describe("The ID of the workspace"),
-        internalName: z.string().describe("The internal name of the type")
-    },
-    annotations: { title: "Get Type Details" }
-}, async ({ workspaceId, internalName }) => {
-    try {
-        const result = await client.makeApiRequest('json/type-definition', 'GET', {
-            workspaceId,
-            internalName
-        });
-        return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-        };
-    }
-    catch (error) {
-        return {
-            content: [{ type: "text", text: `Error retrieving type details: ${error instanceof Error ? error.message : String(error)}` }]
-        };
-    }
-});
-server.registerTool("cplace_get_page_by_id", {
-    description: "Get comprehensive page information including relationships and metadata",
-    inputSchema: {
-        id: z.string().describe("The ID of the page to get, e.g. 'page/kkt8ol745jqur4581kelm5ply'")
-    },
-    annotations: { title: "Get Page by ID" }
-}, async ({ id }) => {
-    try {
-        const result = await client.makeApiRequest('json/page', 'GET', { pageUID: id });
-        return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-        };
-    }
-    catch (error) {
-        return {
-            content: [{ type: "text", text: `Error retrieving page: ${error instanceof Error ? error.message : String(error)}` }]
-        };
-    }
-});
-server.registerTool("cplace_get_person_by_id", {
-    description: "Get details about a person including their name and email.",
-    inputSchema: {
-        id: z.string().describe("The ID of the person to get, e.g. 'person/kkt8ol745jqur4581kelm5ply'")
-    },
-    annotations: { title: "Get Person by ID" }
-}, async ({ id }) => {
-    try {
-        const result = await client.makeApiRequest('json/person', 'GET', { id });
-        return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-        };
-    }
-    catch (error) {
-        return {
-            content: [{ type: "text", text: `Error retrieving person: ${error instanceof Error ? error.message : String(error)}` }]
-        };
-    }
-});
-server.registerTool("cplace_search_person", {
-    description: "Search a person by their name.",
-    inputSchema: {
-        name: z.string().describe("The name of the person or part of the name to search for"),
-    },
-    annotations: { title: "Get Person by ID" }
-}, async ({ name }) => {
-    try {
-        const result = await client.makeApiRequest('json/person', 'GET', { name });
-        return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-        };
-    }
-    catch (error) {
-        return {
-            content: [{ type: "text", text: `Error searching for person: ${error instanceof Error ? error.message : String(error)}` }]
-        };
-    }
-});
-server.registerTool("cplace_search_pages", {
-    description: "Search pages of a type in cplace.",
-    inputSchema: {
-        workspaceId: z.string().optional().describe("The ID of the workspace to search in. If not provided, searches across all accessible workspaces."),
-        internalTypeName: z.string().describe(`The internal name of the type to filter by. Examples:
-- "cf.cplace.solution.safe.feature" for Feature pages
-- "cf.cplace.solution.safe.epic" for Epic pages  
-- "cf.cplace.solution.safe.story" for Story pages
-- "cf.projectNavigator.project" for Project pages
-- "cf.cplace.solution.safe.portfolio" for Portfolio pages
-Use cplace_get_types_in_workspace to discover available types in a workspace.`),
-        search_filter: SearchFilterSchema.describe(`Search Filters using cplace filter format. Examples:
-
-Basic string filter:
-[{"attribute": "cf.cplace.workflow", "string": {"equals": "approved"}}]
-
-Multiple conditions:
-[
-  {"name": {"equals": "Project Alpha"}},
-  {"attribute": "cf.cplace.location", "reference": {"equals": "page/abc123"}}
-]
-
-Date range filter:
-[
-  {"attribute": "cf.cplace.projectStart", "date": {"on_or_after": "2023-01-01"}},
-  {"attribute": "cf.cplace.projectFinish", "date": {"on_or_before": "2024-12-31"}}
-]
-
-Number comparison:
-[{"attribute": "cf.cplace.estimatedCost", "number": {"greater_than": 1000}}]
-
-Logical OR operator:
-[{
-  "or": [
-    {"attribute": "cf.cplace.managementPriority", "string": {"equals": "Focus"}},
-    {"attribute": "cf.cplace.managementPriority", "string": {"equals": "Accelerate"}}
-  ]
-}]
-
-Complex AND/OR combination:
-[{
-  "and": [
-    {"attribute": "cf.cplace.workflow", "string": {"equals": "inProgress"}},
-    {
-      "or": [
-        {"attribute": "cf.cplace.priority", "string": {"equals": "High"}},
-        {"attribute": "cf.cplace.priority", "string": {"equals": "Critical"}}
-      ]
-    }
-  ]
-}]
-
-Boolean filter:
-[{"attribute": "cf.cplace.isActive", "boolean": {"equals": true}}]
-
-Empty/not empty checks:
-[{"attribute": "cf.cplace.description", "string": {"is_not_empty": true}}]`),
-        limit: z.number().min(1).max(1000).default(50).describe("Maximum number of results to return (1-1000)"),
-        offset: z.number().min(0).max(10000).default(0).describe("Number of results to skip for pagination, cannot be larger than 10000"),
-        responseFormat: z.enum(["minimal", "count"]).optional().describe(`Response format options:
-- Default (not specified): Complete page data, respects 'attributes' parameter
-- "minimal": Only core fields (id, name, url, type, workspace)
-- "count": Only return the total count of matching pages`),
-        attributes: z.array(z.string()).optional().describe("Specific attribute names to include in response. If not provided, all attributes are included. Examples: ['cf.cplace.workflow', 'cf.cplace.priority']"),
-    },
-    annotations: { title: "Search Pages" }
-}, async ({ workspaceId, internalTypeName, search_filter, limit = 50, offset = 0, responseFormat, attributes, }) => {
-    debugLogWithTag('SEARCH', `Starting search with params: workspaceId=${workspaceId || 'none'}, type=${internalTypeName}, filter=${JSON.stringify(search_filter)}, limit=${limit}, offset=${offset}`);
-    try {
-        const cplaceFilter = convertSearchFilterToCplaceFormat(search_filter);
-        debugLogWithTag('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('SEARCH', `Final cplace filter: ${JSON.stringify(cplaceFilter)}`);
-        const result = await client.makeApiRequest('json/search', 'GET', {
-            filter: JSON.stringify(cplaceFilter),
-            limit,
-            offset
-        });
-        if (responseFormat === "count") {
-            const countResult = {
-                count: result.pagination?.total || 0
-            };
-            return {
-                content: [{ type: "text", text: JSON.stringify(countResult, null, 2) }]
-            };
-        }
-        const filteredResults = result.results ? result.results.map((item) => filterSearchResult(item, {
-            minimal: responseFormat === "minimal",
-            includeAttributes: responseFormat !== "minimal",
-            includeMetadata: false,
-            attributeFields: attributes,
-            truncateLargeValues: true
-        })) : [];
-        const filteredResult = {
-            results: filteredResults,
-            pagination: {
-                total: result.pagination?.total || 0,
-                limit: result.pagination?.limit || limit,
-                offset: result.pagination?.offset || offset,
-                hasMore: result.pagination?.hasMore || false
-            },
-            humanReadableRepresentation: result.summary
-        };
-        return {
-            content: [{ type: "text", text: JSON.stringify(filteredResult, null, 2) }]
-        };
-    }
-    catch (error) {
-        debugLogWithTag('SEARCH', `Error during search: ${error instanceof Error ? error.message : String(error)}`);
-        return {
-            content: [{ type: "text", text: `Error converting or executing search: ${error instanceof Error ? error.message : String(error)}` }]
-        };
-    }
-});
-server.registerTool("cplace_fulltext_search", {
-    description: "Make a fulltext search across all pages in cplace. Use this only if the user is not asking about specific types.",
-    inputSchema: {
-        workspaceId: z.string().optional().describe("The ID of the workspace to search in. If not provided, searches across all accessible workspaces."),
-        fulltext: z.string().describe("The fulltext search query to filter pages by. The results will include pages that conatin this string in their name, attributes, or content."),
-        limit: z.number().min(1).max(1000).default(50).describe("Maximum number of results to return (1-1000)"),
-        offset: z.number().min(0).max(10000).default(0).describe("Number of results to skip for pagination, cannot be larger than 10000"),
-    },
-    annotations: { title: "Search Pages" }
-}, async ({ workspaceId, fulltext, limit = 50, offset = 0, }) => {
-    if (!fulltext) {
-        return {
-            content: [{ type: "text", text: "fulltext is required" }]
-        };
-    }
-    try {
-        const result = await client.makeApiRequest('json/fulltext-search', 'GET', {
-            spaceId: workspaceId,
-            fulltext: `"${fulltext}"`,
-            limit,
-            offset
-        });
-        const filteredResults = result.results ? result.results.map((item) => filterSearchResult(item, {
-            minimal: false,
-            includeAttributes: true,
-            includeMetadata: false,
-            truncateLargeValues: true
-        })) : [];
-        const filteredResult = {
-            results: filteredResults,
-            pagination: {
-                total: result.pagination?.total || 0,
-                limit: result.pagination?.limit || limit,
-                offset: result.pagination?.offset || offset,
-                hasMore: result.pagination?.hasMore || false
-            },
-            summary: result.summary
-        };
-        return {
-            content: [{ type: "text", text: JSON.stringify(filteredResult, null, 2) }]
-        };
-    }
-    catch (error) {
-        return {
-            content: [{ type: "text", text: `Error converting or executing search: ${error instanceof Error ? error.message : String(error)}` }]
-        };
-    }
-});
-server.registerTool("cplace_get_all_pages_of_type", {
-    description: "Get all pages of a specific type in a workspace in cplace. ONLY use this if you need to retrieve all pages of a type.",
-    inputSchema: {
-        workspaceId: z.string().describe("The ID of the workspace to get pages from"),
-        typeName: z.string().describe("The internal name of the type to retrieve pages for"),
-        limit: z.number().min(1).max(1000).default(50).describe("Maximum number of results to return (1-1000)"),
-        offset: z.number().min(0).max(10000).default(0).describe("Number of results to skip for pagination, cannot be larger than 10000"),
-    },
-    annotations: { title: "Get All Pages of Type" }
-}, async ({ workspaceId, typeName, limit = 50, offset = 0, }) => {
-    try {
-        const cplaceFilter = {
-            filters: [
-                {
-                    type: "Workspace",
-                    workspaceIds: [workspaceId]
-                },
-                {
-                    type: "Type",
-                    types: [typeName]
-                }
-            ]
-        };
-        const result = await client.makeApiRequest('json/search', 'GET', {
-            filter: JSON.stringify(cplaceFilter),
-            limit,
-            offset
-        });
-        const filteredResults = result.results ? result.results.map((item) => filterSearchResult(item, {
-            minimal: false,
-            includeAttributes: true,
-            includeMetadata: false,
-            truncateLargeValues: true
-        })) : [];
-        const filteredResult = {
-            results: filteredResults,
-            pagination: {
-                total: result.pagination?.total || 0,
-                limit: result.pagination?.limit || limit,
-                offset: result.pagination?.offset || offset,
-                hasMore: result.pagination?.hasMore || false
-            },
-            summary: result.summary
-        };
-        return {
-            content: [{ type: "text", text: JSON.stringify(filteredResult, null, 2) }]
-        };
-    }
-    catch (error) {
-        return {
-            content: [{ type: "text", text: `Error retrieving pages: ${error instanceof Error ? error.message : String(error)}` }]
-        };
-    }
-});
-server.registerTool("cplace_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.",
-    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)" }
-}, 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)}` }]
-        };
-    }
-});
-if (config.registerLayoutTools) {
-    server.registerTool("cplace_list_widget_definitions", {
-        description: "Get a list of all available widget definitions in the system with their basic metadata including names, descriptions, and apps",
-        inputSchema: {},
-        annotations: { title: "List Widget Definitions" }
-    }, async () => {
-        debugLogWithTag('WIDGETS', 'Starting widget definitions list request');
-        try {
-            const result = await client.makeApiRequest('json/widget-definitions');
-            debugLogWithTag('WIDGETS', `Retrieved widget definitions`);
-            return {
-                content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-            };
-        }
-        catch (error) {
-            return {
-                content: [{ type: "text", text: `Error retrieving widget definitions: ${error instanceof Error ? error.message : String(error)}` }]
-            };
-        }
-    });
-}
-if (config.registerLayoutTools) {
-    server.registerTool("cplace_get_widget_definition", {
-        description: "Get detailed information about a specific widget definition including its complete configuration schema with all attributes, constraints, and metadata",
-        inputSchema: {
-            widgetKind: z.string().describe("The widget kind identifier (e.g., 'cf.cplace.platform.table', 'cf.platform.wiki')")
-        },
-        annotations: { title: "Get Widget Definition Details" }
-    }, async ({ widgetKind }) => {
-        debugLogWithTag('WIDGETS', `Starting widget definition request for: ${widgetKind}`);
-        try {
-            const result = await client.makeApiRequest('json/widget-definition', 'GET', { widgetKind });
-            debugLogWithTag('WIDGETS', `Retrieved widget definition for: ${widgetKind}`);
-            return {
-                content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-            };
-        }
-        catch (error) {
-            return {
-                content: [{ type: "text", text: `Error retrieving widget definition for ${widgetKind}: ${error instanceof Error ? error.message : String(error)}` }]
-            };
-        }
-    });
-}
-if (config.registerLayoutTools) {
-    server.registerTool("cplace_get_page_layout_overview", {
-        description: "Get the high-level layout structure of a page including rows, columns, and widget summaries. Provides an overview of the page layout grid without detailed widget configurations.",
-        inputSchema: {
-            pageUID: z.string().describe("The unique identifier (UID) of the page to get layout for, e.g. 'page/kkt8ol745jqur4581kelm5ply'")
-        },
-        annotations: { title: "Get Page Layout Overview" }
-    }, async ({ pageUID }) => {
-        debugLogWithTag('LAYOUT', `Starting page layout overview request for: ${pageUID}`);
-        try {
-            const result = await client.makeApiRequest('json/pageLayout', 'GET', { pageUID });
-            const overview = {
-                rows: result.rows?.map((row, rowIndex) => ({
-                    rowIndex,
-                    columns: row.columns?.map((column, colIndex) => ({
-                        columnIndex: colIndex,
-                        proportion: column.proportion,
-                        widgets: column.widgets?.map((widget) => ({
-                            id: widget.id,
-                            widgetType: widget.widgetType,
-                            configurationCount: widget.configuration?.length || 0
-                        })) || []
-                    })) || []
-                })) || []
-            };
-            debugLogWithTag('LAYOUT', `Retrieved layout overview for: ${pageUID}`);
-            return {
-                content: [{ type: "text", text: JSON.stringify(overview, null, 2) }]
-            };
-        }
-        catch (error) {
-            return {
-                content: [{ type: "text", text: `Error retrieving page layout overview for ${pageUID}: ${error instanceof Error ? error.message : String(error)}` }]
-            };
-        }
-    });
-}
-if (config.registerLayoutTools) {
-    server.registerTool("cplace_get_widget_details", {
-        description: "Get detailed configuration for a specific widget within a page layout. Use this after cplace_get_page_layout_overview to examine specific widget configurations.",
-        inputSchema: {
-            pageUID: z.string().describe("The unique identifier (UID) of the page containing the widget"),
-            widgetId: z.string().describe("The unique widget identifier from the layout (e.g., 'id_123', 'id_456')")
-        },
-        annotations: { title: "Get Widget Details" }
-    }, async ({ pageUID, widgetId }) => {
-        debugLogWithTag('LAYOUT', `Starting widget details request for widget ${widgetId} in page ${pageUID}`);
-        try {
-            const result = await client.makeApiRequest('json/pageLayout', 'GET', { pageUID });
-            let foundWidget = null;
-            const findWidget = (rows) => {
-                for (const row of rows || []) {
-                    for (const column of row.columns || []) {
-                        for (const widget of column.widgets || []) {
-                            if (widget.id === widgetId) {
-                                return widget;
-                            }
-                            if (widget.widgetsLayout?.rows) {
-                                const nestedWidget = findWidget(widget.widgetsLayout.rows);
-                                if (nestedWidget)
-                                    return nestedWidget;
-                            }
-                        }
-                    }
-                }
-                return null;
-            };
-            foundWidget = findWidget(result.rows);
-            if (!foundWidget) {
-                return {
-                    content: [{ type: "text", text: `Widget with ID ${widgetId} not found in page ${pageUID}` }]
-                };
-            }
-            debugLogWithTag('LAYOUT', `Retrieved widget details for: ${widgetId}`);
-            return {
-                content: [{ type: "text", text: JSON.stringify(foundWidget, null, 2) }]
-            };
-        }
-        catch (error) {
-            return {
-                content: [{ type: "text", text: `Error retrieving widget details for ${widgetId} in page ${pageUID}: ${error instanceof Error ? error.message : String(error)}` }]
-            };
-        }
-    });
-}
-server.registerTool("cplace_get_current_user", {
-    description: "Get information about the currently logged-in user, including their attributes and metadata",
-    inputSchema: {},
-    annotations: { title: "Get Current User" }
-}, async () => {
-    debugLogWithTag('CURRENT_USER', 'Starting current user request');
-    try {
-        const result = await client.makeApiRequest('json/current-user');
-        debugLogWithTag('CURRENT_USER', `Retrieved current user information`);
-        return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-        };
-    }
-    catch (error) {
-        return {
-            content: [{ type: "text", text: `Error retrieving current user information: ${error instanceof Error ? error.message : String(error)}` }]
-        };
-    }
-});
-server.registerTool("cplace_create_page", {
-    description: "Create a new page with specified attributes and content using the POST /page/create endpoint",
-    inputSchema: {
-        workspaceId: z.string().describe("The ID of the workspace/space to create the page in (e.g., 'workspace/abc123')"),
-        typeInternalName: z.string().describe("The internal name of the page type (e.g., 'cf.example.myType')"),
-        name: z.string().describe("The name of the new page"),
-        parentUID: z.string().optional().describe("The UID of the parent page for hierarchy (optional)"),
-        content: z.string().optional().describe("Wiki markup content for the page (optional)"),
-        attributes: z.record(z.any()).optional().describe(`Custom attribute values as key-value pairs. Supports:
-- String values: "text"
-- Numeric values: 42 or 3.14  
-- Boolean values: true/false
-- Date values: "2024-01-15" or "2024-01-15T10:30:00"
-- Array values: ["value1", "value2"] for multi-valued attributes
-- Reference values: "page/ref123" for page references
-- Localized string values: {"en": "English text", "de": "German text", "fr": "French text"}
-- Multi-valued localized strings: [{"en": "Text 1", "de": "Text 1"}, {"en": "Text 2", "de": "Text 2"}]
-
-The system automatically detects attribute types from the page type definition and handles:
-- Type-aware processing based on actual attribute definitions
-- Proper multiplicity validation (single vs multi-valued)
-- Automatic type conversion and validation
-- Enhanced error messages with attribute-specific details`)
-    },
-    annotations: { title: "Create Page" }
-}, async ({ workspaceId, typeInternalName, name, parentUID, content, attributes }) => {
-    debugLogWithTag('CREATE_PAGE', `Starting page creation: ${name} of type ${typeInternalName} in workspace ${workspaceId}`);
-    try {
-        const requestBody = {
-            workspaceId,
-            typeInternalName,
-            name
-        };
-        if (parentUID) {
-            requestBody.parentUID = parentUID;
-            debugLogWithTag('CREATE_PAGE', `Including parentUID: ${parentUID}`);
-        }
-        if (content) {
-            requestBody.content = content;
-            debugLogWithTag('CREATE_PAGE', `Including content (${content.length} chars)`);
-        }
-        if (attributes && Object.keys(attributes).length > 0) {
-            requestBody.attributes = attributes;
-            debugLogWithTag('CREATE_PAGE', `Including attributes: ${JSON.stringify(Object.keys(attributes))}`);
-        }
-        debugLogWithTag('CREATE_PAGE', `Request body: ${JSON.stringify(requestBody, null, 2)}`);
-        const result = await client.makeApiRequest('json/page/create', 'POST', undefined, requestBody);
-        debugLogWithTag('CREATE_PAGE', `Successfully created page: ${name}`);
-        return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-        };
-    }
-    catch (error) {
-        debugLogWithTag('CREATE_PAGE', `Error creating page: ${error instanceof Error ? error.message : String(error)}`);
-        return {
-            content: [{ type: "text", text: `Error creating page: ${error instanceof Error ? error.message : String(error)}` }]
-        };
-    }
-});
-server.registerTool("cplace_update_page", {
-    description: "Update an existing page's attributes, content, or structure using the PATCH /page/{pageId} endpoint",
-    inputSchema: {
-        pageUID: z.string().describe("The unique identifier (UID) of the page to update"),
-        name: z.string().optional().describe("New name for the page (optional)"),
-        content: z.string().optional().describe("New wiki markup content (optional). Use empty string to remove content."),
-        parentUID: z.string().optional().describe("New parent page UID (optional - for moving pages). Use empty string to remove parent."),
-        attributes: z.record(z.any()).optional().describe(`Custom attributes to update as key-value pairs. Supports:
-- String values: "text"
-- Numeric values: 42 or 3.14
-- Boolean values: true/false  
-- Date values: "2024-01-15" or "2024-01-15T10:30:00"
-- Array values: ["value1", "value2"] for multi-valued attributes
-- Reference values: "page/ref123" for page references
-- Localized string values: {"en": "English text", "de": "German text", "fr": "French text"}
-- Multi-valued localized strings: [{"en": "Text 1", "de": "Text 1"}, {"en": "Text 2", "de": "Text 2"}]
-- Null values: null (removes the attribute value)
-- Empty arrays: [] (removes all values for multi-valued attributes)
-- New attributes: will be added to the page
-
-The system automatically detects attribute types from the page type definition and handles:
-- Type-aware processing based on actual attribute definitions
-- Proper multiplicity validation (single vs multi-valued)
-- Automatic type conversion and validation
-- Enhanced error messages with attribute-specific details`)
-    },
-    annotations: { title: "Update Page" }
-}, async ({ pageUID, name, content, parentUID, attributes }) => {
-    debugLogWithTag('UPDATE_PAGE', `Starting page update for: ${pageUID}`);
-    try {
-        const requestBody = {
-            pageUID
-        };
-        if (name !== undefined) {
-            requestBody.name = name;
-        }
-        if (content !== undefined) {
-            requestBody.content = content;
-        }
-        if (parentUID !== undefined) {
-            requestBody.parentUID = parentUID;
-        }
-        if (attributes && Object.keys(attributes).length > 0) {
-            requestBody.attributes = attributes;
-        }
-        if (Object.keys(requestBody).length === 1) {
-            return {
-                content: [{ type: "text", text: "No updates specified. At least one of name, content, parentId, or attributes must be provided." }]
-            };
-        }
-        const result = await client.makeApiRequest('json/page', 'PATCH', undefined, requestBody);
-        debugLogWithTag('UPDATE_PAGE', `Successfully updated page: ${pageUID}`);
-        return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-        };
-    }
-    catch (error) {
-        debugLogWithTag('UPDATE_PAGE', `Error updating page: ${error instanceof Error ? error.message : String(error)}`);
-        return {
-            content: [{ type: "text", text: `Error updating page: ${error instanceof Error ? error.message : String(error)}` }]
-        };
-    }
-});
-server.registerTool("cplace_update_page_attributes_only", {
-    description: "Lightweight tool for updating only page attributes (no content or structural changes) using the same PATCH /page/{pageId} endpoint",
-    inputSchema: {
-        pageUID: z.string().describe("The unique identifier (UID) of the page to update"),
-        attributes: z.record(z.any()).describe(`Attribute updates as key-value pairs. Supports all the same data types as the full update tool:
-- String values: "text"
-- Numeric values: 42 or 3.14
-- Boolean values: true/false  
-- Date values: "2024-01-15" or "2024-01-15T10:30:00"
-- Array values: ["value1", "value2"] for multi-valued attributes
-- Reference values: "page/ref123" for page references
-- Localized string values: {"en": "English text", "de": "German text", "fr": "French text"}
-- Multi-valued localized strings: [{"en": "Text 1", "de": "Text 1"}, {"en": "Text 2", "de": "Text 2"}]
-- Null values: null (removes the attribute value)
-- Empty arrays: [] (removes all values for multi-valued attributes)
-- New attributes: will be added to the page
-
-The system automatically detects attribute types from the page type definition and handles:
-- Type-aware processing based on actual attribute definitions
-- Proper multiplicity validation (single vs multi-valued)
-- Automatic type conversion and validation
-- Enhanced error messages with attribute-specific details`)
-    },
-    annotations: { title: "Update Page Attributes Only" }
-}, async ({ pageUID, attributes }) => {
-    debugLogWithTag('UPDATE_PAGE_ATTRS', `Starting attribute-only update for: ${pageUID}`);
-    try {
-        if (!attributes || Object.keys(attributes).length === 0) {
-            return {
-                content: [{ type: "text", text: "No attributes specified for update. The attributes parameter must contain at least one attribute." }]
-            };
-        }
-        const requestBody = {
-            pageUID,
-            attributes: attributes
-        };
-        const result = await client.makeApiRequest('json/page', 'PATCH', undefined, requestBody);
-        debugLogWithTag('UPDATE_PAGE_ATTRS', `Successfully updated attributes for page: ${pageUID}`);
-        return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-        };
-    }
-    catch (error) {
-        debugLogWithTag('UPDATE_PAGE_ATTRS', `Error updating page attributes: ${error instanceof Error ? error.message : String(error)}`);
-        return {
-            content: [{ type: "text", text: `Error updating page attributes: ${error instanceof Error ? error.message : String(error)}` }]
-        };
-    }
-});
-if (config.registerLayoutTools) {
-    server.registerTool("cplace_add_widget_to_layout", {
-        description: "Add a new widget to a page layout at a specific position",
-        inputSchema: {
-            pageUID: z.string().describe("The unique identifier (UID) of the page to add the widget to"),
-            widgetType: z.string().describe("The widget type identifier (e.g., 'cf.cplace.platform.table', 'cf.platform.wiki')"),
-            configuration: z.record(z.any()).optional().describe(`Widget-specific configuration object as key-value pairs. IMPORTANT: Check the widget definition schema first to understand required data types:
-- localizedString attributes: use {"en": "English text", "de": "German text"} format
-- boolean attributes: use true/false
-- number attributes: use numeric values
-- string attributes: use simple strings
-
-RECOMMENDED WORKFLOW: 
-1. Use cplace_get_widget_definition() first to understand the configuration schema
-2. Match your configuration values to the constraint types defined in the schema
-3. Use appropriate data formats for each attribute type
-
-Examples: {'title': {'en': 'My Widget', 'de': 'Mein Widget'}, 'showHeader': true, 'height': 600}`),
-            position: z.object({
-                rowIndex: z.number().min(0).describe("Row index in the layout (0-based)"),
-                columnIndex: z.number().min(0).describe("Column index within the row (0-based)"),
-                widgetIndex: z.number().min(0).describe("Widget index within the column (0-based)")
-            }).describe("Grid position where the widget should be added")
-        },
-        annotations: { title: "Add Widget to Layout" }
-    }, async ({ pageUID, widgetType, configuration, position }) => {
-        debugLogWithTag('LAYOUT_MODIFY', `Starting add widget operation: ${widgetType} to page ${pageUID} at position ${JSON.stringify(position)}`);
-        try {
-            const operation = {
-                type: "ADD",
-                widgetType,
-                position: {
-                    rowIndex: position.rowIndex,
-                    columnIndex: position.columnIndex,
-                    widgetIndex: position.widgetIndex
-                }
-            };
-            if (configuration && Object.keys(configuration).length > 0) {
-                operation.configuration = configuration;
-                debugLogWithTag('LAYOUT_MODIFY', `Including configuration: ${JSON.stringify(Object.keys(configuration))}`);
-            }
-            const requestBody = {
-                pageUID,
-                operation
-            };
-            debugLogWithTag('LAYOUT_MODIFY', `Request body: ${JSON.stringify(requestBody, null, 2)}`);
-            const result = await client.makeApiRequest('json/pageLayout', 'PATCH', undefined, requestBody);
-            debugLogWithTag('LAYOUT_MODIFY', `Successfully added widget ${widgetType} to page ${pageUID}`);
-            return {
-                content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-            };
-        }
-        catch (error) {
-            debugLogWithTag('LAYOUT_MODIFY', `Error adding widget: ${error instanceof Error ? error.message : String(error)}`);
-            return {
-                content: [{ type: "text", text: `Error adding widget to layout: ${error instanceof Error ? error.message : String(error)}` }]
-            };
-        }
-    });
-}
-if (config.registerLayoutTools) {
-    server.registerTool("cplace_remove_widget_from_layout", {
-        description: "Remove an existing widget from a page layout",
-        inputSchema: {
-            pageUID: z.string().describe("The unique identifier (UID) of the page containing the widget"),
-            widgetId: z.string().describe("The unique identifier of the widget to remove")
-        },
-        annotations: { title: "Remove Widget from Layout" }
-    }, async ({ pageUID, widgetId }) => {
-        debugLogWithTag('LAYOUT_MODIFY', `Starting remove widget operation: ${widgetId} from page ${pageUID}`);
-        try {
-            const requestBody = {
-                pageUID,
-                operation: {
-                    type: "REMOVE",
-                    widgetId
-                }
-            };
-            debugLogWithTag('LAYOUT_MODIFY', `Request body: ${JSON.stringify(requestBody, null, 2)}`);
-            const result = await client.makeApiRequest('json/pageLayout', 'PATCH', undefined, requestBody);
-            debugLogWithTag('LAYOUT_MODIFY', `Successfully removed widget ${widgetId} from page ${pageUID}`);
-            return {
-                content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-            };
-        }
-        catch (error) {
-            debugLogWithTag('LAYOUT_MODIFY', `Error removing widget: ${error instanceof Error ? error.message : String(error)}`);
-            return {
-                content: [{ type: "text", text: `Error removing widget from layout: ${error instanceof Error ? error.message : String(error)}` }]
-            };
-        }
-    });
-}
-if (config.registerLayoutTools) {
-    server.registerTool("cplace_update_widget_in_layout", {
-        description: "Modify widget configuration or display properties",
-        inputSchema: {
-            pageUID: z.string().describe("The unique identifier (UID) of the page containing the widget"),
-            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). IMPORTANT: Check the widget definition schema first to understand required data types:
-- localizedString attributes: use {"en": "English text", "de": "German text"} format
-- boolean attributes: use true/false
-- number attributes: use numeric values
-- string attributes: use simple strings
-
-RECOMMENDED WORKFLOW: 
-1. Use cplace_get_widget_definition() first to understand the configuration schema
-2. Match your configuration values to the constraint types defined in the schema
-3. Use appropriate data formats for each attribute type
-
-Examples: {'title': {'en': 'My Widget', 'de': 'Mein Widget'}, 'showHeader': true, 'height': 600}`),
-            collapsed: z.boolean().optional().describe("Widget collapse state (optional)")
-        },
-        annotations: { title: "Update Widget in Layout" }
-    }, async ({ pageUID, widgetId, newConfiguration, collapsed }) => {
-        debugLogWithTag('LAYOUT_MODIFY', `Starting update widget operation: ${widgetId} in page ${pageUID}`);
-        try {
-            const operation = {
-                type: "UPDATE",
-                widgetId
-            };
-            if (newConfiguration && Object.keys(newConfiguration).length > 0) {
-                operation.newConfiguration = newConfiguration;
-                debugLogWithTag('LAYOUT_MODIFY', `Including new configuration: ${JSON.stringify(Object.keys(newConfiguration))}`);
-            }
-            if (collapsed !== undefined) {
-                operation.collapsed = collapsed;
-                debugLogWithTag('LAYOUT_MODIFY', `Setting collapsed state to: ${collapsed}`);
-            }
-            if (!operation.newConfiguration && operation.collapsed === undefined) {
-                return {
-                    content: [{ type: "text", text: "No updates specified. At least one of newConfiguration or collapsed must be provided." }]
-                };
-            }
-            const requestBody = {
-                pageUID,
-                operation
-            };
-            debugLogWithTag('LAYOUT_MODIFY', `Request body: ${JSON.stringify(requestBody, null, 2)}`);
-            const result = await client.makeApiRequest('json/pageLayout', 'PATCH', undefined, requestBody);
-            debugLogWithTag('LAYOUT_MODIFY', `Successfully updated widget ${widgetId} in page ${pageUID}`);
-            return {
-                content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-            };
-        }
-        catch (error) {
-            debugLogWithTag('LAYOUT_MODIFY', `Error updating widget: ${error instanceof Error ? error.message : String(error)}`);
-            return {
-                content: [{ type: "text", text: `Error updating widget in layout: ${error instanceof Error ? error.message : String(error)}` }]
-            };
-        }
-    });
-}
-if (config.registerLayoutTools) {
-    server.registerTool("cplace_move_widget_in_layout", {
-        description: "Relocate a widget to a different position in the layout",
-        inputSchema: {
-            pageUID: z.string().describe("The unique identifier (UID) of the page containing the widget"),
-            widgetId: z.string().describe("The unique identifier of the widget to move"),
-            newPosition: z.object({
-                rowIndex: z.number().min(0).describe("Target row index in the layout (0-based)"),
-                columnIndex: z.number().min(0).describe("Target column index within the row (0-based)"),
-                widgetIndex: z.number().min(0).describe("Target widget index within the column (0-based)")
-            }).describe("Target grid position for the widget")
-        },
-        annotations: { title: "Move Widget in Layout" }
-    }, async ({ pageUID, widgetId, newPosition }) => {
-        debugLogWithTag('LAYOUT_MODIFY', `Starting move widget operation: ${widgetId} in page ${pageUID} to position ${JSON.stringify(newPosition)}`);
-        try {
-            const requestBody = {
-                pageUID,
-                operation: {
-                    type: "MOVE",
-                    widgetId,
-                    newPosition: {
-                        rowIndex: newPosition.rowIndex,
-                        columnIndex: newPosition.columnIndex,
-                        widgetIndex: newPosition.widgetIndex
-                    }
-                }
-            };
-            debugLogWithTag('LAYOUT_MODIFY', `Request body: ${JSON.stringify(requestBody, null, 2)}`);
-            const result = await client.makeApiRequest('json/pageLayout', 'PATCH', undefined, requestBody);
-            debugLogWithTag('LAYOUT_MODIFY', `Successfully moved widget ${widgetId} in page ${pageUID}`);
-            return {
-                content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-            };
-        }
-        catch (error) {
-            debugLogWithTag('LAYOUT_MODIFY', `Error moving widget: ${error instanceof Error ? error.message : String(error)}`);
-            return {
-                content: [{ type: "text", text: `Error moving widget in layout: ${error instanceof Error ? error.message : String(error)}` }]
-            };
-        }
-    });
-}
+registerWorkspaceTools(server, client);
+registerPageTools(server, client);
+registerSearchTools(server, client);
+registerUserTools(server, client);
+registerReferenceTools(server, client);
+registerWidgetTools(server, client);
+registerTypeLayoutTools(server, client);
+registerVersionHistoryTools(server, client);
+registerSystemTools(server, config);
 async function runServer() {
     const transport = new StdioServerTransport();
     await server.connect(transport);