@qikdev/mcp 6.7.6 → 6.7.7

package/build/src/tools/workflow.js

@@ -0,0 +1,1047 @@
+import { ConfigManager } from "../config.js";
+import { getUserSessionData, getAvailableScopes, getScopeTitle } from "./user.js";
+// ============================================================================
+// CONSTANTS
+// ============================================================================
+const STEP_COLORS = [
+    '#3B82F6', // Blue
+    '#10B981', // Green
+    '#F59E0B', // Amber
+    '#EF4444', // Red
+    '#8B5CF6', // Purple
+    '#EC4899', // Pink
+    '#06B6D4', // Cyan
+    '#F97316', // Orange
+];
+// ============================================================================
+// TOOL DEFINITIONS
+// ============================================================================
+export const listWorkflowsTool = {
+    name: "list_workflows",
+    description: `List workflow definitions in the platform.
+
+Workflows are kanban-style boards where cards move through steps with automation.
+
+**Example:**
+\`\`\`json
+{ "search": "order" }
+\`\`\`
+
+Returns workflows matching "order" with their IDs and structure summary.`,
+    inputSchema: {
+        type: "object",
+        properties: {
+            search: {
+                type: "string",
+                description: "Search term to filter workflows by title"
+            },
+            category: {
+                type: "string",
+                description: "Filter by category"
+            },
+            page: {
+                type: "object",
+                properties: {
+                    size: { type: "number", description: "Items per page (default: 20)" },
+                    index: { type: "number", description: "Page number, 1-based (default: 1)" }
+                }
+            }
+        }
+    }
+};
+export const getWorkflowTool = {
+    name: "get_workflow",
+    description: `Get full workflow details including all columns, steps, and automation.
+
+**IMPORTANT:** Use this before updating a workflow to understand its current structure.
+
+Returns:
+- Columns with their steps
+- Step configuration (assignees, due dates, requirements)
+- Automation functions (entry, exit, success, fail)
+- Navigation rules (success/failure actions)`,
+    inputSchema: {
+        type: "object",
+        properties: {
+            workflowId: {
+                type: "string",
+                description: "The workflow definition ID"
+            },
+            workflowKey: {
+                type: "string",
+                description: "The workflow key (e.g., 'orderWorkflow')"
+            },
+            workflowTitle: {
+                type: "string",
+                description: "Search by workflow title"
+            }
+        }
+    }
+};
+export const createWorkflowTool = {
+    name: "create_workflow",
+    description: `Create a new workflow definition.
+
+A workflow is a kanban board with columns and steps. Cards move through steps based on completion criteria and automated actions.
+
+## Workflow Structure
+
+\`\`\`json
+{
+  "title": "Order Processing",
+  "category": "Operations",
+  "workflow": [
+    {
+      "title": "Column Name",
+      "description": "Optional description",
+      "steps": [
+        {
+          "title": "Step Name",
+          "key": "uniqueStepKey",
+          "color": "#3B82F6",
+          "description": "Help text for users",
+
+          "assignees": [],
+          "assigneeBehaviour": "",
+
+          "dueDateBehaviour": "period",
+          "dueDateQuantity": 3,
+          "dueDateUnit": "days",
+
+          "hasRequiredTasks": true,
+          "requireTasks": [{ "title": "Review application" }],
+
+          "completionWhen": "immediate",
+
+          "successFunctions": [
+            { "action": "addTag", "title": "Mark processed", "tag": "processed" }
+          ],
+
+          "successAction": "next",
+          "failureAction": "step",
+          "failureTargetStep": "rejected"
+        }
+      ]
+    }
+  ]
+}
+\`\`\`
+
+## Step Properties
+
+**Assignees:**
+- \`assignees\`: Array of profile IDs to auto-assign
+- \`assigneeBehaviour\`: "" (replace), "leave" (keep existing), "remove" (clear all)
+
+**Due Dates:**
+- \`dueDateBehaviour\`: "" (none), "period" (relative), "point" (fixed time)
+- \`dueDateQuantity\`: Number (e.g., 3)
+- \`dueDateUnit\`: "minutes", "hours", "days", "weeks"
+
+**Requirements:**
+- \`hasRequiredTasks\`: true/false
+- \`requireTasks\`: [{ title, description }]
+- \`hasRequiredForms\`: true/false (requires form submission)
+- \`hasRequiredCriteria\`: true/false (requires filter match)
+
+**Automation Timing:**
+- \`completionWhen\`: "" (manual), "immediate" (auto when done), "wait" (at due date)
+
+**Automation Functions:**
+- \`entryFunctions\`: Run when card enters step
+- \`exitFunctions\`: Run when card leaves step
+- \`successFunctions\`: Run on successful completion
+- \`failFunctions\`: Run on failure
+
+**Navigation:**
+- \`successAction\`: "next", "previous", "step", "archive"
+- \`successTargetStep\`: Step key if successAction="step"
+- \`failureAction\`: Same options
+- \`failureTargetStep\`: Step key if failureAction="step"
+
+## Function Types
+
+**addTag** - Add a tag to the card
+\`\`\`json
+{ "action": "addTag", "title": "Description", "tag": "tagName" }
+\`\`\`
+
+**removeTag** - Remove a tag
+\`\`\`json
+{ "action": "removeTag", "title": "Description", "tag": "tagName" }
+\`\`\`
+
+**email** - Send email notification
+\`\`\`json
+{ "action": "email", "title": "Description", "to": "assignees" }
+\`\`\`
+
+**sms** - Send SMS
+\`\`\`json
+{ "action": "sms", "title": "Description", "to": "assignees", "message": "Text" }
+\`\`\`
+
+**update** - Update card/profile fields
+\`\`\`json
+{ "action": "update", "title": "Description", "target": "card", "data": { "fieldKey": "value" } }
+\`\`\`
+
+## Common Patterns
+
+**Simple Order Flow:**
+\`\`\`json
+{
+  "workflow": [
+    { "title": "New", "steps": [{ "title": "Order Received" }] },
+    { "title": "Processing", "steps": [{ "title": "Preparing" }] },
+    { "title": "Complete", "steps": [{ "title": "Ready", "successAction": "archive" }] }
+  ]
+}
+\`\`\`
+
+**Approval Flow:**
+\`\`\`json
+{
+  "workflow": [
+    { "title": "Submitted", "steps": [{ "title": "New Application" }] },
+    { "title": "Review", "steps": [{ "title": "Under Review", "hasRequiredTasks": true, "requireTasks": [{ "title": "Review documents" }] }] },
+    { "title": "Decision", "steps": [{ "title": "Approved", "successFunctions": [{ "action": "addTag", "tag": "approved" }] }, { "title": "Rejected" }] }
+  ]
+}
+\`\`\``,
+    inputSchema: {
+        type: "object",
+        properties: {
+            title: {
+                type: "string",
+                description: "Workflow name (e.g., 'Food Order Workflow')"
+            },
+            plural: {
+                type: "string",
+                description: "Plural name (auto-generated if not provided)"
+            },
+            category: {
+                type: "string",
+                description: "Category for organization (e.g., 'Operations')"
+            },
+            workflow: {
+                type: "array",
+                description: "Array of columns, each containing steps",
+                items: {
+                    type: "object",
+                    properties: {
+                        title: { type: "string" },
+                        description: { type: "string" },
+                        steps: { type: "array" }
+                    },
+                    required: ["title", "steps"]
+                }
+            },
+            scope: {
+                type: "string",
+                description: "Scope ID to create the workflow in"
+            }
+        },
+        required: ["title", "workflow"]
+    }
+};
+export const updateWorkflowTool = {
+    name: "update_workflow",
+    description: `Update an existing workflow definition.
+
+**IMPORTANT:** Use get_workflow first to see the current structure before making changes.
+
+## Update Operations
+
+**Add a column:**
+\`\`\`json
+{
+  "workflowId": "...",
+  "addColumns": [{ "title": "Archive", "steps": [{ "title": "Archived" }] }]
+}
+\`\`\`
+
+**Add a step to existing column:**
+\`\`\`json
+{
+  "workflowId": "...",
+  "addSteps": [{ "columnTitle": "Processing", "step": { "title": "Quality Check" } }]
+}
+\`\`\`
+
+**Modify a step:**
+\`\`\`json
+{
+  "workflowId": "...",
+  "updateSteps": [{
+    "stepKey": "newOrder",
+    "changes": {
+      "title": "New Order Received",
+      "successFunctions": [{ "action": "addTag", "tag": "received" }]
+    }
+  }]
+}
+\`\`\`
+
+**Remove a step:**
+\`\`\`json
+{
+  "workflowId": "...",
+  "removeSteps": ["oldStepKey"]
+}
+\`\`\`
+
+**Add automation to a step:**
+\`\`\`json
+{
+  "workflowId": "...",
+  "updateSteps": [{
+    "stepKey": "approved",
+    "changes": {
+      "successFunctions": [
+        { "action": "addTag", "title": "Add confirmed tag", "tag": "confirmed" }
+      ]
+    }
+  }]
+}
+\`\`\`
+
+**Change navigation:**
+\`\`\`json
+{
+  "workflowId": "...",
+  "updateSteps": [{
+    "stepKey": "review",
+    "changes": {
+      "successAction": "step",
+      "successTargetStep": "approved",
+      "failureAction": "step",
+      "failureTargetStep": "rejected"
+    }
+  }]
+}
+\`\`\``,
+    inputSchema: {
+        type: "object",
+        properties: {
+            workflowId: {
+                type: "string",
+                description: "The workflow definition ID"
+            },
+            workflowKey: {
+                type: "string",
+                description: "The workflow key"
+            },
+            workflowTitle: {
+                type: "string",
+                description: "Search by workflow title"
+            },
+            title: {
+                type: "string",
+                description: "New title for the workflow"
+            },
+            category: {
+                type: "string",
+                description: "New category"
+            },
+            addColumns: {
+                type: "array",
+                description: "New columns to add",
+                items: {
+                    type: "object",
+                    properties: {
+                        title: { type: "string" },
+                        description: { type: "string" },
+                        steps: { type: "array" },
+                        insertAfter: { type: "string", description: "Column title to insert after" }
+                    }
+                }
+            },
+            removeColumns: {
+                type: "array",
+                items: { type: "string" },
+                description: "Column titles to remove"
+            },
+            addSteps: {
+                type: "array",
+                description: "Steps to add to existing columns",
+                items: {
+                    type: "object",
+                    properties: {
+                        columnTitle: { type: "string", description: "Column to add step to" },
+                        step: { type: "object", description: "Step configuration" },
+                        insertAfter: { type: "string", description: "Step key to insert after" }
+                    }
+                }
+            },
+            removeSteps: {
+                type: "array",
+                items: { type: "string" },
+                description: "Step keys to remove"
+            },
+            updateSteps: {
+                type: "array",
+                description: "Steps to modify",
+                items: {
+                    type: "object",
+                    properties: {
+                        stepKey: { type: "string", description: "Key of step to update" },
+                        changes: { type: "object", description: "Fields to update" }
+                    }
+                }
+            }
+        }
+    }
+};
+// ============================================================================
+// HANDLERS
+// ============================================================================
+export async function handleListWorkflows(args) {
+    try {
+        const configManager = new ConfigManager();
+        const config = await configManager.loadConfig();
+        if (!config) {
+            throw new Error('Qik MCP server not configured. Run setup first.');
+        }
+        const filters = [
+            { key: 'definesType', comparator: 'equal', value: 'workflowcard' }
+        ];
+        if (args.search) {
+            filters.push({
+                operator: 'or',
+                filters: [
+                    { key: 'title', comparator: 'contains', value: args.search },
+                    { key: 'key', comparator: 'contains', value: args.search }
+                ]
+            });
+        }
+        if (args.category) {
+            filters.push({ key: 'category', comparator: 'contains', value: args.category });
+        }
+        const listPayload = {
+            filter: { operator: 'and', filters },
+            sort: { key: 'title', direction: 'asc', type: 'string' },
+            page: {
+                size: args.page?.size || 20,
+                index: args.page?.index || 1
+            },
+            select: ['_id', 'title', 'plural', 'key', 'category', 'workflow', '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) {
+            const searchNote = args.search ? ` matching "${args.search}"` : '';
+            return {
+                content: [{
+                        type: "text",
+                        text: `No workflows found${searchNote}.`
+                    }]
+            };
+        }
+        let resultText = `# Workflows (${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;
+            const columnCount = item.workflow?.length || 0;
+            const stepCount = item.workflow?.reduce((acc, col) => acc + (col.steps?.length || 0), 0) || 0;
+            resultText += `**${itemNumber}. ${item.title}**\n`;
+            resultText += `   ID: \`${item._id}\`\n`;
+            resultText += `   Key: \`${item.key}\`\n`;
+            if (item.category) {
+                resultText += `   Category: ${item.category}\n`;
+            }
+            resultText += `   Structure: ${columnCount} columns, ${stepCount} steps\n\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 {
+            content: [{
+                    type: "text",
+                    text: `Failed to list workflows: ${error.message}`
+                }]
+        };
+    }
+}
+export async function handleGetWorkflow(args) {
+    try {
+        const configManager = new ConfigManager();
+        const config = await configManager.loadConfig();
+        if (!config) {
+            throw new Error('Qik MCP server not configured. Run setup first.');
+        }
+        let workflowId = args.workflowId;
+        // Resolve ID from key or title
+        if (!workflowId && (args.workflowKey || args.workflowTitle)) {
+            const searchFilters = [
+                { key: 'definesType', comparator: 'equal', value: 'workflowcard' }
+            ];
+            if (args.workflowKey) {
+                searchFilters.push({ key: 'key', comparator: 'equal', value: args.workflowKey });
+            }
+            else if (args.workflowTitle) {
+                searchFilters.push({ key: 'title', comparator: 'contains', value: args.workflowTitle });
+            }
+            const searchResponse = 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: searchFilters },
+                    page: { size: 1, index: 1 },
+                    select: ['_id', 'title']
+                })
+            });
+            if (!searchResponse.ok) {
+                throw new Error(`HTTP ${searchResponse.status}: ${await searchResponse.text()}`);
+            }
+            const searchResults = await searchResponse.json();
+            if (!searchResults.items?.length) {
+                const searchTerm = args.workflowKey || args.workflowTitle;
+                return {
+                    content: [{
+                            type: "text",
+                            text: `No workflow found matching "${searchTerm}"`
+                        }]
+                };
+            }
+            workflowId = searchResults.items[0]._id;
+        }
+        if (!workflowId) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Please provide workflowId, workflowKey, or workflowTitle`
+                    }]
+            };
+        }
+        const response = await fetch(`${config.apiUrl || 'https://api.qik.dev'}/content/${workflowId}`, {
+            headers: {
+                'Authorization': `Bearer ${config.accessToken}`,
+                'Content-Type': 'application/json',
+            }
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+        }
+        const workflow = await response.json();
+        let resultText = `# Workflow: ${workflow.title}\n\n`;
+        resultText += `**ID:** \`${workflow._id}\`\n`;
+        resultText += `**Key:** \`${workflow.key}\`\n`;
+        if (workflow.category) {
+            resultText += `**Category:** ${workflow.category}\n`;
+        }
+        resultText += '\n---\n';
+        resultText += formatWorkflowForDisplay(workflow.workflow || []);
+        resultText += '\n---\n\n## Raw Structure\n\n';
+        resultText += '```json\n' + JSON.stringify(workflow.workflow, null, 2) + '\n```';
+        return {
+            content: [{
+                    type: "text",
+                    text: resultText
+                }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Failed to get workflow: ${error.message}`
+                }]
+        };
+    }
+}
+export async function handleCreateWorkflow(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.title) {
+            return createErrorResponse('Title is required');
+        }
+        if (!args.workflow || args.workflow.length === 0) {
+            return createErrorResponse('Workflow must have at least one column');
+        }
+        // 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.`);
+        }
+        const selectedScopeId = args.scope;
+        if (!selectedScopeId && availableScopes.length > 1) {
+            return createScopeSelectionPrompt('workflow', availableScopes, userSession);
+        }
+        const targetScopeId = selectedScopeId || availableScopes[0];
+        if (!availableScopes.includes(targetScopeId)) {
+            return createErrorResponse(`Invalid scope "${targetScopeId}".`);
+        }
+        // Normalize and validate workflow
+        const normalizedWorkflow = normalizeWorkflow(args.workflow);
+        const validation = validateWorkflow(normalizedWorkflow);
+        if (!validation.valid) {
+            return createErrorResponse(`Invalid workflow structure:\n- ${validation.errors.join('\n- ')}`);
+        }
+        // Generate key from title
+        const key = generateKey(args.title);
+        const definitionPayload = {
+            title: args.title,
+            plural: args.plural || `${args.title}s`,
+            key: key,
+            definesType: 'workflowcard',
+            category: args.category || '',
+            workflow: normalizedWorkflow,
+            fields: [],
+            defaultScopes: [],
+            restrictScopes: [],
+            weight: 0,
+            meta: {
+                scopes: [targetScopeId],
+                status: 'active'
+            }
+        };
+        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 created = await response.json();
+        const columnCount = normalizedWorkflow.length;
+        const stepCount = normalizedWorkflow.reduce((acc, col) => acc + col.steps.length, 0);
+        return {
+            content: [{
+                    type: "text",
+                    text: `# Workflow Created Successfully!
+
+**Title:** ${args.title}
+**ID:** \`${created._id}\`
+**Key:** \`${key}\`
+**Category:** ${args.category || 'None'}
+**Structure:** ${columnCount} columns, ${stepCount} steps
+**Scope:** ${getScopeTitle(userSession, targetScopeId)}
+
+## Structure Overview
+${formatWorkflowForDisplay(normalizedWorkflow)}`
+                }]
+        };
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to create workflow: ${error.message}`);
+    }
+}
+export async function handleUpdateWorkflow(args) {
+    try {
+        const configManager = new ConfigManager();
+        const config = await configManager.loadConfig();
+        if (!config) {
+            throw new Error('Qik MCP server not configured. Run setup first.');
+        }
+        // Resolve workflow ID
+        let workflowId = args.workflowId;
+        if (!workflowId && (args.workflowKey || args.workflowTitle)) {
+            const searchFilters = [
+                { key: 'definesType', comparator: 'equal', value: 'workflowcard' }
+            ];
+            if (args.workflowKey) {
+                searchFilters.push({ key: 'key', comparator: 'equal', value: args.workflowKey });
+            }
+            else if (args.workflowTitle) {
+                searchFilters.push({ key: 'title', comparator: 'contains', value: args.workflowTitle });
+            }
+            const searchResponse = 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: searchFilters },
+                    page: { size: 1, index: 1 }
+                })
+            });
+            if (!searchResponse.ok) {
+                throw new Error(`HTTP ${searchResponse.status}`);
+            }
+            const searchResults = await searchResponse.json();
+            if (!searchResults.items?.length) {
+                return createErrorResponse(`No workflow found matching "${args.workflowKey || args.workflowTitle}"`);
+            }
+            workflowId = searchResults.items[0]._id;
+        }
+        if (!workflowId) {
+            return createErrorResponse('Please provide workflowId, workflowKey, or workflowTitle');
+        }
+        // Fetch current workflow
+        const getResponse = await fetch(`${config.apiUrl || 'https://api.qik.dev'}/content/${workflowId}`, {
+            headers: {
+                'Authorization': `Bearer ${config.accessToken}`,
+                'Content-Type': 'application/json',
+            }
+        });
+        if (!getResponse.ok) {
+            throw new Error(`HTTP ${getResponse.status}`);
+        }
+        const current = await getResponse.json();
+        let workflow = [...(current.workflow || [])];
+        const changes = [];
+        // Update title/category
+        if (args.title) {
+            current.title = args.title;
+            changes.push(`Title changed to "${args.title}"`);
+        }
+        if (args.category) {
+            current.category = args.category;
+            changes.push(`Category changed to "${args.category}"`);
+        }
+        // Remove columns
+        if (args.removeColumns?.length) {
+            const originalCount = workflow.length;
+            workflow = workflow.filter(col => !args.removeColumns.includes(col.title));
+            changes.push(`Removed ${originalCount - workflow.length} column(s)`);
+        }
+        // Remove steps
+        if (args.removeSteps?.length) {
+            let removedCount = 0;
+            workflow = workflow.map(col => ({
+                ...col,
+                steps: col.steps.filter(step => {
+                    if (args.removeSteps.includes(step.key)) {
+                        removedCount++;
+                        return false;
+                    }
+                    return true;
+                })
+            }));
+            changes.push(`Removed ${removedCount} step(s)`);
+        }
+        // Update steps
+        if (args.updateSteps?.length) {
+            for (const update of args.updateSteps) {
+                for (const col of workflow) {
+                    const stepIndex = col.steps.findIndex(s => s.key === update.stepKey);
+                    if (stepIndex !== -1) {
+                        col.steps[stepIndex] = { ...col.steps[stepIndex], ...update.changes };
+                        changes.push(`Updated step "${update.stepKey}"`);
+                        break;
+                    }
+                }
+            }
+        }
+        // Add columns
+        if (args.addColumns?.length) {
+            const existingKeys = getAllStepKeys(workflow);
+            for (const newCol of args.addColumns) {
+                const normalizedSteps = newCol.steps.map((step, i) => normalizeStep(step, existingKeys, workflow.length * 10 + i));
+                const column = {
+                    title: newCol.title,
+                    description: newCol.description || '',
+                    steps: normalizedSteps
+                };
+                if (newCol.insertAfter) {
+                    const insertIndex = workflow.findIndex(c => c.title === newCol.insertAfter);
+                    if (insertIndex !== -1) {
+                        workflow.splice(insertIndex + 1, 0, column);
+                    }
+                    else {
+                        workflow.push(column);
+                    }
+                }
+                else {
+                    workflow.push(column);
+                }
+                changes.push(`Added column "${newCol.title}"`);
+            }
+        }
+        // Add steps
+        if (args.addSteps?.length) {
+            const existingKeys = getAllStepKeys(workflow);
+            for (const addStep of args.addSteps) {
+                const column = workflow.find(c => c.title === addStep.columnTitle);
+                if (column) {
+                    const normalizedStep = normalizeStep(addStep.step, existingKeys, column.steps.length);
+                    if (addStep.insertAfter) {
+                        const insertIndex = column.steps.findIndex(s => s.key === addStep.insertAfter);
+                        if (insertIndex !== -1) {
+                            column.steps.splice(insertIndex + 1, 0, normalizedStep);
+                        }
+                        else {
+                            column.steps.push(normalizedStep);
+                        }
+                    }
+                    else {
+                        column.steps.push(normalizedStep);
+                    }
+                    changes.push(`Added step "${normalizedStep.title}" to "${column.title}"`);
+                }
+                else {
+                    changes.push(`Warning: Column "${addStep.columnTitle}" not found`);
+                }
+            }
+        }
+        // Validate final structure
+        const validation = validateWorkflow(workflow);
+        if (!validation.valid) {
+            return createErrorResponse(`Invalid workflow structure after changes:\n- ${validation.errors.join('\n- ')}`);
+        }
+        // Update
+        current.workflow = workflow;
+        const updateResponse = await fetch(`${config.apiUrl || 'https://api.qik.dev'}/content/${workflowId}`, {
+            method: 'PUT',
+            headers: {
+                'Authorization': `Bearer ${config.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(current)
+        });
+        if (!updateResponse.ok) {
+            const errorText = await updateResponse.text();
+            throw new Error(`HTTP ${updateResponse.status} - ${errorText}`);
+        }
+        const columnCount = workflow.length;
+        const stepCount = workflow.reduce((acc, col) => acc + col.steps.length, 0);
+        return {
+            content: [{
+                    type: "text",
+                    text: `# Workflow Updated Successfully!
+
+**Title:** ${current.title}
+**ID:** \`${workflowId}\`
+**Structure:** ${columnCount} columns, ${stepCount} steps
+
+## Changes Made
+${changes.map(c => `- ${c}`).join('\n')}
+
+## Current Structure
+${formatWorkflowForDisplay(workflow)}`
+                }]
+        };
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to update workflow: ${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_workflow again with the scope parameter.`
+            }]
+    };
+}
+function generateKey(title) {
+    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('') + 'Workflow';
+}
+function generateStepKey(title, existingKeys) {
+    let key = title
+        .toLowerCase()
+        .replace(/[^a-z0-9\s]/g, '')
+        .split(/\s+/)
+        .map((word, i) => i === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1))
+        .join('');
+    let finalKey = key;
+    let counter = 1;
+    while (existingKeys.includes(finalKey)) {
+        finalKey = `${key}${counter}`;
+        counter++;
+    }
+    existingKeys.push(finalKey);
+    return finalKey;
+}
+function normalizeStep(step, existingKeys, colorIndex) {
+    const key = step.key || generateStepKey(step.title, existingKeys);
+    return {
+        title: step.title,
+        key,
+        color: step.color || STEP_COLORS[colorIndex % STEP_COLORS.length],
+        description: step.description || '',
+        assignees: step.assignees || [],
+        assigneeBehaviour: step.assigneeBehaviour || '',
+        dueDateBehaviour: step.dueDateBehaviour || '',
+        dueDateQuantity: step.dueDateQuantity || 0,
+        dueDateUnit: step.dueDateUnit || 'days',
+        dueDateReplacement: step.dueDateReplacement || '',
+        hasRequiredTasks: step.hasRequiredTasks || false,
+        requireTasks: step.requireTasks || [],
+        hasRequiredForms: step.hasRequiredForms || false,
+        requireForms: step.requireForms || [],
+        hasRequiredCriteria: step.hasRequiredCriteria || false,
+        completionCriteria: step.completionCriteria || [],
+        completionWhen: step.completionWhen || '',
+        entryFunctions: step.entryFunctions || [],
+        exitFunctions: step.exitFunctions || [],
+        successFunctions: step.successFunctions || [],
+        failFunctions: step.failFunctions || [],
+        successAction: step.successAction || 'next',
+        successTargetStep: step.successTargetStep || '',
+        failureAction: step.failureAction || '',
+        failureTargetStep: step.failureTargetStep || ''
+    };
+}
+function normalizeWorkflow(workflow) {
+    const existingKeys = [];
+    let colorIndex = 0;
+    return workflow.map(column => ({
+        title: column.title,
+        description: column.description || '',
+        steps: (column.steps || []).map((step) => {
+            const normalized = normalizeStep(step, existingKeys, colorIndex);
+            colorIndex++;
+            return normalized;
+        })
+    }));
+}
+function getAllStepKeys(workflow) {
+    const keys = [];
+    for (const col of workflow) {
+        for (const step of col.steps) {
+            if (step.key)
+                keys.push(step.key);
+        }
+    }
+    return keys;
+}
+function formatWorkflowForDisplay(workflow) {
+    let output = '';
+    workflow.forEach((column, colIndex) => {
+        output += `\n## Column ${colIndex + 1}: ${column.title}\n`;
+        if (column.description) {
+            output += `_${column.description}_\n`;
+        }
+        column.steps.forEach((step, stepIndex) => {
+            output += `\n### ${colIndex + 1}.${stepIndex + 1} ${step.title}\n`;
+            output += `- Key: \`${step.key}\`\n`;
+            if (step.dueDateBehaviour === 'period' && step.dueDateQuantity) {
+                output += `- Due: ${step.dueDateQuantity} ${step.dueDateUnit} after entry\n`;
+            }
+            if (step.hasRequiredTasks && step.requireTasks?.length) {
+                output += `- Required tasks: ${step.requireTasks.map(t => t.title).join(', ')}\n`;
+            }
+            const functions = [
+                step.entryFunctions?.length ? `entry: ${step.entryFunctions.length}` : null,
+                step.exitFunctions?.length ? `exit: ${step.exitFunctions.length}` : null,
+                step.successFunctions?.length ? `success: ${step.successFunctions.length}` : null,
+                step.failFunctions?.length ? `fail: ${step.failFunctions.length}` : null
+            ].filter(Boolean);
+            if (functions.length) {
+                output += `- Automation: ${functions.join(', ')}\n`;
+            }
+            output += `- On success: ${step.successAction || 'next'}`;
+            if (step.successAction === 'step' && step.successTargetStep) {
+                output += ` → \`${step.successTargetStep}\``;
+            }
+            output += '\n';
+            if (step.failureAction) {
+                output += `- On failure: ${step.failureAction}`;
+                if (step.failureAction === 'step' && step.failureTargetStep) {
+                    output += ` → \`${step.failureTargetStep}\``;
+                }
+                output += '\n';
+            }
+        });
+    });
+    return output;
+}
+function validateWorkflow(workflow) {
+    const errors = [];
+    const allStepKeys = new Set();
+    workflow.forEach((column, colIndex) => {
+        if (!column.title) {
+            errors.push(`Column ${colIndex + 1} is missing a title`);
+        }
+        if (!column.steps || column.steps.length === 0) {
+            errors.push(`Column "${column.title}" has no steps`);
+        }
+        column.steps?.forEach((step, stepIndex) => {
+            if (!step.title) {
+                errors.push(`Step ${colIndex + 1}.${stepIndex + 1} is missing a title`);
+            }
+            if (!step.key) {
+                errors.push(`Step "${step.title}" is missing a key`);
+            }
+            if (allStepKeys.has(step.key)) {
+                errors.push(`Duplicate step key: "${step.key}"`);
+            }
+            allStepKeys.add(step.key);
+        });
+    });
+    // Validate navigation targets
+    workflow.forEach(column => {
+        column.steps?.forEach((step) => {
+            if (step.successAction === 'step' && step.successTargetStep) {
+                if (!allStepKeys.has(step.successTargetStep)) {
+                    errors.push(`Step "${step.key}" has invalid successTargetStep: "${step.successTargetStep}"`);
+                }
+            }
+            if (step.failureAction === 'step' && step.failureTargetStep) {
+                if (!allStepKeys.has(step.failureTargetStep)) {
+                    errors.push(`Step "${step.key}" has invalid failureTargetStep: "${step.failureTargetStep}"`);
+                }
+            }
+        });
+    });
+    return { valid: errors.length === 0, errors };
+}
+//# sourceMappingURL=workflow.js.map