snow-flow 3.3.3 → 3.3.4

package/dist/dynamic-version.js

@@ -36,7 +36,7 @@ function getDynamicVersion() {
         console.warn('Warning: Could not read version from package.json:', error);
     }
     // Fallback to hardcoded version
-    return '3.3.3';
+    return '3.3.4';
 }
 // Export a constant that uses the dynamic version
 exports.VERSION = getDynamicVersion();

package/dist/mcp/servicenow-deployment-mcp.js

@@ -242,7 +242,11 @@ class ServiceNowDeploymentMCP {
                         properties: {
                             type: {
                                 type: 'string',
-                                enum: ['widget', 'application', 'business_rule', 'script_include', 'ui_page'],
+                                enum: [
+                                    'widget', 'application', 'business_rule', 'script_include', 'ui_page',
+                                    'client_script', 'ui_action', 'ui_policy', 'acl', 'table', 'field',
+                                    'workflow', 'flow', 'notification', 'scheduled_job'
+                                ],
                                 description: 'Type of artifact to update'
                             },
                             identifier: {
@@ -279,7 +283,11 @@ class ServiceNowDeploymentMCP {
                         properties: {
                             type: {
                                 type: 'string',
-                                enum: ['widget', 'portal_page', 'application', 'script', 'business_rule', 'table'],
+                                enum: [
+                                    'widget', 'portal_page', 'application', 'script', 'business_rule', 'table',
+                                    'script_include', 'ui_page', 'client_script', 'ui_action', 'ui_policy',
+                                    'acl', 'field', 'workflow', 'flow', 'notification', 'scheduled_job'
+                                ],
                                 description: 'Type of artifact to deploy'
                             },
                             instruction: {
@@ -8172,6 +8180,36 @@ ${updateSetSession ? `📋 **Update Set**: ${updateSetSession.name}
                 case 'ui_page':
                     tableName = 'sys_ui_page';
                     break;
+                case 'client_script':
+                    tableName = 'sys_script_client';
+                    break;
+                case 'ui_action':
+                    tableName = 'sys_ui_action';
+                    break;
+                case 'ui_policy':
+                    tableName = 'sys_ui_policy';
+                    break;
+                case 'acl':
+                    tableName = 'sys_security_acl';
+                    break;
+                case 'table':
+                    tableName = 'sys_db_object';
+                    break;
+                case 'field':
+                    tableName = 'sys_dictionary';
+                    break;
+                case 'workflow':
+                    tableName = 'wf_workflow';
+                    break;
+                case 'flow':
+                    tableName = 'sys_hub_flow';
+                    break;
+                case 'notification':
+                    tableName = 'sysevent_email_action';
+                    break;
+                case 'scheduled_job':
+                    tableName = 'sysauto_script';
+                    break;
                 default:
                     throw new Error(`Unsupported artifact type: ${type}`);
             }
@@ -8254,14 +8292,7 @@ ${updateSetSession ? `📋 **Update Set**: ${updateSetSession.name}
             }
             // Step 7: Track the update
             if (updateSetSession) {
-                artifact_tracker_js_1.artifactTracker.trackArtifact({
-                    type: type,
-                    name: existingArtifact.name,
-                    sys_id: existingArtifact.sys_id,
-                    operation: 'update',
-                    table: tableName,
-                    update_set_id: updateSetSession.update_set_id
-                });
+                artifact_tracker_js_1.artifactTracker.trackArtifact(existingArtifact.sys_id, tableName, existingArtifact.name, type, 'update');
             }
             // Step 8: Return success response
             const updatedFields = Object.keys(updateData);
@@ -8316,55 +8347,465 @@ Use \`snow_deploy\` to create a new ${args.type} instead.`
     /**
      * Process natural language instruction for updates
      */
+    /**
+     * Intelligent Natural Language Processing for ServiceNow artifact updates
+     * Converts natural language instructions into valid ServiceNow field updates
+     */
     async processUpdateInstruction(type, instruction, existingArtifact) {
         const updateData = {};
-        // Simple natural language processing for common update patterns
-        const lowerInstruction = instruction.toLowerCase();
-        if (type === 'widget') {
-            // Widget-specific updates
-            if (lowerInstruction.includes('html') || lowerInstruction.includes('template')) {
-                if (lowerInstruction.includes('add') || lowerInstruction.includes('update')) {
-                    // Extract HTML content if provided
-                    const htmlMatch = instruction.match(/```html\s*\n([\s\S]*?)\n```/);
-                    if (htmlMatch) {
-                        updateData.template = htmlMatch[1];
+        const lowerInstruction = instruction.toLowerCase().trim();
+        this.logger.info(`Processing update instruction for ${type}`, { instruction });
+        try {
+            // First, extract any code blocks or explicit values
+            const codeBlocks = this.extractCodeBlocks(instruction);
+            const explicitValues = this.extractExplicitValues(instruction);
+            // Apply type-specific intelligent parsing
+            switch (type) {
+                case 'widget':
+                    await this.parseWidgetInstruction(updateData, lowerInstruction, codeBlocks, explicitValues, existingArtifact);
+                    break;
+                case 'business_rule':
+                case 'client_script':
+                case 'script_include':
+                    await this.parseScriptInstruction(updateData, lowerInstruction, codeBlocks, explicitValues, existingArtifact);
+                    break;
+                case 'ui_action':
+                    await this.parseUIActionInstruction(updateData, lowerInstruction, codeBlocks, explicitValues, existingArtifact);
+                    break;
+                case 'ui_policy':
+                    await this.parseUIPolicyInstruction(updateData, lowerInstruction, codeBlocks, explicitValues, existingArtifact);
+                    break;
+                case 'notification':
+                    await this.parseNotificationInstruction(updateData, lowerInstruction, codeBlocks, explicitValues, existingArtifact);
+                    break;
+                case 'acl':
+                    await this.parseACLInstruction(updateData, lowerInstruction, codeBlocks, explicitValues, existingArtifact);
+                    break;
+                case 'table':
+                    await this.parseTableInstruction(updateData, lowerInstruction, codeBlocks, explicitValues, existingArtifact);
+                    break;
+                case 'field':
+                    await this.parseFieldInstruction(updateData, lowerInstruction, codeBlocks, explicitValues, existingArtifact);
+                    break;
+                case 'workflow':
+                    await this.parseWorkflowInstruction(updateData, lowerInstruction, codeBlocks, explicitValues, existingArtifact);
+                    break;
+                case 'flow':
+                    await this.parseFlowInstruction(updateData, lowerInstruction, codeBlocks, explicitValues, existingArtifact);
+                    break;
+                case 'scheduled_job':
+                    await this.parseScheduledJobInstruction(updateData, lowerInstruction, codeBlocks, explicitValues, existingArtifact);
+                    break;
+                default:
+                    // Generic parsing for unsupported types
+                    await this.parseGenericInstruction(updateData, lowerInstruction, codeBlocks, explicitValues, existingArtifact);
+            }
+            // Apply common field updates
+            this.applyCommonUpdates(updateData, lowerInstruction, explicitValues);
+            // Validate that we have valid updates
+            if (Object.keys(updateData).length === 0) {
+                throw new Error(`Unable to parse instruction: "${instruction}". Please use more specific language or provide explicit field values.
+
+📝 **Examples that work:**
+- "Change the title to 'New Widget Title'"
+- "Update the description to 'Updated description'"  
+- "Add this CSS: .my-class { color: blue; }"
+- "Change the script to: function() { console.log('updated'); }"
+- "Set active to false"
+
+💡 **Or use the config parameter directly:**
+snow_update({ 
+  type: "${type}", 
+  identifier: "${existingArtifact?.name || 'artifact_name'}", 
+  config: { 
+    field_name: "new_value"
+  }
+})`);
+            }
+            this.logger.info(`Parsed ${Object.keys(updateData).length} field updates`, { updateData });
+            return updateData;
+        }
+        catch (error) {
+            this.logger.error('Failed to process update instruction', { error: error instanceof Error ? error.message : error });
+            throw error;
+        }
+    }
+    /**
+     * Extract code blocks from instruction text
+     */
+    extractCodeBlocks(instruction) {
+        const codeBlocks = {};
+        // Extract different types of code blocks
+        const htmlMatch = instruction.match(/```html\s*\n([\s\S]*?)\n```/i);
+        if (htmlMatch)
+            codeBlocks.html = htmlMatch[1].trim();
+        const cssMatch = instruction.match(/```css\s*\n([\s\S]*?)\n```/i);
+        if (cssMatch)
+            codeBlocks.css = cssMatch[1].trim();
+        const jsMatch = instruction.match(/```javascript\s*\n([\s\S]*?)\n```/i);
+        if (jsMatch)
+            codeBlocks.javascript = jsMatch[1].trim();
+        const jsonMatch = instruction.match(/```json\s*\n([\s\S]*?)\n```/i);
+        if (jsonMatch) {
+            try {
+                codeBlocks.json = JSON.parse(jsonMatch[1].trim());
+            }
+            catch (e) {
+                codeBlocks.json = jsonMatch[1].trim();
+            }
+        }
+        return codeBlocks;
+    }
+    /**
+     * Extract explicit field values from instruction
+     */
+    extractExplicitValues(instruction) {
+        const values = {};
+        // Common patterns for explicit values
+        const patterns = [
+            { regex: /title[:\s]+["']([^"']+)["']/i, field: 'title' },
+            { regex: /name[:\s]+["']([^"']+)["']/i, field: 'name' },
+            { regex: /description[:\s]+["']([^"']+)["']/i, field: 'description' },
+            { regex: /subject[:\s]+["']([^"']+)["']/i, field: 'subject' },
+            { regex: /label[:\s]+["']([^"']+)["']/i, field: 'label' },
+            { regex: /condition[:\s]+["']([^"']+)["']/i, field: 'condition' },
+            { regex: /script[:\s]+["']([^"']+)["']/i, field: 'script' },
+            { regex: /active[:\s]+(\w+)/i, field: 'active', transform: (v) => v.toLowerCase() === 'true' },
+            { regex: /priority[:\s]+(\d+)/i, field: 'priority', transform: (v) => parseInt(v) },
+            { regex: /order[:\s]+(\d+)/i, field: 'order', transform: (v) => parseInt(v) }
+        ];
+        for (const pattern of patterns) {
+            const match = instruction.match(pattern.regex);
+            if (match) {
+                values[pattern.field] = pattern.transform ? pattern.transform(match[1]) : match[1];
+            }
+        }
+        return values;
+    }
+    /**
+     * Parse widget-specific instructions
+     */
+    async parseWidgetInstruction(updateData, instruction, codeBlocks, explicitValues, existingArtifact) {
+        // Handle code blocks
+        if (codeBlocks.html)
+            updateData.template = codeBlocks.html;
+        if (codeBlocks.css)
+            updateData.css = codeBlocks.css;
+        if (codeBlocks.javascript)
+            updateData.script = codeBlocks.javascript;
+        // Handle semantic instructions for widgets
+        if (instruction.includes('add') && instruction.includes('chart')) {
+            // User wants to add a chart - enhance existing template
+            if (existingArtifact?.template) {
+                const currentTemplate = existingArtifact.template || '';
+                if (!currentTemplate.includes('canvas') && !currentTemplate.includes('chart')) {
+                    updateData.template = currentTemplate + '\n<div class="chart-container">\n  <canvas id="widget-chart"></canvas>\n</div>';
+                }
+            }
+            // Add chart CSS if not present
+            if (existingArtifact?.css && !existingArtifact.css.includes('chart-container')) {
+                updateData.css = (existingArtifact.css || '') + '\n\n.chart-container {\n  margin: 20px 0;\n  height: 300px;\n}\n\ncanvas {\n  width: 100% !important;\n  height: 100% !important;\n}';
+            }
+            // Add chart script if not present  
+            if (existingArtifact?.script && !existingArtifact.script.includes('Chart')) {
+                const chartScript = `
+// Chart functionality added
+c.initChart = function() {
+  if (typeof Chart !== 'undefined' && document.getElementById('widget-chart')) {
+    var ctx = document.getElementById('widget-chart').getContext('2d');
+    c.chart = new Chart(ctx, {
+      type: 'bar',
+      data: c.data.chartData || { labels: [], datasets: [] },
+      options: { responsive: true, maintainAspectRatio: false }
+    });
+  }
+};
+
+// Add to existing onInit
+var originalInit = c.$onInit;
+c.$onInit = function() {
+  if (originalInit) originalInit();
+  c.initChart();
+};`;
+                updateData.script = (existingArtifact.script || '') + chartScript;
+            }
+        }
+        // Handle title/name changes  
+        if (instruction.includes('change') && instruction.includes('title')) {
+            const titleMatch = instruction.match(/title[:\s]+["']([^"']+)["']/i) ||
+                instruction.match(/to\s+["']([^"']+)["']/i);
+            if (titleMatch)
+                updateData.title = titleMatch[1];
+        }
+        // Handle style updates
+        if (instruction.includes('style') || instruction.includes('css')) {
+            if (!codeBlocks.css) {
+                // Generate basic style updates based on instruction
+                if (instruction.includes('color')) {
+                    const colorMatch = instruction.match(/color[:\s]+(\w+|#[a-fA-F0-9]{6}|#[a-fA-F0-9]{3})/i);
+                    if (colorMatch) {
+                        updateData.css = (existingArtifact?.css || '') + `\n\n.widget-content { color: ${colorMatch[1]}; }`;
                     }
                 }
             }
-            if (lowerInstruction.includes('css') || lowerInstruction.includes('style')) {
-                const cssMatch = instruction.match(/```css\s*\n([\s\S]*?)\n```/);
-                if (cssMatch) {
-                    updateData.css = cssMatch[1];
+        }
+        // Apply explicit values
+        Object.assign(updateData, explicitValues);
+    }
+    /**
+     * Parse script-based artifact instructions (business_rule, script_include, client_script)
+     */
+    async parseScriptInstruction(updateData, instruction, codeBlocks, explicitValues, existingArtifact) {
+        if (codeBlocks.javascript) {
+            updateData.script = codeBlocks.javascript;
+        }
+        // Handle condition updates
+        if (instruction.includes('condition') && !codeBlocks.javascript) {
+            const conditionMatch = instruction.match(/condition[:\s]+["']([^"']+)["']/i);
+            if (conditionMatch)
+                updateData.condition = conditionMatch[1];
+        }
+        // Handle when/trigger changes for business rules
+        if (instruction.includes('when') || instruction.includes('trigger')) {
+            const whenOptions = ['before', 'after', 'async', 'display'];
+            for (const option of whenOptions) {
+                if (instruction.includes(option)) {
+                    updateData.when = option;
+                    break;
                 }
             }
-            if (lowerInstruction.includes('script') || lowerInstruction.includes('javascript')) {
-                const jsMatch = instruction.match(/```javascript\s*\n([\s\S]*?)\n```/);
-                if (jsMatch) {
-                    updateData.script = jsMatch[1];
-                }
+        }
+        // Handle table changes
+        if (instruction.includes('table')) {
+            const tableMatch = instruction.match(/table[:\s]+["']?([a-z_]+)["']?/i);
+            if (tableMatch)
+                updateData.table = tableMatch[1];
+        }
+        Object.assign(updateData, explicitValues);
+    }
+    /**
+     * Parse UI Action instructions
+     */
+    async parseUIActionInstruction(updateData, instruction, codeBlocks, explicitValues, existingArtifact) {
+        if (codeBlocks.javascript) {
+            updateData.script = codeBlocks.javascript;
+        }
+        // Handle label/action name changes
+        if (instruction.includes('label') || instruction.includes('button') || instruction.includes('action name')) {
+            const labelMatch = instruction.match(/(?:label|button|action name)[:\s]+["']([^"']+)["']/i);
+            if (labelMatch)
+                updateData.action_name = labelMatch[1];
+        }
+        // Handle condition changes
+        if (instruction.includes('condition')) {
+            const conditionMatch = instruction.match(/condition[:\s]+["']([^"']+)["']/i);
+            if (conditionMatch)
+                updateData.condition = conditionMatch[1];
+        }
+        Object.assign(updateData, explicitValues);
+    }
+    /**
+     * Parse UI Policy instructions
+     */
+    async parseUIPolicyInstruction(updateData, instruction, codeBlocks, explicitValues, existingArtifact) {
+        if (codeBlocks.javascript) {
+            updateData.script_true = codeBlocks.javascript;
+        }
+        if (instruction.includes('condition')) {
+            const conditionMatch = instruction.match(/condition[:\s]+["']([^"']+)["']/i);
+            if (conditionMatch)
+                updateData.conditions = conditionMatch[1];
+        }
+        Object.assign(updateData, explicitValues);
+    }
+    /**
+     * Parse notification instructions
+     */
+    async parseNotificationInstruction(updateData, instruction, codeBlocks, explicitValues, existingArtifact) {
+        if (codeBlocks.html) {
+            updateData.message_html = codeBlocks.html;
+        }
+        // Handle subject changes
+        if (instruction.includes('subject')) {
+            const subjectMatch = instruction.match(/subject[:\s]+["']([^"']+)["']/i);
+            if (subjectMatch)
+                updateData.subject = subjectMatch[1];
+        }
+        // Handle body/message changes  
+        if (instruction.includes('body') || instruction.includes('message')) {
+            if (!codeBlocks.html) {
+                const messageMatch = instruction.match(/(?:body|message)[:\s]+["']([^"']+)["']/i);
+                if (messageMatch)
+                    updateData.message_html = messageMatch[1];
+            }
+        }
+        // Handle recipient changes
+        if (instruction.includes('recipient') || instruction.includes('to')) {
+            const recipientMatch = instruction.match(/(?:recipient|to)[:\s]+["']([^"']+)["']/i);
+            if (recipientMatch)
+                updateData.recipient = recipientMatch[1];
+        }
+        Object.assign(updateData, explicitValues);
+    }
+    /**
+     * Parse ACL instructions
+     */
+    async parseACLInstruction(updateData, instruction, codeBlocks, explicitValues, existingArtifact) {
+        if (codeBlocks.javascript) {
+            updateData.script = codeBlocks.javascript;
+        }
+        // Handle operation changes
+        const operations = ['read', 'write', 'create', 'delete', 'execute'];
+        for (const op of operations) {
+            if (instruction.includes(op)) {
+                updateData.operation = op;
+                break;
             }
-            if (lowerInstruction.includes('server') || lowerInstruction.includes('server script')) {
-                const serverMatch = instruction.match(/```javascript\s*\n([\s\S]*?)\n```/);
-                if (serverMatch) {
-                    updateData.script = serverMatch[1];
-                }
+        }
+        // Handle role changes
+        if (instruction.includes('role')) {
+            const roleMatch = instruction.match(/role[:\s]+["']([^"']+)["']/i);
+            if (roleMatch)
+                updateData.role = roleMatch[1];
+        }
+        Object.assign(updateData, explicitValues);
+    }
+    /**
+     * Parse table instructions
+     */
+    async parseTableInstruction(updateData, instruction, codeBlocks, explicitValues, existingArtifact) {
+        if (instruction.includes('label')) {
+            const labelMatch = instruction.match(/label[:\s]+["']([^"']+)["']/i);
+            if (labelMatch)
+                updateData.label = labelMatch[1];
+        }
+        if (instruction.includes('access')) {
+            const accessMatch = instruction.match(/access[:\s]+["']([^"']+)["']/i);
+            if (accessMatch)
+                updateData.access = accessMatch[1];
+        }
+        Object.assign(updateData, explicitValues);
+    }
+    /**
+     * Parse field instructions
+     */
+    async parseFieldInstruction(updateData, instruction, codeBlocks, explicitValues, existingArtifact) {
+        if (instruction.includes('label')) {
+            const labelMatch = instruction.match(/label[:\s]+["']([^"']+)["']/i);
+            if (labelMatch)
+                updateData.column_label = labelMatch[1];
+        }
+        if (instruction.includes('type')) {
+            const typeMatch = instruction.match(/type[:\s]+["']([^"']+)["']/i);
+            if (typeMatch)
+                updateData.internal_type = typeMatch[1];
+        }
+        // Handle mandatory/required changes
+        if (instruction.includes('mandatory') || instruction.includes('required')) {
+            if (instruction.includes('make mandatory') || instruction.includes('make required')) {
+                updateData.mandatory = true;
+            }
+            else if (instruction.includes('remove mandatory') || instruction.includes('optional')) {
+                updateData.mandatory = false;
+            }
+        }
+        Object.assign(updateData, explicitValues);
+    }
+    /**
+     * Parse workflow instructions
+     */
+    async parseWorkflowInstruction(updateData, instruction, codeBlocks, explicitValues, existingArtifact) {
+        if (instruction.includes('description')) {
+            const descMatch = instruction.match(/description[:\s]+["']([^"']+)["']/i);
+            if (descMatch)
+                updateData.description = descMatch[1];
+        }
+        Object.assign(updateData, explicitValues);
+    }
+    /**
+     * Parse flow instructions
+     */
+    async parseFlowInstruction(updateData, instruction, codeBlocks, explicitValues, existingArtifact) {
+        if (instruction.includes('description')) {
+            const descMatch = instruction.match(/description[:\s]+["']([^"']+)["']/i);
+            if (descMatch)
+                updateData.description = descMatch[1];
+        }
+        if (instruction.includes('trigger')) {
+            const triggerMatch = instruction.match(/trigger[:\s]+["']([^"']+)["']/i);
+            if (triggerMatch)
+                updateData.trigger = triggerMatch[1];
+        }
+        Object.assign(updateData, explicitValues);
+    }
+    /**
+     * Parse scheduled job instructions
+     */
+    async parseScheduledJobInstruction(updateData, instruction, codeBlocks, explicitValues, existingArtifact) {
+        if (codeBlocks.javascript) {
+            updateData.script = codeBlocks.javascript;
+        }
+        if (instruction.includes('schedule') || instruction.includes('cron')) {
+            const scheduleMatch = instruction.match(/(?:schedule|cron)[:\s]+["']([^"']+)["']/i);
+            if (scheduleMatch) {
+                updateData.run_type = 'Periodically';
+                updateData.run_period = scheduleMatch[1];
             }
-            // Update description if mentioned
-            if (lowerInstruction.includes('description')) {
-                const descMatch = instruction.match(/description:?\s*["']([^"']+)["']/i);
-                if (descMatch) {
-                    updateData.short_description = descMatch[1];
+            // Handle time-based schedules
+            if (instruction.includes('hour')) {
+                const hourMatch = instruction.match(/(\d+)\s*hour/i);
+                if (hourMatch) {
+                    updateData.run_type = 'Periodically';
+                    updateData.run_period = `0 0 */${hourMatch[1]} * * *`;
                 }
             }
+            if (instruction.includes('daily')) {
+                updateData.run_type = 'Periodically';
+                updateData.run_period = '0 0 0 * * *'; // Daily at midnight
+            }
+            if (instruction.includes('weekly')) {
+                updateData.run_type = 'Periodically';
+                updateData.run_period = '0 0 0 * * 0'; // Weekly on Sunday
+            }
         }
-        // If no specific patterns matched, add as general update
-        if (Object.keys(updateData).length === 0) {
-            // For now, return instruction for manual processing
-            updateData._instruction = instruction;
-            // You could add more sophisticated NLP processing here
-            // or integrate with AI services to interpret the instruction
+        Object.assign(updateData, explicitValues);
+    }
+    /**
+     * Generic parsing for unsupported types
+     */
+    async parseGenericInstruction(updateData, instruction, codeBlocks, explicitValues, existingArtifact) {
+        // Apply only explicit values for unsupported types
+        Object.assign(updateData, explicitValues);
+        // Handle common script field
+        if (codeBlocks.javascript && !updateData.script) {
+            updateData.script = codeBlocks.javascript;
+        }
+    }
+    /**
+     * Apply common field updates across all artifact types
+     */
+    applyCommonUpdates(updateData, instruction, explicitValues) {
+        // Handle active/inactive states
+        if (instruction.includes('activate') || instruction.includes('enable')) {
+            updateData.active = true;
+        }
+        else if (instruction.includes('deactivate') || instruction.includes('disable')) {
+            updateData.active = false;
+        }
+        // Handle description updates (various field names)
+        if (instruction.includes('description') && !updateData.description && !updateData.short_description) {
+            const descMatch = instruction.match(/description[:\s]+["']([^"']+)["']/i);
+            if (descMatch) {
+                // Use appropriate description field based on common patterns
+                updateData.short_description = descMatch[1];
+            }
+        }
+        // Handle name updates
+        if (instruction.includes('name') && instruction.includes('change')) {
+            const nameMatch = instruction.match(/name[:\s]+["']([^"']+)["']/i);
+            if (nameMatch)
+                updateData.name = nameMatch[1];
         }
-        return updateData;
     }
     /**
      * Get table name for artifact type
@@ -8381,6 +8822,26 @@ Use \`snow_deploy\` to create a new ${args.type} instead.`
                 return 'sys_script_include';
             case 'ui_page':
                 return 'sys_ui_page';
+            case 'client_script':
+                return 'sys_script_client';
+            case 'ui_action':
+                return 'sys_ui_action';
+            case 'ui_policy':
+                return 'sys_ui_policy';
+            case 'acl':
+                return 'sys_security_acl';
+            case 'table':
+                return 'sys_db_object';
+            case 'field':
+                return 'sys_dictionary';
+            case 'workflow':
+                return 'wf_workflow';
+            case 'flow':
+                return 'sys_hub_flow';
+            case 'notification':
+                return 'sysevent_email_action';
+            case 'scheduled_job':
+                return 'sysauto_script';
             default:
                 return 'sys_metadata';
         }