@qikdev/mcp 6.6.48 → 6.7.0

package/build/src/tools/definition.js

@@ -0,0 +1,803 @@
+import { ConfigManager } from "../config.js";
+import { getUserSessionData, getAvailableScopes, getScopeTitle } from "./user.js";
+// ============================================================================
+// TOOL DEFINITIONS
+// ============================================================================
+export const getDefinitionSchemaTool = {
+    name: "get_definition_schema",
+    description: "Get the complete schema reference for creating definitions - includes valid field types, widgets, base types, and validation options. Call this before creating definitions to understand what's available.",
+    inputSchema: {
+        type: "object",
+        properties: {},
+    },
+};
+export const searchSimilarDefinitionsTool = {
+    name: "search_similar_definitions",
+    description: "Search existing definitions to find similar content types that might be reused or extended. Use this before creating new definitions to check for existing types.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            query: {
+                type: "string",
+                description: "Natural language description of what you're looking for (e.g., 'inventory tracking', 'product catalog', 'customer records')"
+            },
+            category: {
+                type: "string",
+                description: "Optional category to filter by"
+            }
+        },
+        required: ["query"]
+    },
+};
+export const createDefinitionTool = {
+    name: "create_definition",
+    description: "Create a new content type definition in Qik. Definitions are blueprints that specify the fields, validation rules, and behavior of content you store.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            title: {
+                type: "string",
+                description: "Singular title for the content type (e.g., 'Car Part', 'Supplier', 'Invoice')"
+            },
+            plural: {
+                type: "string",
+                description: "Plural title (e.g., 'Car Parts', 'Suppliers'). Auto-generated if not provided."
+            },
+            definesType: {
+                type: "string",
+                enum: ["article", "submission", "scope", "event", "profile", "email", "integration", "workflowcard", "roster"],
+                description: "The base content type to extend. Use 'article' for most custom content, 'submission' for forms with payments, 'event' for calendar items."
+            },
+            category: {
+                type: "string",
+                description: "Category for organizing in admin menus (e.g., 'Inventory', 'Sales', 'People')"
+            },
+            fields: {
+                type: "array",
+                description: "Array of field definitions",
+                items: {
+                    type: "object",
+                    properties: {
+                        title: { type: "string", description: "Display name for the field" },
+                        key: { type: "string", description: "Database key (camelCase). Auto-generated from title if not provided." },
+                        type: {
+                            type: "string",
+                            enum: ["string", "number", "integer", "boolean", "date", "email", "url", "reference", "object", "group"],
+                            description: "Data type for the field"
+                        },
+                        widget: {
+                            type: "string",
+                            description: "UI widget type (input, textarea, select, button, richtext, datepicker, upload, currency, checkbox, switch, code)"
+                        },
+                        description: { type: "string", description: "Help text shown to users" },
+                        minimum: { type: "number", description: "Minimum required answers. 0 = optional, 1+ = required." },
+                        maximum: { type: "number", description: "Maximum answers allowed. 0 = unlimited, 1 = single value." },
+                        referenceType: { type: "string", description: "For reference fields - the content type key to link to" },
+                        options: {
+                            type: "array",
+                            description: "For select/button widgets - predefined choices",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    title: { type: "string" },
+                                    value: { type: "string" }
+                                }
+                            }
+                        },
+                        defaultValues: {
+                            type: "array",
+                            description: "Default values for the field"
+                        }
+                    },
+                    required: ["title", "type"]
+                }
+            },
+            scope: {
+                type: "string",
+                description: "Scope ID to create the definition in"
+            },
+            defaultScopes: {
+                type: "array",
+                items: { type: "string" },
+                description: "Default scopes for content created with this definition"
+            }
+        },
+        required: ["title", "definesType"]
+    },
+};
+export const updateDefinitionTool = {
+    name: "update_definition",
+    description: "Update an existing definition - add/remove fields, change settings, or modify configuration",
+    inputSchema: {
+        type: "object",
+        properties: {
+            definitionId: {
+                type: "string",
+                description: "The ID of the definition to update"
+            },
+            definitionKey: {
+                type: "string",
+                description: "Alternatively, the key of the definition to update (e.g., 'carPart')"
+            },
+            changes: {
+                type: "object",
+                description: "The changes to apply",
+                properties: {
+                    title: { type: "string", description: "New title" },
+                    plural: { type: "string", description: "New plural title" },
+                    category: { type: "string", description: "New category" },
+                    addFields: {
+                        type: "array",
+                        description: "New fields to add (same format as create_definition fields)"
+                    },
+                    removeFields: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Field keys to remove"
+                    },
+                    updateFields: {
+                        type: "array",
+                        description: "Fields to modify (matched by key)"
+                    }
+                }
+            }
+        },
+        required: ["changes"]
+    },
+};
+export const listDefinitionsTool = {
+    name: "list_definitions",
+    description: "List and search custom definitions (content types) in the platform",
+    inputSchema: {
+        type: "object",
+        properties: {
+            search: {
+                type: "string",
+                description: "Search term to filter definitions by title, key, or description"
+            },
+            definesType: {
+                type: "string",
+                description: "Filter by base type (e.g., 'article', 'submission', 'event')"
+            },
+            category: {
+                type: "string",
+                description: "Filter by category"
+            },
+            includeFields: {
+                type: "boolean",
+                description: "Include field definitions in response (default: false)"
+            },
+            page: {
+                type: "object",
+                description: "Pagination settings",
+                properties: {
+                    size: { type: "number", description: "Items per page (default: 20)" },
+                    index: { type: "number", description: "Page number, 1-based (default: 1)" }
+                }
+            }
+        }
+    },
+};
+// ============================================================================
+// HANDLERS
+// ============================================================================
+export async function handleGetDefinitionSchema() {
+    const schema = {
+        baseTypes: [
+            { key: "article", description: "General content items with title, body, tags. Use for most custom content types." },
+            { key: "submission", description: "Form submissions with payment support, automation, and profile linking." },
+            { key: "event", description: "Calendar events with start/end dates, recurrence, and scheduling." },
+            { key: "profile", description: "People/contacts with name, contact info, address, and relationships." },
+            { key: "scope", description: "Organizational units for multi-tenancy and hierarchical permissions." },
+            { key: "email", description: "Email templates with variables and formatting." },
+            { key: "integration", description: "Third-party service integrations and webhooks." },
+            { key: "workflowcard", description: "Process automation templates with state machines." },
+            { key: "roster", description: "Scheduling and staffing management." }
+        ],
+        fieldTypes: [
+            { type: "string", description: "Basic text", widgets: ["input", "textarea", "select", "button", "richtext", "code"] },
+            { type: "number", description: "Decimal numbers", widgets: ["input", "slider", "currency"] },
+            { type: "integer", description: "Whole numbers", widgets: ["input", "slider"] },
+            { type: "boolean", description: "True/false", widgets: ["checkbox", "switch"] },
+            { type: "date", description: "Date/time values", widgets: ["datepicker", "dateobject"] },
+            { type: "email", description: "Email addresses", widgets: ["input"] },
+            { type: "url", description: "URLs/links", widgets: ["input"] },
+            { type: "reference", description: "Links to other content", widgets: ["select", "button", "upload", "form"] },
+            { type: "object", description: "Complex/nested data", widgets: ["filter", "dateobject", "location"] },
+            { type: "group", description: "Visual field grouping (no data storage)", widgets: null }
+        ],
+        widgetDetails: {
+            input: "Single-line text input",
+            textarea: "Multi-line text area",
+            select: "Dropdown selection",
+            button: "Button-style selection (radio or checkbox)",
+            richtext: "Rich text editor with formatting",
+            code: "Code editor with syntax highlighting",
+            datepicker: "Date and/or time picker",
+            dateobject: "Structured date object with separate fields",
+            upload: "File/image upload",
+            currency: "Currency input with formatting",
+            checkbox: "Checkbox for boolean",
+            switch: "Toggle switch for boolean",
+            slider: "Slider for number ranges",
+            filter: "Complex filter builder",
+            location: "Location/address picker",
+            form: "Embedded form for references"
+        },
+        validationOptions: {
+            minimum: "Minimum required answers (0 = optional, 1+ = required)",
+            maximum: "Maximum answers allowed (0 = unlimited)",
+            minValue: "For numbers - minimum value allowed",
+            maxValue: "For numbers - maximum value allowed",
+            allowedValues: "Restrict to specific values only"
+        },
+        referenceOptions: {
+            referenceType: "Content type key to link to (e.g., 'profile', 'partCategory')",
+            lockFilter: "Filter to restrict which items can be selected",
+            searchable: "Allow searching within reference items"
+        },
+        examples: {
+            simpleTextField: {
+                title: "Name",
+                type: "string",
+                widget: "input",
+                minimum: 1,
+                maximum: 1
+            },
+            optionalTextArea: {
+                title: "Description",
+                type: "string",
+                widget: "textarea",
+                minimum: 0,
+                maximum: 1
+            },
+            currencyField: {
+                title: "Price",
+                type: "number",
+                widget: "currency",
+                minimum: 1
+            },
+            selectField: {
+                title: "Status",
+                type: "string",
+                widget: "select",
+                minimum: 1,
+                options: [
+                    { title: "Active", value: "active" },
+                    { title: "Inactive", value: "inactive" },
+                    { title: "Archived", value: "archived" }
+                ]
+            },
+            referenceField: {
+                title: "Category",
+                type: "reference",
+                widget: "select",
+                referenceType: "category",
+                minimum: 1
+            },
+            dateField: {
+                title: "Due Date",
+                type: "date",
+                widget: "datepicker",
+                minimum: 0
+            }
+        }
+    };
+    return {
+        content: [{
+                type: "text",
+                text: `# Definition Schema Reference
+
+## Base Types
+
+${schema.baseTypes.map(t => `**${t.key}**: ${t.description}`).join('\n')}
+
+## Field Types
+
+${schema.fieldTypes.map(t => `**${t.type}**: ${t.description}${t.widgets ? ` (widgets: ${t.widgets.join(', ')})` : ''}`).join('\n')}
+
+## Widget Details
+
+${Object.entries(schema.widgetDetails).map(([k, v]) => `**${k}**: ${v}`).join('\n')}
+
+## Validation Options
+
+${Object.entries(schema.validationOptions).map(([k, v]) => `**${k}**: ${v}`).join('\n')}
+
+## Reference Field Options
+
+${Object.entries(schema.referenceOptions).map(([k, v]) => `**${k}**: ${v}`).join('\n')}
+
+## Field Examples
+
+\`\`\`json
+${JSON.stringify(schema.examples, null, 2)}
+\`\`\`
+
+---
+Use this schema to construct valid field definitions when calling create_definition.`
+            }]
+    };
+}
+export async function handleSearchSimilarDefinitions(args) {
+    try {
+        const configManager = new ConfigManager();
+        const config = await configManager.loadConfig();
+        if (!config) {
+            throw new Error('Qik MCP server not configured. Run setup first.');
+        }
+        // Fetch all definitions from glossary
+        const response = await fetch(`${config.apiUrl || 'https://api.qik.dev'}/glossary/ai`, {
+            headers: {
+                'Authorization': `Bearer ${config.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const glossary = await response.json();
+        // Filter to only custom definitions (those with definesType set)
+        let definitions = glossary.filter(item => item.definesType);
+        // Filter by category if provided
+        if (args.category) {
+            const categoryLower = args.category.toLowerCase();
+            definitions = definitions.filter(d => d.category && d.category.toLowerCase().includes(categoryLower));
+        }
+        // Search and score by relevance
+        const searchTerms = args.query.toLowerCase().split(/\s+/);
+        const scored = definitions.map(def => {
+            let score = 0;
+            const title = (def.title || '').toLowerCase();
+            const plural = (def.plural || '').toLowerCase();
+            const key = (def.key || '').toLowerCase();
+            const category = (def.category || '').toLowerCase();
+            for (const term of searchTerms) {
+                if (title.includes(term))
+                    score += 10;
+                if (plural.includes(term))
+                    score += 8;
+                if (key.includes(term))
+                    score += 6;
+                if (category.includes(term))
+                    score += 4;
+                // Partial matches
+                if (term.includes(title) || title.includes(term))
+                    score += 2;
+            }
+            return { ...def, score };
+        });
+        // Sort by score and filter out zero scores
+        const matches = scored
+            .filter(d => d.score > 0)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, 10);
+        if (matches.length === 0) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `No existing definitions found matching "${args.query}".
+
+This means you can create a new definition for this purpose. Use create_definition to create one.`
+                    }]
+            };
+        }
+        const resultText = matches.map((def, i) => {
+            return `**${i + 1}. ${def.title}** (${def.plural})
+   Key: \`${def.key}\`
+   Extends: ${def.definesType}
+   Category: ${def.category || 'None'}
+   Relevance: ${Math.round((def.score / 10) * 100)}%`;
+        }).join('\n\n');
+        return {
+            content: [{
+                    type: "text",
+                    text: `# Similar Definitions Found
+
+${resultText}
+
+---
+**Options:**
+- Use an existing definition if it matches your needs
+- Create a new definition if none of these fit
+- Use \`get_content_type_details\` with any key above to see full field details`
+                }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Failed to search definitions: ${error.message}`
+                }]
+        };
+    }
+}
+export async function handleCreateDefinition(args) {
+    try {
+        const configManager = new ConfigManager();
+        const config = await configManager.loadConfig();
+        if (!config) {
+            throw new Error('Qik MCP server not configured. Run setup first.');
+        }
+        // Validate required fields
+        if (!args.title) {
+            return createErrorResponse('Title is required for creating a definition');
+        }
+        if (!args.definesType) {
+            return createErrorResponse('definesType is required. Use "article" for most custom content types.');
+        }
+        // Get user session for permissions
+        const userSession = await getUserSessionData();
+        const createPermission = 'definition.create';
+        const availableScopes = getAvailableScopes(userSession, createPermission);
+        if (availableScopes.length === 0) {
+            return createErrorResponse(`You don't have permission to create definitions. Required permission: ${createPermission}`);
+        }
+        // Handle scope selection
+        const selectedScopeId = args.scope;
+        if (!selectedScopeId && availableScopes.length > 1) {
+            return createScopeSelectionPrompt('definition', availableScopes, userSession);
+        }
+        const targetScopeId = selectedScopeId || availableScopes[0];
+        if (!availableScopes.includes(targetScopeId)) {
+            return createErrorResponse(`Invalid scope "${targetScopeId}". Available scopes: ${availableScopes.map(id => `${getScopeTitle(userSession, id)} (${id})`).join(', ')}`);
+        }
+        // Generate key from title
+        const key = generateKey(args.title);
+        // Build definition payload
+        const definitionPayload = {
+            title: args.title,
+            plural: args.plural || `${args.title}s`,
+            key: key,
+            definesType: args.definesType,
+            category: args.category || '',
+            fields: normalizeFields(args.fields || []),
+            defaultScopes: args.defaultScopes || [],
+            restrictScopes: [],
+            weight: 0,
+            meta: {
+                scopes: [targetScopeId],
+                status: 'active'
+            }
+        };
+        // Create via API
+        const response = await fetch(`${config.apiUrl || 'https://api.qik.dev'}/content/definition/create`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${config.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(definitionPayload)
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`HTTP ${response.status} - ${errorText}`);
+        }
+        const createdDefinition = await response.json();
+        return {
+            content: [{
+                    type: "text",
+                    text: `Successfully created definition "${args.title}"!
+
+**Details:**
+- ID: ${createdDefinition._id}
+- Key: \`${key}\`
+- Base Type: ${args.definesType}
+- Category: ${args.category || 'None'}
+- Fields: ${(args.fields || []).length}
+- Scope: ${getScopeTitle(userSession, targetScopeId)}
+
+**Next Steps:**
+- Create content with: \`create_content\` using typeKey: \`${key}\`
+- View full details: \`get_content_type_details\` with key: \`${key}\`
+- Add more fields: \`update_definition\` with definitionKey: \`${key}\``
+                }]
+        };
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to create definition: ${error.message}`);
+    }
+}
+export async function handleUpdateDefinition(args) {
+    try {
+        const configManager = new ConfigManager();
+        const config = await configManager.loadConfig();
+        if (!config) {
+            throw new Error('Qik MCP server not configured. Run setup first.');
+        }
+        if (!args.changes) {
+            return createErrorResponse('No changes provided');
+        }
+        // Need either definitionId or definitionKey
+        let definitionId = args.definitionId;
+        if (!definitionId && args.definitionKey) {
+            // Look up the definition by key
+            const listResponse = await fetch(`${config.apiUrl || 'https://api.qik.dev'}/content/definition/list`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${config.accessToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    filter: {
+                        operator: 'and',
+                        filters: [
+                            { key: 'key', comparator: 'equal', value: args.definitionKey }
+                        ]
+                    },
+                    page: { size: 1, index: 1 }
+                })
+            });
+            if (!listResponse.ok) {
+                throw new Error(`Failed to find definition: HTTP ${listResponse.status}`);
+            }
+            const listData = await listResponse.json();
+            if (!listData.items || listData.items.length === 0) {
+                return createErrorResponse(`Definition with key "${args.definitionKey}" not found`);
+            }
+            definitionId = listData.items[0]._id;
+        }
+        if (!definitionId) {
+            return createErrorResponse('Either definitionId or definitionKey must be provided');
+        }
+        // First, get the current definition
+        const getResponse = await fetch(`${config.apiUrl || 'https://api.qik.dev'}/content/${definitionId}`, {
+            headers: {
+                'Authorization': `Bearer ${config.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!getResponse.ok) {
+            throw new Error(`Failed to get definition: HTTP ${getResponse.status}`);
+        }
+        const currentDefinition = await getResponse.json();
+        // Build update payload
+        const updatePayload = { ...currentDefinition };
+        if (args.changes.title) {
+            updatePayload.title = args.changes.title;
+        }
+        if (args.changes.plural) {
+            updatePayload.plural = args.changes.plural;
+        }
+        if (args.changes.category) {
+            updatePayload.category = args.changes.category;
+        }
+        // Handle field changes
+        let fields = [...(currentDefinition.fields || [])];
+        // Remove fields
+        if (args.changes.removeFields && args.changes.removeFields.length > 0) {
+            fields = fields.filter(f => !args.changes.removeFields.includes(f.key));
+        }
+        // Update fields
+        if (args.changes.updateFields && args.changes.updateFields.length > 0) {
+            for (const updateField of args.changes.updateFields) {
+                const index = fields.findIndex(f => f.key === updateField.key);
+                if (index !== -1) {
+                    fields[index] = { ...fields[index], ...normalizeField(updateField) };
+                }
+            }
+        }
+        // Add fields
+        if (args.changes.addFields && args.changes.addFields.length > 0) {
+            const normalizedNewFields = args.changes.addFields.map(f => normalizeField(f));
+            fields = [...fields, ...normalizedNewFields];
+        }
+        updatePayload.fields = fields;
+        // Update via API
+        const response = await fetch(`${config.apiUrl || 'https://api.qik.dev'}/content/${definitionId}`, {
+            method: 'PUT',
+            headers: {
+                'Authorization': `Bearer ${config.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(updatePayload)
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`HTTP ${response.status} - ${errorText}`);
+        }
+        const updatedDefinition = await response.json();
+        return {
+            content: [{
+                    type: "text",
+                    text: `Successfully updated definition "${updatedDefinition.title}"!
+
+**Changes Applied:**
+${args.changes.title ? `- Title changed to: ${args.changes.title}` : ''}
+${args.changes.plural ? `- Plural changed to: ${args.changes.plural}` : ''}
+${args.changes.category ? `- Category changed to: ${args.changes.category}` : ''}
+${args.changes.addFields ? `- Added ${args.changes.addFields.length} field(s)` : ''}
+${args.changes.removeFields ? `- Removed ${args.changes.removeFields.length} field(s)` : ''}
+${args.changes.updateFields ? `- Updated ${args.changes.updateFields.length} field(s)` : ''}
+
+**Current Field Count:** ${fields.length}`
+                }]
+        };
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to update definition: ${error.message}`);
+    }
+}
+export async function handleListDefinitions(args) {
+    try {
+        const configManager = new ConfigManager();
+        const config = await configManager.loadConfig();
+        if (!config) {
+            throw new Error('Qik MCP server not configured. Run setup first.');
+        }
+        // Build filter
+        const filters = [];
+        if (args.search) {
+            // Search in title and key
+            filters.push({
+                operator: 'or',
+                filters: [
+                    { key: 'title', comparator: 'contains', value: args.search },
+                    { key: 'key', comparator: 'contains', value: args.search }
+                ]
+            });
+        }
+        if (args.definesType) {
+            filters.push({ key: 'definesType', comparator: 'equal', value: args.definesType });
+        }
+        if (args.category) {
+            filters.push({ key: 'category', comparator: 'contains', value: args.category });
+        }
+        const listPayload = {
+            sort: { key: 'title', direction: 'asc', type: 'string' },
+            page: {
+                size: args.page?.size || 20,
+                index: args.page?.index || 1
+            }
+        };
+        if (filters.length > 0) {
+            listPayload.filter = {
+                operator: 'and',
+                filters: filters
+            };
+        }
+        // Select fields based on includeFields option
+        if (args.includeFields) {
+            listPayload.select = ['_id', 'title', 'plural', 'key', 'definesType', 'category', 'fields', 'meta'];
+        }
+        else {
+            listPayload.select = ['_id', 'title', 'plural', 'key', 'definesType', 'category', 'meta'];
+        }
+        const response = await fetch(`${config.apiUrl || 'https://api.qik.dev'}/content/definition/list`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${config.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(listPayload)
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`HTTP ${response.status} - ${errorText}`);
+        }
+        const results = await response.json();
+        const items = results.items || [];
+        const total = results.total || items.length;
+        const currentPage = args.page?.index || 1;
+        const pageSize = args.page?.size || 20;
+        if (items.length === 0) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `No definitions found matching your criteria.
+
+Use create_definition to create a new content type.`
+                    }]
+            };
+        }
+        let resultText = `# Definitions (${total} total)`;
+        if (total > pageSize) {
+            const totalPages = Math.ceil(total / pageSize);
+            resultText += ` - Page ${currentPage} of ${totalPages}`;
+        }
+        resultText += '\n\n';
+        items.forEach((item, index) => {
+            const itemNumber = ((currentPage - 1) * pageSize) + index + 1;
+            resultText += `**${itemNumber}. ${item.title}** (${item.plural || item.title + 's'})\n`;
+            resultText += `   Key: \`${item.key}\`\n`;
+            resultText += `   Extends: ${item.definesType}\n`;
+            if (item.category) {
+                resultText += `   Category: ${item.category}\n`;
+            }
+            if (args.includeFields && item.fields) {
+                resultText += `   Fields: ${item.fields.length} (${item.fields.slice(0, 3).map((f) => f.title).join(', ')}${item.fields.length > 3 ? '...' : ''})\n`;
+            }
+            resultText += '\n';
+        });
+        if (total > pageSize && currentPage < Math.ceil(total / pageSize)) {
+            resultText += `\nTo see more: use page: { index: ${currentPage + 1} }`;
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: resultText
+                }]
+        };
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to list definitions: ${error.message}`);
+    }
+}
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+function createErrorResponse(message) {
+    return {
+        content: [{
+                type: "text",
+                text: `${message}`
+            }]
+    };
+}
+function createScopeSelectionPrompt(contentType, availableScopes, userSession) {
+    const scopeOptions = availableScopes.map(scopeId => {
+        const title = getScopeTitle(userSession, scopeId);
+        return `- **${title}** (ID: \`${scopeId}\`)`;
+    }).join('\n');
+    return {
+        content: [{
+                type: "text",
+                text: `You can create this ${contentType} in multiple scopes. Please select one:
+
+${scopeOptions}
+
+Call create_definition again with the scope parameter:
+\`\`\`json
+{
+  "title": "Your Title",
+  "definesType": "article",
+  "scope": "scope_id_here"
+}
+\`\`\``
+            }]
+    };
+}
+function generateKey(title) {
+    // Convert "Car Part" to "carPart"
+    return title
+        .toLowerCase()
+        .replace(/[^a-z0-9\s]/g, '')
+        .split(/\s+/)
+        .map((word, i) => i === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1))
+        .join('');
+}
+function normalizeFields(fields) {
+    return fields.map(field => normalizeField(field));
+}
+function normalizeField(field) {
+    return {
+        title: field.title,
+        key: field.key || generateKey(field.title),
+        type: field.type || 'string',
+        widget: field.widget || getDefaultWidget(field.type),
+        description: field.description || '',
+        minimum: field.minimum ?? 0,
+        maximum: field.maximum ?? 1,
+        referenceType: field.referenceType,
+        options: field.options || [],
+        defaultValues: field.defaultValues || [],
+        lockFilter: field.lockFilter,
+        expressions: field.expressions
+    };
+}
+function getDefaultWidget(type) {
+    const defaults = {
+        'string': 'input',
+        'number': 'input',
+        'integer': 'input',
+        'boolean': 'checkbox',
+        'date': 'datepicker',
+        'email': 'input',
+        'url': 'input',
+        'reference': 'select',
+        'object': 'input'
+    };
+    return defaults[type] || 'input';
+}
+//# sourceMappingURL=definition.js.map