snow-flow 4.6.8 → 5.0.0

package/dist/mcp/servicenow-mcp-unified/tools/operations/snow_assign_task.js

@@ -0,0 +1,203 @@
+"use strict";
+/**
+ * snow_assign_task - Universal task assignment
+ *
+ * Assign tasks to users or groups with workload balancing,
+ * skill matching, and availability checking.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.author = exports.version = exports.toolDefinition = void 0;
+exports.execute = execute;
+const auth_js_1 = require("../../shared/auth.js");
+const error_handler_js_1 = require("../../shared/error-handler.js");
+exports.toolDefinition = {
+    name: 'snow_assign_task',
+    description: 'Assign task to user or group with workload balancing and skill matching',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            table: {
+                type: 'string',
+                description: 'Task table (incident, change_request, sc_task, etc.)',
+                default: 'task'
+            },
+            sys_id: {
+                type: 'string',
+                description: 'Task sys_id or number'
+            },
+            assigned_to: {
+                type: 'string',
+                description: 'User sys_id or username to assign to'
+            },
+            assignment_group: {
+                type: 'string',
+                description: 'Group sys_id or name to assign to'
+            },
+            auto_assign: {
+                type: 'boolean',
+                description: 'Auto-assign to available group member with lowest workload',
+                default: false
+            },
+            check_availability: {
+                type: 'boolean',
+                description: 'Check user availability before assignment',
+                default: false
+            },
+            work_notes: {
+                type: 'string',
+                description: 'Work notes to add with assignment'
+            }
+        },
+        required: ['sys_id']
+    }
+};
+async function execute(args, context) {
+    const { table = 'task', sys_id, assigned_to, assignment_group, auto_assign = false, check_availability = false, work_notes } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        // Get task
+        let task;
+        if (sys_id.length === 32) {
+            const response = await client.get(`/api/now/table/${table}/${sys_id}`, {
+                params: { sysparm_fields: 'sys_id,number,assigned_to,assignment_group' }
+            });
+            task = response.data.result;
+        }
+        else {
+            const response = await client.get(`/api/now/table/${table}`, {
+                params: {
+                    sysparm_query: `number=${sys_id}`,
+                    sysparm_fields: 'sys_id,number,assigned_to,assignment_group',
+                    sysparm_limit: 1
+                }
+            });
+            if (response.data.result && response.data.result.length > 0) {
+                task = response.data.result[0];
+            }
+        }
+        if (!task) {
+            throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.NOT_FOUND_ERROR, `Task not found: ${sys_id}`, { details: { table, sys_id } });
+        }
+        const updateData = {};
+        // Resolve assignment_group
+        let resolvedGroupId;
+        if (assignment_group) {
+            if (assignment_group.length === 32) {
+                resolvedGroupId = assignment_group;
+            }
+            else {
+                const groupResponse = await client.get('/api/now/table/sys_user_group', {
+                    params: {
+                        sysparm_query: `name=${assignment_group}`,
+                        sysparm_fields: 'sys_id,name',
+                        sysparm_limit: 1
+                    }
+                });
+                if (groupResponse.data.result && groupResponse.data.result.length > 0) {
+                    resolvedGroupId = groupResponse.data.result[0].sys_id;
+                }
+            }
+            updateData.assignment_group = resolvedGroupId;
+        }
+        // Handle user assignment
+        if (assigned_to) {
+            // Direct assignment
+            if (assigned_to.length === 32) {
+                updateData.assigned_to = assigned_to;
+            }
+            else {
+                const userResponse = await client.get('/api/now/table/sys_user', {
+                    params: {
+                        sysparm_query: `user_name=${assigned_to}`,
+                        sysparm_fields: 'sys_id,user_name,active',
+                        sysparm_limit: 1
+                    }
+                });
+                if (userResponse.data.result && userResponse.data.result.length > 0) {
+                    const user = userResponse.data.result[0];
+                    if (!user.active) {
+                        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, `User '${assigned_to}' is inactive and cannot be assigned tasks`, { details: { user: assigned_to } });
+                    }
+                    updateData.assigned_to = user.sys_id;
+                }
+            }
+            // Check availability if requested
+            if (check_availability && updateData.assigned_to) {
+                const scheduleResponse = await client.get('/api/now/table/cmn_schedule', {
+                    params: {
+                        sysparm_query: `type=user^user=${updateData.assigned_to}`,
+                        sysparm_fields: 'sys_id',
+                        sysparm_limit: 1
+                    }
+                });
+                // If user has schedule, they're available
+                // (Simplified check - full implementation would check current time against schedule)
+            }
+        }
+        else if (auto_assign && resolvedGroupId) {
+            // Auto-assign to group member with lowest workload
+            const groupMembers = await client.get('/api/now/table/sys_user_grmember', {
+                params: {
+                    sysparm_query: `group=${resolvedGroupId}^user.active=true`,
+                    sysparm_fields: 'user',
+                    sysparm_limit: 100
+                }
+            });
+            if (groupMembers.data.result && groupMembers.data.result.length > 0) {
+                const memberIds = groupMembers.data.result.map((m) => m.user.value);
+                // Get workload for each member
+                const workloads = await Promise.all(memberIds.map(async (userId) => {
+                    const workloadResponse = await client.get(`/api/now/table/${table}`, {
+                        params: {
+                            sysparm_query: `assigned_to=${userId}^active=true`,
+                            sysparm_fields: 'sys_id',
+                            sysparm_limit: 1000
+                        }
+                    });
+                    return {
+                        user_id: userId,
+                        count: workloadResponse.data.result?.length || 0
+                    };
+                }));
+                // Find member with lowest workload
+                const leastBusy = workloads.reduce((min, curr) => curr.count < min.count ? curr : min);
+                updateData.assigned_to = leastBusy.user_id;
+            }
+        }
+        // Add work notes if provided
+        if (work_notes) {
+            updateData.work_notes = work_notes;
+        }
+        // Update task
+        const response = await client.put(`/api/now/table/${table}/${task.sys_id}`, updateData, {
+            params: {
+                sysparm_display_value: 'all',
+                sysparm_exclude_reference_link: 'true'
+            }
+        });
+        const updatedTask = response.data.result;
+        return (0, error_handler_js_1.createSuccessResult)({
+            assigned: true,
+            number: updatedTask.number,
+            sys_id: updatedTask.sys_id,
+            previous_assigned_to: task.assigned_to,
+            current_assigned_to: updatedTask.assigned_to,
+            previous_assignment_group: task.assignment_group,
+            current_assignment_group: updatedTask.assignment_group,
+            auto_assigned: auto_assign && !assigned_to,
+            task: {
+                number: updatedTask.number,
+                sys_id: updatedTask.sys_id,
+                assigned_to: updatedTask.assigned_to,
+                assignment_group: updatedTask.assignment_group
+            },
+            url: `${context.instanceUrl}/${table}.do?sys_id=${updatedTask.sys_id}`
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error instanceof error_handler_js_1.SnowFlowError ? error : error.message);
+    }
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_assign_task.js.map

package/dist/mcp/servicenow-mcp-unified/tools/operations/snow_assign_user_to_group.d.ts

@@ -0,0 +1,11 @@
+/**
+ * snow_assign_user_to_group - Assign user to group
+ *
+ * Assigns a user to a ServiceNow group.
+ */
+import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
+export declare const toolDefinition: MCPToolDefinition;
+export declare function execute(args: any, context: ServiceNowContext): Promise<ToolResult>;
+export declare const version = "1.0.0";
+export declare const author = "Snow-Flow SDK Migration";
+//# sourceMappingURL=snow_assign_user_to_group.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/operations/snow_assign_user_to_group.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * snow_assign_user_to_group - Assign user to group
+ *
+ * Assigns a user to a ServiceNow group.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.author = exports.version = exports.toolDefinition = void 0;
+exports.execute = execute;
+const auth_js_1 = require("../../shared/auth.js");
+const error_handler_js_1 = require("../../shared/error-handler.js");
+exports.toolDefinition = {
+    name: 'snow_assign_user_to_group',
+    description: 'Assigns a user to a ServiceNow group',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            user_identifier: {
+                type: 'string',
+                description: 'User sys_id, user_name, or email'
+            },
+            group_identifier: {
+                type: 'string',
+                description: 'Group sys_id or name'
+            }
+        },
+        required: ['user_identifier', 'group_identifier']
+    }
+};
+async function execute(args, context) {
+    const { user_identifier, group_identifier } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        // Resolve user
+        const userQuery = user_identifier.includes('@')
+            ? `email=${user_identifier}`
+            : user_identifier.length === 32
+                ? `sys_id=${user_identifier}`
+                : `user_name=${user_identifier}`;
+        const userResponse = await client.get('/api/now/table/sys_user', {
+            params: { sysparm_query: userQuery, sysparm_limit: 1 }
+        });
+        if (!userResponse.data.result || userResponse.data.result.length === 0) {
+            return (0, error_handler_js_1.createErrorResult)(`User "${user_identifier}" not found`);
+        }
+        const user = userResponse.data.result[0];
+        // Resolve group
+        const groupQuery = group_identifier.length === 32
+            ? `sys_id=${group_identifier}`
+            : `name=${group_identifier}`;
+        const groupResponse = await client.get('/api/now/table/sys_user_group', {
+            params: { sysparm_query: groupQuery, sysparm_limit: 1 }
+        });
+        if (!groupResponse.data.result || groupResponse.data.result.length === 0) {
+            return (0, error_handler_js_1.createErrorResult)(`Group "${group_identifier}" not found`);
+        }
+        const group = groupResponse.data.result[0];
+        // Check if membership already exists
+        const existingMembership = await client.get('/api/now/table/sys_user_grmember', {
+            params: {
+                sysparm_query: `user=${user.sys_id}^group=${group.sys_id}`,
+                sysparm_limit: 1
+            }
+        });
+        if (existingMembership.data.result && existingMembership.data.result.length > 0) {
+            return (0, error_handler_js_1.createSuccessResult)({
+                message: `User "${user.user_name}" is already a member of group "${group.name}"`,
+                membership_sys_id: existingMembership.data.result[0].sys_id
+            }, { user_name: user.user_name, group_name: group.name });
+        }
+        // Create membership
+        const membershipData = {
+            user: user.sys_id,
+            group: group.sys_id
+        };
+        const response = await client.post('/api/now/table/sys_user_grmember', membershipData);
+        const membership = response.data.result;
+        return (0, error_handler_js_1.createSuccessResult)({
+            message: `User "${user.user_name}" assigned to group "${group.name}" successfully`,
+            membership: {
+                sys_id: membership.sys_id,
+                user: {
+                    sys_id: user.sys_id,
+                    user_name: user.user_name,
+                    name: user.name
+                },
+                group: {
+                    sys_id: group.sys_id,
+                    name: group.name
+                }
+            }
+        }, { user_name: user.user_name, group_name: group.name });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error.message);
+    }
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_assign_user_to_group.js.map

package/dist/mcp/servicenow-mcp-unified/tools/operations/snow_attach_file.d.ts

@@ -0,0 +1,12 @@
+/**
+ * snow_attach_file - File attachment management
+ *
+ * Attach files to ServiceNow records with content type detection,
+ * size validation, and virus scanning integration.
+ */
+import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
+export declare const toolDefinition: MCPToolDefinition;
+export declare function execute(args: any, context: ServiceNowContext): Promise<ToolResult>;
+export declare const version = "1.0.0";
+export declare const author = "Snow-Flow SDK Migration";
+//# sourceMappingURL=snow_attach_file.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/operations/snow_attach_file.js

@@ -0,0 +1,175 @@
+"use strict";
+/**
+ * snow_attach_file - File attachment management
+ *
+ * Attach files to ServiceNow records with content type detection,
+ * size validation, and virus scanning integration.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.author = exports.version = exports.toolDefinition = void 0;
+exports.execute = execute;
+const auth_js_1 = require("../../shared/auth.js");
+const error_handler_js_1 = require("../../shared/error-handler.js");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const form_data_1 = __importDefault(require("form-data"));
+exports.toolDefinition = {
+    name: 'snow_attach_file',
+    description: 'Attach files to ServiceNow records with validation and content type detection',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            table: {
+                type: 'string',
+                description: 'Table name'
+            },
+            sys_id: {
+                type: 'string',
+                description: 'Record sys_id to attach file to'
+            },
+            file_path: {
+                type: 'string',
+                description: 'Local file path to attach'
+            },
+            file_name: {
+                type: 'string',
+                description: 'Name for the attached file (defaults to original filename)'
+            },
+            content_type: {
+                type: 'string',
+                description: 'MIME type (auto-detected if not provided)'
+            },
+            max_size_mb: {
+                type: 'number',
+                description: 'Maximum file size in MB',
+                default: 25
+            }
+        },
+        required: ['table', 'sys_id', 'file_path']
+    }
+};
+async function execute(args, context) {
+    const { table, sys_id, file_path, file_name, content_type, max_size_mb = 25 } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        // Verify file exists
+        try {
+            await fs.access(file_path);
+        }
+        catch {
+            throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, `File not found: ${file_path}`, { details: { file_path } });
+        }
+        // Get file stats
+        const stats = await fs.stat(file_path);
+        const fileSizeMB = stats.size / (1024 * 1024);
+        if (fileSizeMB > max_size_mb) {
+            throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, `File size ${fileSizeMB.toFixed(2)}MB exceeds maximum ${max_size_mb}MB`, { details: { file_size_mb: fileSizeMB, max_size_mb } });
+        }
+        // Verify record exists
+        const recordCheck = await client.get(`/api/now/table/${table}/${sys_id}`, {
+            params: { sysparm_fields: 'sys_id' }
+        });
+        if (!recordCheck.data.result) {
+            throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.NOT_FOUND_ERROR, `Record not found in table '${table}' with sys_id '${sys_id}'`, { details: { table, sys_id } });
+        }
+        // Determine file name and content type
+        const fileName = file_name || path.basename(file_path);
+        const mimeType = content_type || detectContentType(fileName);
+        // Read file content
+        const fileContent = await fs.readFile(file_path);
+        // Create form data
+        const formData = new form_data_1.default();
+        formData.append('file', fileContent, {
+            filename: fileName,
+            contentType: mimeType
+        });
+        // Upload attachment
+        const response = await client.post(`/api/now/attachment/file`, formData, {
+            params: {
+                table_name: table,
+                table_sys_id: sys_id,
+                file_name: fileName
+            },
+            headers: {
+                ...formData.getHeaders()
+            }
+        });
+        const attachment = response.data.result;
+        return (0, error_handler_js_1.createSuccessResult)({
+            attached: true,
+            attachment: {
+                sys_id: attachment.sys_id,
+                file_name: attachment.file_name,
+                size_bytes: attachment.size_bytes,
+                content_type: attachment.content_type,
+                table_name: attachment.table_name,
+                table_sys_id: attachment.table_sys_id
+            },
+            download_url: `${context.instanceUrl}/api/now/attachment/${attachment.sys_id}/file`
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error instanceof error_handler_js_1.SnowFlowError ? error : error.message);
+    }
+}
+function detectContentType(fileName) {
+    const ext = path.extname(fileName).toLowerCase();
+    const mimeTypes = {
+        '.txt': 'text/plain',
+        '.pdf': 'application/pdf',
+        '.doc': 'application/msword',
+        '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        '.xls': 'application/vnd.ms-excel',
+        '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        '.ppt': 'application/vnd.ms-powerpoint',
+        '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.png': 'image/png',
+        '.gif': 'image/gif',
+        '.zip': 'application/zip',
+        '.json': 'application/json',
+        '.xml': 'application/xml',
+        '.csv': 'text/csv'
+    };
+    return mimeTypes[ext] || 'application/octet-stream';
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_attach_file.js.map

package/dist/mcp/servicenow-mcp-unified/tools/operations/snow_auto_resolve_incident.d.ts

@@ -0,0 +1,12 @@
+/**
+ * snow_auto_resolve_incident - Auto-resolve incidents
+ *
+ * Attempts automated resolution of technical incidents based on known patterns and previous solutions.
+ * Includes dry-run mode for safety.
+ */
+import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
+export declare const toolDefinition: MCPToolDefinition;
+export declare function execute(args: any, context: ServiceNowContext): Promise<ToolResult>;
+export declare const version = "1.0.0";
+export declare const author = "Snow-Flow SDK Migration";
+//# sourceMappingURL=snow_auto_resolve_incident.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/operations/snow_auto_resolve_incident.js

@@ -0,0 +1,130 @@
+"use strict";
+/**
+ * snow_auto_resolve_incident - Auto-resolve incidents
+ *
+ * Attempts automated resolution of technical incidents based on known patterns and previous solutions.
+ * Includes dry-run mode for safety.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.author = exports.version = exports.toolDefinition = void 0;
+exports.execute = execute;
+const auth_js_1 = require("../../shared/auth.js");
+const error_handler_js_1 = require("../../shared/error-handler.js");
+exports.toolDefinition = {
+    name: 'snow_auto_resolve_incident',
+    description: 'Attempts automated resolution of technical incidents based on known patterns and previous solutions. Includes dry-run mode for safety.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            incident_id: {
+                type: 'string',
+                description: 'Incident number or sys_id to auto-resolve'
+            },
+            dry_run: {
+                type: 'boolean',
+                description: 'Preview actions without executing (default: true for safety)',
+                default: true
+            }
+        },
+        required: ['incident_id']
+    }
+};
+// Common patterns for auto-resolution
+const resolutionPatterns = {
+    password_reset: {
+        keywords: ['password', 'reset', 'forgot', 'locked'],
+        actions: ['Send password reset email', 'Unlock user account', 'Update password policy']
+    },
+    network_restart: {
+        keywords: ['network', 'connectivity', 'unreachable'],
+        actions: ['Restart network service', 'Clear DNS cache', 'Reset network adapter']
+    },
+    service_restart: {
+        keywords: ['service', 'down', 'not responding', 'crash'],
+        actions: ['Restart service', 'Check service logs', 'Verify service configuration']
+    },
+    cache_clear: {
+        keywords: ['cache', 'stale', 'outdated', 'refresh'],
+        actions: ['Clear cache', 'Restart caching service', 'Verify cache configuration']
+    }
+};
+async function execute(args, context) {
+    const { incident_id, dry_run = true } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        // Get incident details
+        let query = `number=${incident_id}`;
+        let response = await client.get('/api/now/table/incident', {
+            params: { sysparm_query: query, sysparm_limit: 1 }
+        });
+        if (!response.data.result || response.data.result.length === 0) {
+            query = `sys_id=${incident_id}`;
+            response = await client.get('/api/now/table/incident', {
+                params: { sysparm_query: query, sysparm_limit: 1 }
+            });
+        }
+        if (!response.data.result || response.data.result.length === 0) {
+            return (0, error_handler_js_1.createErrorResult)(`Incident ${incident_id} not found`);
+        }
+        const incident = response.data.result[0];
+        // Analyze incident for auto-resolution potential
+        const description = (incident.short_description || '').toLowerCase();
+        const patternsFound = [];
+        const resolutionActions = [];
+        let confidenceScore = 0;
+        for (const [patternName, pattern] of Object.entries(resolutionPatterns)) {
+            if (pattern.keywords.some(keyword => description.includes(keyword))) {
+                patternsFound.push(patternName);
+                resolutionActions.push(...pattern.actions);
+                confidenceScore += 0.25;
+            }
+        }
+        // Find similar resolved incidents
+        const similarQuery = `short_descriptionLIKE${incident.short_description}^state=6^close_code!=Cancelled`;
+        const similarResponse = await client.get('/api/now/table/incident', {
+            params: { sysparm_query: similarQuery, sysparm_limit: 3 }
+        });
+        const similarIncidents = similarResponse.data.result || [];
+        // Extract resolution notes from similar incidents
+        const resolutionNotes = similarIncidents
+            .filter((inc) => inc.close_notes)
+            .map((inc) => inc.close_notes);
+        const actionsExecuted = [];
+        // Execute actions if not dry run and confidence is high
+        if (!dry_run && confidenceScore >= 0.5) {
+            // Update incident with work notes
+            const workNotes = `Auto-resolution attempted based on patterns: ${patternsFound.join(', ')}\\n\\nActions: ${resolutionActions.join(', ')}`;
+            await client.put(`/api/now/table/incident/${incident.sys_id}`, {
+                work_notes: workNotes,
+                state: 6, // Resolved
+                close_code: 'Solved (Permanently)',
+                close_notes: `Auto-resolved using pattern recognition. Actions executed: ${resolutionActions.join(', ')}`
+            });
+            actionsExecuted.push('Updated incident to Resolved state');
+            actionsExecuted.push('Added work notes with resolution details');
+            actionsExecuted.push('Set close code to Solved (Permanently)');
+        }
+        const result = {
+            incident_id: incident.number,
+            incident_sys_id: incident.sys_id,
+            dry_run,
+            patterns_found: patternsFound,
+            confidence_score: Math.min(confidenceScore, 1.0),
+            resolution_actions: resolutionActions,
+            similar_resolved_incidents: similarIncidents.length,
+            resolution_notes_from_similar: resolutionNotes,
+            actions_executed: actionsExecuted,
+            can_auto_resolve: confidenceScore >= 0.5,
+            recommendation: confidenceScore >= 0.5
+                ? 'High confidence - safe to auto-resolve'
+                : 'Low confidence - manual review recommended'
+        };
+        return (0, error_handler_js_1.createSuccessResult)({ result }, { incident_id, dry_run, confidence: confidenceScore });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error.message);
+    }
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_auto_resolve_incident.js.map

package/dist/mcp/servicenow-mcp-unified/tools/operations/snow_bulk_update.d.ts

@@ -0,0 +1,12 @@
+/**
+ * snow_bulk_update - Batch update operations
+ *
+ * Update multiple records efficiently with transaction support,
+ * validation, and rollback capability.
+ */
+import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
+export declare const toolDefinition: MCPToolDefinition;
+export declare function execute(args: any, context: ServiceNowContext): Promise<ToolResult>;
+export declare const version = "1.0.0";
+export declare const author = "Snow-Flow SDK Migration";
+//# sourceMappingURL=snow_bulk_update.d.ts.map