@qikdev/mcp 6.7.2 → 6.7.6

package/build/src/tools/create.js

@@ -1,23 +1,47 @@
 import { ConfigManager } from "../config.js";
-import { getUserSessionData, getAvailableScopes, getScopeTitle } from "./user.js";
-import { handleListContent } from "./list.js";
 export const createContentTool = {
     name: "create_content",
-    description: "✨ Create new content items using Qik content types with guided field collection",
+    description: `Create new content items in Qik.
+
+**Endpoint:** POST /content/:typeKey/create
+
+**Required:**
+- typeKey: The content type key (e.g., 'article', 'profile', 'event')
+
+All other properties are passed directly to the API as the create payload.
+
+**Tags Shorthand:**
+Pass \`tags: ['green', 'red']\` as string names and the backend auto-creates tags.
+
+**Scope:**
+Set \`meta.scopes: ['scopeId']\` to specify which scope(s) the content belongs to.
+
+**Example:**
+\`\`\`json
+{
+  "typeKey": "article",
+  "title": "My Article",
+  "tags": ["featured", "news"],
+  "meta": {
+    "scopes": ["scopeId123"]
+  }
+}
+\`\`\``,
     inputSchema: {
         type: "object",
         properties: {
             typeKey: {
                 type: "string",
-                description: "The content type key to create (e.g., 'article', 'incidentReportComment') OR a natural language description (e.g., 'incident report', 'blog post')"
+                description: "The content type key (e.g., 'article', 'profile')"
             },
-            scope: {
-                type: "string",
-                description: "The scope ID to create the content in. If not provided and multiple scopes are available, you'll be prompted to select one."
+            tags: {
+                type: "array",
+                items: { type: "string" },
+                description: "Tag names - backend auto-creates tags and attaches IDs"
             }
         },
         required: ["typeKey"],
-        additionalProperties: true // Allow any additional properties for field values
+        additionalProperties: true
     },
 };
 export async function handleCreateContent(args) {
@@ -27,408 +51,27 @@ export async function handleCreateContent(args) {
         if (!config) {
             throw new Error('Qik MCP server not configured. Run setup first.');
         }
-        // Extract the natural language description
-        const naturalLanguage = args.typeKey;
-        if (!naturalLanguage || typeof naturalLanguage !== 'string') {
-            return createErrorResponse('Please provide a description of what you want to create (e.g., "article", "incident report")');
-        }
-        // STEP 1: Translate natural language to content type
-        // Check if this is a UI/interface creation request first
-        const uiKeywords = ['website', 'web app', 'webapp', 'interface', 'ui', 'user interface', 'site', 'portal', 'blog', 'app'];
-        const isUIRequest = uiKeywords.some(keyword => naturalLanguage.toLowerCase().includes(keyword));
-        if (isUIRequest) {
-            // Extract user arguments (everything except typeKey)
-            const { typeKey, ...userArgs } = args;
-            return await createUICreationSuggestion(naturalLanguage, userArgs);
-        }
-        const contentType = await findContentTypeFromNaturalLanguage(config, naturalLanguage);
-        if (!contentType) {
-            return createErrorResponse(`I couldn't find a content type matching "${naturalLanguage}". Please check available types using get_glossary.`);
-        }
-        // STEP 2: Get user session to check permissions and scopes
-        const userSession = await getUserSessionData();
-        const createPermission = `${contentType.key}.create`;
-        const createParentTypePermission = contentType.definesType ? `${contentType.definesType}.create` : '---';
-        const availableScopesForDefinition = getAvailableScopes(userSession, createPermission);
-        const availableScopesForParentType = getAvailableScopes(userSession, createParentTypePermission);
-        const availableScopes = [
-            ...availableScopesForDefinition,
-            ...availableScopesForParentType
-        ];
-        if (availableScopes.length === 0) {
-            return createErrorResponse(`You don't have permission to create ${contentType.title} content. Required permission: ${createPermission}`);
-        }
-        // STEP 3: Check if we have the create example payload
-        if (!contentType.examples || !contentType.examples.create) {
-            return createErrorResponse(`No create example found for ${contentType.title}. Cannot proceed without API example.`);
-        }
-        // STEP 4: Extract field values from user input (everything except typeKey, scope, scopeId)
-        const { typeKey, scope, scopeId, ...userFieldValues } = args;
-        // STEP 5: Handle scope selection
-        const selectedScopeId = scope || scopeId;
-        // If no scope provided and multiple scopes available, ask user to select
-        if (!selectedScopeId && availableScopes.length > 1) {
-            return createScopeSelectionPrompt(contentType.title, availableScopes, userSession, naturalLanguage);
-        }
-        // Use selected scope or default to first available
-        const targetScopeId = selectedScopeId || availableScopes[0];
-        // Validate the selected scope is actually available
-        if (!availableScopes.includes(targetScopeId)) {
-            return createErrorResponse(`Invalid scope "${targetScopeId}". Available scopes: ${availableScopes.map(id => `${getScopeTitle(userSession, id)} (${id})`).join(', ')}`);
+        const { typeKey, ...payload } = args;
+        if (!typeKey) {
+            throw new Error('typeKey is required');
         }
-        // STEP 6: Build the exact payload using the API example as template
-        const buildResult = await buildExactPayloadFromExample(contentType.examples.create, contentType.fields || [], userFieldValues, targetScopeId, contentType, naturalLanguage);
-        // Check if the result is a reference search response
-        if ('content' in buildResult) {
-            return buildResult;
-        }
-        const { payload, missingFields } = buildResult;
-        // STEP 7: If fields are missing, ask user for them
-        if (missingFields.length > 0) {
-            // Check if any missing fields are reference fields that need special handling
-            const referenceFieldsNeedingHelp = missingFields.filter(field => field.type === 'reference' && !userFieldValues[field.path] && !userFieldValues[field.path.split('.').pop()]);
-            if (referenceFieldsNeedingHelp.length > 0) {
-                return createReferenceFieldPrompt(contentType.title, referenceFieldsNeedingHelp, missingFields, targetScopeId, naturalLanguage);
-            }
-            return createFieldCollectionPrompt(contentType.title, missingFields, contentType.examples.create, targetScopeId, naturalLanguage);
-        }
-        // STEP 8: Create the content using the exact payload
-        const createdContent = await createContentViaAPI(config, payload, contentType.key);
-        return createSuccessResponse(contentType.title, createdContent, getScopeTitle(userSession, targetScopeId));
-    }
-    catch (error) {
-        return createErrorResponse(`Failed to create content: ${error.message}`);
-    }
-}
-// STEP 1: Find content type from natural language
-async function findContentTypeFromNaturalLanguage(config, naturalLanguage) {
-    // Get the glossary index
-    const indexResponse = await fetch(`${config.apiUrl || 'https://api.qik.dev'}/glossary/ai`, {
-        headers: {
-            'Authorization': `Bearer ${config.accessToken}`,
-            'Content-Type': 'application/json',
-        },
-    });
-    if (!indexResponse.ok) {
-        throw new Error(`Failed to fetch glossary: HTTP ${indexResponse.status}`);
-    }
-    const glossary = await indexResponse.json();
-    // Find matching content type
-    const searchTerm = naturalLanguage.toLowerCase().trim();
-    let matchedType = null;
-    // Try exact key match first
-    matchedType = glossary.find(ct => ct.key === searchTerm);
-    // Try fuzzy matching on title, plural, and key
-    if (!matchedType) {
-        matchedType = glossary.find(ct => {
-            const title = (ct.title || '').toLowerCase();
-            const plural = (ct.plural || '').toLowerCase();
-            const key = (ct.key || '').toLowerCase();
-            return title.includes(searchTerm) ||
-                plural.includes(searchTerm) ||
-                key.includes(searchTerm) ||
-                searchTerm.includes(title) ||
-                searchTerm.includes(plural) ||
-                searchTerm.includes(key);
+        const response = await fetch(`${config.apiUrl || 'https://api.qik.dev'}/content/${typeKey}/create`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${config.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(payload)
         });
-    }
-    if (!matchedType) {
-        return null;
-    }
-    // Fetch detailed documentation with examples
-    const detailResponse = await fetch(matchedType.urls.documentation.url, {
-        headers: {
-            'Authorization': `Bearer ${config.accessToken}`,
-            'Content-Type': 'application/json',
-        },
-    });
-    if (!detailResponse.ok) {
-        throw new Error(`Failed to fetch content type details: HTTP ${detailResponse.status}`);
-    }
-    const detailData = await detailResponse.json();
-    return {
-        ...detailData,
-        title: matchedType.title,
-        plural: matchedType.plural,
-        urls: matchedType.urls
-    };
-}
-// STEP 5: Build exact payload using the API example as template
-async function buildExactPayloadFromExample(examplePayload, fields, userValues, defaultScope, contentType, naturalLanguage) {
-    // Start with the structure from the example payload but clear out example values
-    const payload = JSON.parse(JSON.stringify(examplePayload));
-    const missingFields = [];
-    // Clear out all example values, keeping only the structure
-    clearExampleValues(payload, fields);
-    // Set system-managed fields first
-    setValueAtPath(payload, 'meta.scopes', [defaultScope]);
-    // Set default values for fields that have them
-    fields.forEach(field => {
-        if (!field.path || field.readOnly === true || field.type === 'group') {
-            return;
-        }
-        // Apply system defaults for common fields
-        if (field.path === 'meta.status' && field.defaultValues && field.defaultValues.length > 0) {
-            setValueAtPath(payload, field.path, field.defaultValues[0]);
-        }
-        else if (field.path === 'meta.security' && field.defaultValues && field.defaultValues.length > 0) {
-            setValueAtPath(payload, field.path, field.defaultValues[0]);
-        }
-        else if (field.path === 'meta.created' && field.type === 'date') {
-            setValueAtPath(payload, field.path, new Date().toISOString());
-        }
-    });
-    // Apply user-provided values, handling reference fields specially
-    for (const [key, value] of Object.entries(userValues)) {
-        // Try to find the field definition for this key
-        const field = fields.find(f => f.path === key ||
-            f.title === key ||
-            f.path.split('.').pop() === key);
-        if (field && !field.readOnly) {
-            // Handle reference fields that might need search assistance
-            if (field.type === 'reference' && typeof value === 'string' && value.startsWith('search for:')) {
-                // This is a search request for a reference field - we'll handle this in the missing fields check
-                continue;
-            }
-            setValueAtPath(payload, field.path, value);
-        }
-        else {
-            // If no field definition found, try to set it directly
-            setValueAtPath(payload, key, value);
-        }
-    }
-    // Check for required fields that still need values, and handle reference field searches
-    for (const field of fields) {
-        if (!field.path || field.readOnly === true || field.type === 'group') {
-            continue;
-        }
-        // Check if this is a reference field with a search request
-        if (field.type === 'reference') {
-            const userValue = getUserValueForField(userValues, field);
-            if (typeof userValue === 'string' && userValue.startsWith('search for:')) {
-                const searchTerm = userValue.replace('search for:', '').trim();
-                if (searchTerm) {
-                    // Perform the reference search
-                    const referenceResult = await handleReferenceFieldSearch(field, searchTerm, contentType.title, defaultScope, naturalLanguage);
-                    if (referenceResult) {
-                        return referenceResult;
-                    }
-                }
-            }
-        }
-        if (field.required === true) {
-            const currentValue = getValueAtPath(payload, field.path);
-            // If the field is empty/null/undefined, mark as missing
-            if (currentValue === null || currentValue === undefined || currentValue === '') {
-                missingFields.push(field);
-            }
-        }
-    }
-    return { payload, missingFields };
-}
-// Helper function to clear example values while preserving structure
-function clearExampleValues(obj, fields, currentPath = '') {
-    if (obj === null || typeof obj !== 'object') {
-        return;
-    }
-    if (Array.isArray(obj)) {
-        // For arrays, clear them but keep the structure
-        obj.length = 0; // Clear the array but keep it as an array
-        return;
-    }
-    // For objects, recursively clear values
-    for (const key in obj) {
-        const fullPath = currentPath ? `${currentPath}.${key}` : key;
-        if (typeof obj[key] === 'object' && obj[key] !== null && !Array.isArray(obj[key])) {
-            // Recursively clear nested objects
-            clearExampleValues(obj[key], fields, fullPath);
-        }
-        else if (Array.isArray(obj[key])) {
-            // Clear arrays but keep them as arrays
-            obj[key] = [];
-        }
-        else {
-            // Clear primitive values - don't preserve system fields at this stage
-            // We'll set system fields later in the process
-            if (typeof obj[key] === 'string') {
-                obj[key] = undefined;
-            }
-            else if (typeof obj[key] === 'number') {
-                obj[key] = undefined;
-            }
-            else if (typeof obj[key] === 'boolean') {
-                obj[key] = undefined;
-            }
-            else {
-                obj[key] = undefined;
-            }
-        }
-    }
-}
-// Helper function to get value at a specific path
-function getValueAtPath(obj, path) {
-    const parts = path.split('.');
-    let current = obj;
-    for (const part of parts) {
-        if (current === null || current === undefined) {
-            return undefined;
-        }
-        current = current[part];
-    }
-    return current;
-}
-// Get user value for a specific field
-function getUserValueForField(userValues, field) {
-    // Try exact field path first
-    if (userValues[field.path] !== undefined) {
-        return userValues[field.path];
-    }
-    // Try field title
-    if (field.title && userValues[field.title] !== undefined) {
-        return userValues[field.title];
-    }
-    // Try last part of path (e.g., "title" for "meta.title")
-    const pathParts = field.path.split('.');
-    const lastPart = pathParts[pathParts.length - 1];
-    if (userValues[lastPart] !== undefined) {
-        return userValues[lastPart];
-    }
-    return undefined;
-}
-// Set value at specific path in object
-function setValueAtPath(obj, path, value) {
-    const parts = path.split('.');
-    let current = obj;
-    for (let i = 0; i < parts.length - 1; i++) {
-        const part = parts[i];
-        if (!current[part]) {
-            current[part] = {};
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`HTTP ${response.status}: ${errorText}`);
         }
-        current = current[part];
-    }
-    const finalPart = parts[parts.length - 1];
-    current[finalPart] = value;
-}
-// Create content via API
-async function createContentViaAPI(config, payload, contentTypeKey) {
-    const response = await fetch(`${config.apiUrl || 'https://api.qik.dev'}/content/${contentTypeKey}/create`, {
-        method: 'POST',
-        headers: {
-            'Authorization': `Bearer ${config.accessToken}`,
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify(payload)
-    });
-    if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`HTTP ${response.status} - ${errorText}`);
-    }
-    return await response.json();
-}
-// Helper functions for responses
-function createErrorResponse(message) {
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({ error: message }, null, 2)
-            }]
-    };
-}
-function createScopeSelectionPrompt(contentTitle, availableScopes, userSession, naturalLanguage) {
-    const scopeOptions = availableScopes.map(scopeId => ({
-        id: scopeId,
-        title: getScopeTitle(userSession, scopeId)
-    }));
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({
-                    needsScopeSelection: true,
-                    contentTitle,
-                    availableScopes: scopeOptions,
-                    typeKey: naturalLanguage
-                }, null, 2)
-            }]
-    };
-}
-function createFieldCollectionPrompt(contentTitle, missingFields, examplePayload, scopeId, naturalLanguage) {
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({
-                    needsFields: true,
-                    contentTitle,
-                    missingFields: missingFields.map(field => ({
-                        path: field.path,
-                        title: field.title,
-                        type: field.type,
-                        description: field.description,
-                        referenceType: field.referenceType,
-                        options: field.options
-                    })),
-                    typeKey: naturalLanguage || contentTitle.toLowerCase(),
-                    scope: scopeId
-                }, null, 2)
-            }]
-    };
-}
-function createReferenceFieldPrompt(contentTitle, referenceFields, allMissingFields, scopeId, naturalLanguage) {
-    const nonReferenceFields = allMissingFields.filter(field => field.type !== 'reference');
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({
-                    needsReferenceFields: true,
-                    contentTitle,
-                    referenceFields: referenceFields.map(field => ({
-                        path: field.path,
-                        title: field.title,
-                        description: field.description,
-                        referenceType: field.referenceType
-                    })),
-                    otherMissingFields: nonReferenceFields.map(field => ({
-                        path: field.path,
-                        title: field.title,
-                        type: field.type,
-                        description: field.description
-                    })),
-                    typeKey: naturalLanguage || contentTitle.toLowerCase(),
-                    scope: scopeId
-                }, null, 2)
-            }]
-    };
-}
-// Handle reference field search and selection
-async function handleReferenceFieldSearch(field, searchTerm, contentTitle, scopeId, naturalLanguage) {
-    try {
-        if (!field.referenceType) {
-            return {
-                content: [{
-                        type: "text",
-                        text: JSON.stringify({ error: `Cannot search for ${field.path} references - no reference type specified in field definition.` }, null, 2)
-                    }]
-            };
-        }
-        // Use the list function to search for references
-        const listArgs = {
-            typeKey: field.referenceType,
-            search: searchTerm,
-            page: { size: 10, index: 1 }
-        };
-        const searchResults = await handleListContent(listArgs);
+        const data = await response.json();
         return {
             content: [{
                     type: "text",
-                    text: JSON.stringify({
-                        referenceSearch: true,
-                        field: field.path,
-                        fieldTitle: field.title,
-                        referenceType: field.referenceType,
-                        searchTerm,
-                        results: JSON.parse(searchResults.content[0]?.text || '{}'),
-                        typeKey: naturalLanguage,
-                        scope: scopeId
-                    }, null, 2)
+                    text: JSON.stringify(data, null, 2)
                 }]
         };
     }
@@ -436,238 +79,9 @@ async function handleReferenceFieldSearch(field, searchTerm, contentTitle, scope
         return {
             content: [{
                     type: "text",
-                    text: JSON.stringify({ error: `Failed to search for ${field.path} references: ${error.message}` }, null, 2)
+                    text: JSON.stringify({ error: error.message }, null, 2)
                 }]
         };
     }
 }
-async function createUICreationSuggestion(naturalLanguage, userArgs = {}) {
-    // Determine interface type based on keywords
-    let interfaceType = 'website';
-    let description = 'a website interface';
-    if (naturalLanguage.toLowerCase().includes('web app') || naturalLanguage.toLowerCase().includes('webapp') || naturalLanguage.toLowerCase().includes('app')) {
-        interfaceType = 'web-app';
-        description = 'a web application interface';
-    }
-    else if (naturalLanguage.toLowerCase().includes('portal')) {
-        interfaceType = 'portal';
-        description = 'a portal interface';
-    }
-    else if (naturalLanguage.toLowerCase().includes('blog')) {
-        interfaceType = 'blog';
-        description = 'a blog interface';
-    }
-    // Step 1: Initial request - ask guided questions
-    if (!userArgs.interfaceTitle && !userArgs.confirmPayload) {
-        return createInterfaceQuestionPrompt(description, interfaceType, naturalLanguage);
-    }
-    // Step 2: Generate payload from collected information
-    if (userArgs.interfaceTitle && !userArgs.confirmPayload) {
-        const generatedPayload = generateInterfacePayload(userArgs, interfaceType);
-        return createPayloadReviewPrompt(generatedPayload, naturalLanguage, userArgs);
-    }
-    // Step 3: User confirmed payload - create the interface
-    if (userArgs.confirmPayload) {
-        return await handleConfirmedInterfaceCreation(naturalLanguage, userArgs, interfaceType);
-    }
-    // Invalid state
-    return createErrorResponse('Invalid interface creation state. Please start the process again.');
-}
-function createSuccessResponse(contentTitle, createdContent, scopeTitle) {
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify(createdContent, null, 2)
-            }]
-    };
-}
-// Interface creation helper functions
-function createInterfaceQuestionPrompt(description, interfaceType, naturalLanguage) {
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({
-                    needsInterfaceDetails: true,
-                    description,
-                    interfaceType,
-                    typeKey: naturalLanguage,
-                    requiredFields: ['interfaceTitle'],
-                    optionalFields: ['pageCount', 'pages', 'primaryColor']
-                }, null, 2)
-            }]
-    };
-}
-function generateInterfacePayload(args, interfaceType) {
-    const title = args.interfaceTitle || 'New Interface';
-    const pageCount = args.pageCount || 3;
-    const primaryColor = args.primaryColor || '#3570c9';
-    // Generate default pages based on interface type and count
-    let pages = args.pages;
-    if (!pages || !Array.isArray(pages)) {
-        pages = generateDefaultPages(interfaceType, pageCount);
-    }
-    // Basic interface payload structure
-    const payload = {
-        title: title,
-        meta: {
-            scopes: [] // Will be filled by scope selection
-        },
-        seo: {
-            title: `${title} - Default SEO Title`,
-            description: `${title} - Default SEO Description`
-        },
-        menus: [
-            {
-                title: "Primary Menu",
-                name: "primaryMenu",
-                items: pages.map((pageName, index) => ({
-                    title: pageName,
-                    type: "route",
-                    route: index === 0 ? "home" : pageName.toLowerCase().replace(/\s+/g, ''),
-                    url: "",
-                    target: "",
-                    items: []
-                }))
-            },
-            {
-                title: "Footer Menu",
-                name: "footerMenu",
-                items: [
-                    {
-                        title: "Privacy Policy",
-                        type: "route",
-                        route: "privacyPolicy",
-                        url: "",
-                        target: "",
-                        items: []
-                    },
-                    {
-                        title: "Terms and Conditions",
-                        type: "route",
-                        route: "termsAndConditions",
-                        url: "",
-                        target: "",
-                        items: []
-                    }
-                ]
-            }
-        ],
-        services: [],
-        components: [],
-        styles: {
-            pre: `:root {\n    --primary: ${primaryColor};\n    --text: #777;\n    --headings: #222;\n    --outer-width: 1800px;\n    --inner-width: 1400px;\n    --btn-border-radius: 3em;\n}\n\nbody, html {\n    font-size: clamp(13px, 1.5vw, 23px);\n    font-family: 'Poppins', sans-serif;\n    scroll-behavior: smooth;\n    background: #eee;\n    color: var(--text);\n}\n\n@import url('https://fonts.googleapis.com/css2?family=Poppins:ital,wght@0,400;0,700;1,400&display=swap');`,
-            post: `.layout-app {\n    background: #fff;\n    max-width: var(--outer-width);\n    margin: auto;\n    box-shadow: 0 0 15px rgba(0, 0, 0, 0.05);\n}\n\n.v-wrap {\n    padding: 4em 0;\n}\n\n.h-wrap {\n    margin: auto;\n    padding: 0 20px;\n    max-width: var(--inner-width);\n}\n\nh1, h2, h3, h4, h5, h6 {\n    letter-spacing: -0.03em;\n    line-height: 1.2;\n    margin-top: 0;\n    margin-bottom: 0.5em;\n    color: var(--headings);\n}`,
-            includes: [],
-            themes: [
-                {
-                    title: "Primary",
-                    uuid: generateUUID(),
-                    body: `background: var(--primary);\ncolor: #fff;\n\nh1, h2, h3, h4, h5 {\n    color: #fff;\n}`
-                }
-            ]
-        },
-        header: { sections: [] },
-        slots: [],
-        layout: "",
-        routes: pages.map((pageName, index) => ({
-            sections: [],
-            title: pageName,
-            path: index === 0 ? "/" : `/${pageName.toLowerCase().replace(/\s+/g, '-')}`,
-            seo: {
-                title: `${pageName} - ${title}`,
-                description: `${pageName} page for ${title}`,
-                sitemapDisabled: false,
-                sitemapPriority: index === 0 ? "1.0" : "0.5",
-                sitemapChangeFrequency: ""
-            },
-            name: index === 0 ? "home" : pageName.toLowerCase().replace(/\s+/g, ''),
-            type: "route",
-            headerDisabled: false,
-            footerDisabled: false,
-            advancedOptions: false,
-            routes: []
-        })),
-        footer: { sections: [] },
-        usage: [],
-        versioning: { latest: [] }
-    };
-    return payload;
-}
-function generateDefaultPages(interfaceType, pageCount) {
-    const pageTemplates = {
-        website: ['Home', 'About', 'Services', 'Contact', 'Portfolio', 'Blog'],
-        'web-app': ['Dashboard', 'Profile', 'Settings', 'Help', 'Reports', 'Analytics'],
-        portal: ['Dashboard', 'Users', 'Reports', 'Settings', 'Profile', 'Help'],
-        blog: ['Home', 'Articles', 'Categories', 'About', 'Contact', 'Archive']
-    };
-    const template = pageTemplates[interfaceType] || pageTemplates.website;
-    return template.slice(0, Math.max(pageCount, 1));
-}
-function createPayloadReviewPrompt(payload, naturalLanguage, userArgs) {
-    const preview = {
-        title: payload.title,
-        pages: payload.routes.map((route) => ({
-            title: route.title,
-            path: route.path
-        })),
-        primaryColor: payload.styles?.pre?.match(/--primary:\s*([^;]+)/)?.[1] || '#3570c9',
-        menus: payload.menus.map((menu) => ({
-            name: menu.name,
-            items: menu.items.map((item) => item.title)
-        }))
-    };
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({
-                    needsConfirmation: true,
-                    preview,
-                    typeKey: naturalLanguage,
-                    interfaceTitle: userArgs.interfaceTitle
-                }, null, 2)
-            }]
-    };
-}
-function generateUUID() {
-    return Math.random().toString(36).substr(2, 10);
-}
-async function handleConfirmedInterfaceCreation(naturalLanguage, userArgs, interfaceType) {
-    try {
-        const configManager = new ConfigManager();
-        const config = await configManager.loadConfig();
-        if (!config) {
-            throw new Error('Qik MCP server not configured. Run setup first.');
-        }
-        // Generate the interface payload
-        const interfacePayload = generateInterfacePayload(userArgs, interfaceType);
-        // Get user session for scope handling
-        const userSession = await getUserSessionData();
-        // Handle scope selection for interface creation
-        const selectedScopeId = userArgs.scope || userArgs.scopeId;
-        // Get available scopes for interface creation (assuming interface.create permission)
-        const interfaceCreatePermission = 'interface.create';
-        const availableScopes = getAvailableScopes(userSession, interfaceCreatePermission);
-        if (availableScopes.length === 0) {
-            return createErrorResponse(`You don't have permission to create interfaces. Required permission: ${interfaceCreatePermission}`);
-        }
-        // If no scope provided and multiple scopes available, ask user to select
-        if (!selectedScopeId && availableScopes.length > 1) {
-            return createScopeSelectionPrompt('interface', availableScopes, userSession, naturalLanguage);
-        }
-        // Use selected scope or default to first available
-        const targetScopeId = selectedScopeId || availableScopes[0];
-        // Validate the selected scope is actually available
-        if (!availableScopes.includes(targetScopeId)) {
-            return createErrorResponse(`Invalid scope "${targetScopeId}". Available scopes: ${availableScopes.map(id => `${getScopeTitle(userSession, id)} (${id})`).join(', ')}`);
-        }
-        // Set the scope in the payload
-        interfacePayload.meta.scopes = [targetScopeId];
-        // Create the interface using the API
-        const createdInterface = await createContentViaAPI(config, interfacePayload, 'interface');
-        return createSuccessResponse('Interface', createdInterface, getScopeTitle(userSession, targetScopeId));
-    }
-    catch (error) {
-        return createErrorResponse(`Failed to create interface: ${error.message}`);
-    }
-}
 //# sourceMappingURL=create.js.map