snow-flow 4.6.8 → 5.0.0

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

@@ -0,0 +1,208 @@
+"use strict";
+/**
+ * snow_pattern_analysis - Analyze patterns
+ *
+ * Analyzes patterns across incidents, requests, and problems to identify trends, common issues, and improvement opportunities.
+ */
+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_pattern_analysis',
+    description: 'Analyzes patterns across incidents, requests, and problems to identify trends, common issues, and improvement opportunities',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            analysis_type: {
+                type: 'string',
+                description: 'Type of pattern analysis',
+                enum: ['incident_patterns', 'request_trends', 'problem_root_causes', 'user_behavior']
+            },
+            timeframe: {
+                type: 'string',
+                description: 'Time period for analysis',
+                enum: ['day', 'week', 'month', 'quarter'],
+                default: 'week'
+            }
+        },
+        required: ['analysis_type']
+    }
+};
+function getDateFilter(timeframe) {
+    const filters = {
+        day: 'ONToday@javascript:gs.daysAgoStart(0)@javascript:gs.daysAgoEnd(0)',
+        week: 'ONLast 7 days@javascript:gs.daysAgoStart(7)@javascript:gs.daysAgoEnd(0)',
+        month: 'ONLast 30 days@javascript:gs.daysAgoStart(30)@javascript:gs.daysAgoEnd(0)',
+        quarter: 'ONLast 90 days@javascript:gs.daysAgoStart(90)@javascript:gs.daysAgoEnd(0)'
+    };
+    return filters[timeframe] || filters.week;
+}
+async function execute(args, context) {
+    const { analysis_type, timeframe = 'week' } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        const dateFilter = getDateFilter(timeframe);
+        let patterns = {
+            analysis_type,
+            timeframe,
+            generated_at: new Date().toISOString()
+        };
+        switch (analysis_type) {
+            case 'incident_patterns':
+                patterns = { ...patterns, ...(await analyzeIncidentPatterns(client, dateFilter)) };
+                break;
+            case 'request_trends':
+                patterns = { ...patterns, ...(await analyzeRequestTrends(client, dateFilter)) };
+                break;
+            case 'problem_root_causes':
+                patterns = { ...patterns, ...(await analyzeProblemRootCauses(client, dateFilter)) };
+                break;
+            case 'user_behavior':
+                patterns = { ...patterns, ...(await analyzeUserBehavior(client, dateFilter)) };
+                break;
+            default:
+                return (0, error_handler_js_1.createErrorResult)(`Unknown analysis type: ${analysis_type}`);
+        }
+        return (0, error_handler_js_1.createSuccessResult)({ patterns }, { analysis_type, timeframe });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error.message);
+    }
+}
+async function analyzeIncidentPatterns(client, dateFilter) {
+    const response = await client.get('/api/now/table/incident', {
+        params: {
+            sysparm_query: `sys_created_on${dateFilter}`,
+            sysparm_limit: 1000
+        }
+    });
+    const incidents = response.data.result || [];
+    const patterns = {
+        by_category: new Map(),
+        by_priority: new Map(),
+        by_state: new Map(),
+        by_hour: new Map(),
+        common_keywords: new Map()
+    };
+    incidents.forEach((incident) => {
+        // Category
+        const category = incident.category || 'uncategorized';
+        patterns.by_category.set(category, (patterns.by_category.get(category) || 0) + 1);
+        // Priority
+        const priority = incident.priority || 'unknown';
+        patterns.by_priority.set(priority, (patterns.by_priority.get(priority) || 0) + 1);
+        // State
+        const state = incident.state || 'unknown';
+        patterns.by_state.set(state, (patterns.by_state.get(state) || 0) + 1);
+        // Time patterns
+        if (incident.sys_created_on) {
+            const hour = new Date(incident.sys_created_on).getHours();
+            patterns.by_hour.set(hour, (patterns.by_hour.get(hour) || 0) + 1);
+        }
+        // Keywords
+        const description = (incident.short_description || '').toLowerCase();
+        const keywords = description.split(/\s+/).filter((word) => word.length > 3);
+        keywords.slice(0, 5).forEach((keyword) => {
+            patterns.common_keywords.set(keyword, (patterns.common_keywords.get(keyword) || 0) + 1);
+        });
+    });
+    return {
+        total_incidents: incidents.length,
+        patterns: {
+            by_category: Object.fromEntries(patterns.by_category),
+            by_priority: Object.fromEntries(patterns.by_priority),
+            by_state: Object.fromEntries(patterns.by_state),
+            peak_hours: Array.from(patterns.by_hour.entries())
+                .sort((a, b) => b[1] - a[1])
+                .slice(0, 5)
+                .map(([hour, count]) => ({ hour, count })),
+            top_keywords: Array.from(patterns.common_keywords.entries())
+                .sort((a, b) => b[1] - a[1])
+                .slice(0, 10)
+                .map(([keyword, count]) => ({ keyword, count }))
+        }
+    };
+}
+async function analyzeRequestTrends(client, dateFilter) {
+    const response = await client.get('/api/now/table/sc_request', {
+        params: {
+            sysparm_query: `sys_created_on${dateFilter}`,
+            sysparm_limit: 1000
+        }
+    });
+    const requests = response.data.result || [];
+    const trends = {
+        by_state: new Map(),
+        by_approval: new Map()
+    };
+    requests.forEach((request) => {
+        const state = request.request_state || 'unknown';
+        trends.by_state.set(state, (trends.by_state.get(state) || 0) + 1);
+        const approval = request.approval || 'unknown';
+        trends.by_approval.set(approval, (trends.by_approval.get(approval) || 0) + 1);
+    });
+    return {
+        total_requests: requests.length,
+        trends: {
+            by_state: Object.fromEntries(trends.by_state),
+            by_approval_status: Object.fromEntries(trends.by_approval)
+        }
+    };
+}
+async function analyzeProblemRootCauses(client, dateFilter) {
+    const response = await client.get('/api/now/table/problem', {
+        params: {
+            sysparm_query: `sys_created_on${dateFilter}`,
+            sysparm_limit: 100
+        }
+    });
+    const problems = response.data.result || [];
+    const rootCauses = {
+        by_category: new Map(),
+        by_state: new Map()
+    };
+    problems.forEach((problem) => {
+        const category = problem.category || 'uncategorized';
+        rootCauses.by_category.set(category, (rootCauses.by_category.get(category) || 0) + 1);
+        const state = problem.state || 'unknown';
+        rootCauses.by_state.set(state, (rootCauses.by_state.get(state) || 0) + 1);
+    });
+    return {
+        total_problems: problems.length,
+        root_causes: {
+            by_category: Object.fromEntries(rootCauses.by_category),
+            by_state: Object.fromEntries(rootCauses.by_state)
+        }
+    };
+}
+async function analyzeUserBehavior(client, dateFilter) {
+    const incidentsResponse = await client.get('/api/now/table/incident', {
+        params: {
+            sysparm_query: `sys_created_on${dateFilter}`,
+            sysparm_limit: 500,
+            sysparm_fields: 'caller_id'
+        }
+    });
+    const incidents = incidentsResponse.data.result || [];
+    const userIncidents = new Map();
+    incidents.forEach((inc) => {
+        const userId = inc.caller_id?.value || inc.caller_id;
+        if (userId) {
+            userIncidents.set(userId, (userIncidents.get(userId) || 0) + 1);
+        }
+    });
+    return {
+        user_activities: {
+            total_incidents: incidents.length,
+            unique_users: userIncidents.size,
+            avg_incidents_per_user: userIncidents.size > 0
+                ? Math.round(incidents.length / userIncidents.size * 10) / 10
+                : 0
+        }
+    };
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_pattern_analysis.js.map

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

@@ -0,0 +1,11 @@
+/**
+ * snow_predictive_analysis - Predictive analysis
+ *
+ * Provides predictive analysis for incident volumes, system failures, and resource issues based on historical patterns.
+ */
+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_predictive_analysis.d.ts.map

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

@@ -0,0 +1,165 @@
+"use strict";
+/**
+ * snow_predictive_analysis - Predictive analysis
+ *
+ * Provides predictive analysis for incident volumes, system failures, and resource issues based on historical patterns.
+ */
+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_predictive_analysis',
+    description: 'Provides predictive analysis for incident volumes, system failures, and resource issues based on historical patterns',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            prediction_type: {
+                type: 'string',
+                description: 'Type of prediction',
+                enum: ['incident_volume', 'system_failure', 'resource_exhaustion', 'user_impact']
+            },
+            timeframe: {
+                type: 'string',
+                description: 'Prediction timeframe',
+                enum: ['day', 'week', 'month'],
+                default: 'week'
+            }
+        },
+        required: ['prediction_type']
+    }
+};
+function getHistoricalDateFilter(timeframe) {
+    const filters = {
+        day: 'ONLast 7 days@javascript:gs.daysAgoStart(7)@javascript:gs.daysAgoEnd(0)',
+        week: 'ONLast 30 days@javascript:gs.daysAgoStart(30)@javascript:gs.daysAgoEnd(0)',
+        month: 'ONLast 90 days@javascript:gs.daysAgoStart(90)@javascript:gs.daysAgoEnd(0)'
+    };
+    return filters[timeframe] || filters.week;
+}
+async function execute(args, context) {
+    const { prediction_type, timeframe = 'week' } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        const dateFilter = getHistoricalDateFilter(timeframe);
+        let predictions = {
+            prediction_type,
+            timeframe,
+            generated_at: new Date().toISOString(),
+            analysis_method: 'trend_analysis'
+        };
+        switch (prediction_type) {
+            case 'incident_volume':
+                predictions = { ...predictions, ...(await predictIncidentVolume(client, dateFilter, timeframe)) };
+                break;
+            case 'system_failure':
+                predictions = { ...predictions, ...(await predictSystemFailure(client, dateFilter, timeframe)) };
+                break;
+            case 'resource_exhaustion':
+                predictions = { ...predictions, ...(await predictResourceExhaustion(client, dateFilter, timeframe)) };
+                break;
+            case 'user_impact':
+                predictions = { ...predictions, ...(await predictUserImpact(client, dateFilter, timeframe)) };
+                break;
+            default:
+                return (0, error_handler_js_1.createErrorResult)(`Unknown prediction type: ${prediction_type}`);
+        }
+        return (0, error_handler_js_1.createSuccessResult)({ predictions }, { prediction_type, timeframe });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error.message);
+    }
+}
+async function predictIncidentVolume(client, dateFilter, timeframe) {
+    const response = await client.get('/api/now/table/incident', {
+        params: {
+            sysparm_query: `sys_created_on${dateFilter}`,
+            sysparm_limit: 1000,
+            sysparm_fields: 'sys_created_on,priority'
+        }
+    });
+    const incidents = response.data.result || [];
+    const dailyVolumes = new Map();
+    incidents.forEach((inc) => {
+        if (inc.sys_created_on) {
+            const date = inc.sys_created_on.split(' ')[0];
+            dailyVolumes.set(date, (dailyVolumes.get(date) || 0) + 1);
+        }
+    });
+    const volumes = Array.from(dailyVolumes.values());
+    const avgVolume = volumes.length > 0 ? volumes.reduce((a, b) => a + b, 0) / volumes.length : 0;
+    return {
+        historical_data: {
+            total_incidents: incidents.length,
+            average_daily_volume: Math.round(avgVolume),
+            peak_volume: Math.max(...volumes, 0),
+            low_volume: Math.min(...volumes, 0)
+        },
+        prediction: {
+            expected_volume: Math.round(avgVolume),
+            confidence: volumes.length >= 7 ? 'high' : 'low',
+            interpretation: `Based on ${volumes.length} days of data, expecting approximately ${Math.round(avgVolume)} incidents per ${timeframe}`
+        }
+    };
+}
+async function predictSystemFailure(client, dateFilter, timeframe) {
+    const response = await client.get('/api/now/table/incident', {
+        params: {
+            sysparm_query: `sys_created_on${dateFilter}^priority=1`,
+            sysparm_limit: 500
+        }
+    });
+    const criticalIncidents = response.data.result || [];
+    return {
+        historical_data: {
+            critical_incidents: criticalIncidents.length
+        },
+        prediction: {
+            risk_level: criticalIncidents.length > 10 ? 'high' : 'low',
+            interpretation: `Based on ${criticalIncidents.length} critical incidents, system failure risk is ${criticalIncidents.length > 10 ? 'elevated' : 'normal'}`
+        }
+    };
+}
+async function predictResourceExhaustion(client, dateFilter, timeframe) {
+    const requestsResponse = await client.get('/api/now/table/sc_request', {
+        params: {
+            sysparm_query: `sys_created_on${dateFilter}`,
+            sysparm_limit: 1000
+        }
+    });
+    const requests = requestsResponse.data.result || [];
+    return {
+        historical_data: {
+            total_requests: requests.length
+        },
+        prediction: {
+            risk_level: requests.length > 500 ? 'medium' : 'low',
+            interpretation: `Based on ${requests.length} service requests, resource demand is ${requests.length > 500 ? 'increasing' : 'stable'}`
+        }
+    };
+}
+async function predictUserImpact(client, dateFilter, timeframe) {
+    const response = await client.get('/api/now/table/incident', {
+        params: {
+            sysparm_query: `sys_created_on${dateFilter}`,
+            sysparm_limit: 1000,
+            sysparm_fields: 'caller_id,state'
+        }
+    });
+    const incidents = response.data.result || [];
+    const uniqueUsers = new Set(incidents.map((inc) => inc.caller_id?.value || inc.caller_id).filter(Boolean));
+    return {
+        historical_data: {
+            total_incidents: incidents.length,
+            affected_users: uniqueUsers.size
+        },
+        prediction: {
+            impact_level: uniqueUsers.size > 50 ? 'high' : 'medium',
+            interpretation: `${uniqueUsers.size} unique users affected. User impact is ${uniqueUsers.size > 50 ? 'widespread' : 'localized'}`
+        }
+    };
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_predictive_analysis.js.map

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

@@ -0,0 +1,12 @@
+/**
+ * snow_query_incidents - Query incidents
+ *
+ * Query incidents with advanced filtering and analysis capabilities.
+ * Optimized for performance with optional content inclusion.
+ */
+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_query_incidents.d.ts.map

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

@@ -0,0 +1,141 @@
+"use strict";
+/**
+ * snow_query_incidents - Query incidents
+ *
+ * Query incidents with advanced filtering and analysis capabilities.
+ * Optimized for performance with optional content inclusion.
+ */
+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_query_incidents',
+    description: 'Query incidents with advanced filtering and analysis capabilities. Optimized for performance with optional content inclusion.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            query: {
+                type: 'string',
+                description: 'ServiceNow encoded query or natural language description (e.g., "high priority", "open", "active=true^priority=1")'
+            },
+            limit: {
+                type: 'number',
+                description: 'Maximum number of results',
+                default: 10,
+                minimum: 1,
+                maximum: 1000
+            },
+            include_content: {
+                type: 'boolean',
+                description: 'Include full incident data. Default false for performance, returns count and summary only.',
+                default: false
+            },
+            include_analysis: {
+                type: 'boolean',
+                description: 'Include intelligent analysis of incidents (requires include_content=true)',
+                default: false
+            },
+            fields: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Specific fields to return (automatically sets include_content=true)',
+                examples: [['number', 'short_description', 'priority', 'state']]
+            }
+        },
+        required: ['query']
+    }
+};
+function processNaturalLanguageQuery(query) {
+    const lowerQuery = query.toLowerCase();
+    // If already a ServiceNow encoded query, return as-is
+    if (query.includes('=') || query.includes('!=') || query.includes('^') || query.includes('LIKE')) {
+        return query;
+    }
+    // Common patterns
+    if (lowerQuery.includes('high priority'))
+        return 'priority=1';
+    if (lowerQuery.includes('critical'))
+        return 'priority=1^ORseverity=1';
+    if (lowerQuery.includes('open') || lowerQuery.includes('active'))
+        return 'active=true^state!=6^state!=7';
+    if (lowerQuery.includes('closed') || lowerQuery.includes('resolved'))
+        return 'state=6^ORstate=7';
+    if (lowerQuery.includes('today'))
+        return 'sys_created_onONToday@javascript:gs.daysAgoStart(0)@javascript:gs.daysAgoEnd(0)';
+    if (lowerQuery.includes('all') || lowerQuery === '')
+        return '';
+    // Default: search in short_description
+    return `short_descriptionLIKE${query}^ORdescriptionLIKE${query}`;
+}
+async function execute(args, context) {
+    const { query, limit = 10, include_content = false, include_analysis = false, fields } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        // Process query
+        const processedQuery = processNaturalLanguageQuery(query);
+        // Build params
+        const params = {
+            sysparm_query: processedQuery,
+            sysparm_limit: limit
+        };
+        if (fields && fields.length > 0) {
+            params.sysparm_fields = fields.join(',');
+        }
+        // Execute query
+        const response = await client.get('/api/now/table/incident', { params });
+        const incidents = response.data.result || [];
+        let result = {
+            total_results: incidents.length,
+            query_used: processedQuery
+        };
+        // Include content if requested or fields specified
+        if (include_content || (fields && fields.length > 0)) {
+            result.incidents = incidents;
+        }
+        else {
+            // Performance mode: summary only
+            result.summary = {
+                count: incidents.length,
+                message: 'Use include_content=true to retrieve full incident data'
+            };
+            if (incidents.length > 0) {
+                result.summary.sample = {
+                    first_incident: incidents[0].number || 'Unknown',
+                    categories: [...new Set(incidents.slice(0, 5).map((inc) => inc.category || 'none'))],
+                    priorities: [...new Set(incidents.slice(0, 5).map((inc) => inc.priority || 'none'))],
+                    states: [...new Set(incidents.slice(0, 5).map((inc) => inc.state || 'unknown'))]
+                };
+            }
+        }
+        // Add analysis if requested
+        if (include_analysis && incidents.length > 0) {
+            const patterns = new Map();
+            const categories = new Map();
+            incidents.forEach((incident) => {
+                const category = incident.category || 'uncategorized';
+                categories.set(category, (categories.get(category) || 0) + 1);
+                const description = (incident.short_description || '').toLowerCase();
+                if (description.includes('network'))
+                    patterns.set('network_issues', (patterns.get('network_issues') || 0) + 1);
+                if (description.includes('database'))
+                    patterns.set('database_issues', (patterns.get('database_issues') || 0) + 1);
+                if (description.includes('password'))
+                    patterns.set('auth_issues', (patterns.get('auth_issues') || 0) + 1);
+            });
+            result.analysis = {
+                patterns_detected: Object.fromEntries(patterns),
+                category_distribution: Object.fromEntries(categories),
+                total_analyzed: incidents.length
+            };
+        }
+        return (0, error_handler_js_1.createSuccessResult)(result, { query: processedQuery, limit, count: incidents.length });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error.message);
+    }
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_query_incidents.js.map

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

@@ -0,0 +1,11 @@
+/**
+ * snow_query_problems - Query problems
+ *
+ * Queries problem records with root cause analysis and optional inclusion of related incidents.
+ */
+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_query_problems.d.ts.map

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

@@ -0,0 +1,115 @@
+"use strict";
+/**
+ * snow_query_problems - Query problems
+ *
+ * Queries problem records with root cause analysis and optional inclusion of related incidents.
+ */
+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_query_problems',
+    description: 'Queries problem records with root cause analysis and optional inclusion of related incidents',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            query: {
+                type: 'string',
+                description: 'ServiceNow encoded query or natural language (e.g., "open", "active=true", "high priority")'
+            },
+            limit: {
+                type: 'number',
+                description: 'Maximum number of results',
+                default: 10,
+                minimum: 1,
+                maximum: 100
+            },
+            include_incidents: {
+                type: 'boolean',
+                description: 'Include related incidents for each problem',
+                default: false
+            }
+        },
+        required: ['query']
+    }
+};
+function processNaturalLanguageQuery(query) {
+    const lowerQuery = query.toLowerCase();
+    // If already a ServiceNow encoded query, return as-is
+    if (query.includes('=') || query.includes('!=') || query.includes('^') || query.includes('LIKE')) {
+        return query;
+    }
+    // Common patterns
+    if (lowerQuery.includes('open') || lowerQuery.includes('active'))
+        return 'active=true^state!=4';
+    if (lowerQuery.includes('closed') || lowerQuery.includes('resolved'))
+        return 'state=4';
+    if (lowerQuery.includes('high priority'))
+        return 'priority=1';
+    if (lowerQuery.includes('all') || lowerQuery === '')
+        return '';
+    // Default: search in short_description
+    return `short_descriptionLIKE${query}`;
+}
+async function execute(args, context) {
+    const { query, limit = 10, include_incidents = false } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        // Process query
+        const processedQuery = processNaturalLanguageQuery(query);
+        // Query problems
+        const response = await client.get('/api/now/table/problem', {
+            params: {
+                sysparm_query: processedQuery,
+                sysparm_limit: limit
+            }
+        });
+        const problems = response.data.result || [];
+        let result = {
+            total_results: problems.length,
+            query_used: processedQuery,
+            problems: problems.map((problem) => ({
+                number: problem.number,
+                sys_id: problem.sys_id,
+                short_description: problem.short_description,
+                state: problem.state,
+                priority: problem.priority,
+                root_cause: problem.problem_statement,
+                known_error: problem.known_error
+            }))
+        };
+        // Include related incidents if requested
+        if (include_incidents && problems.length > 0) {
+            const relatedIncidents = [];
+            for (const problem of problems) {
+                const incidentResponse = await client.get('/api/now/table/incident', {
+                    params: {
+                        sysparm_query: `problem_id=${problem.sys_id}`,
+                        sysparm_limit: 10
+                    }
+                });
+                if (incidentResponse.data.result && incidentResponse.data.result.length > 0) {
+                    relatedIncidents.push({
+                        problem_number: problem.number,
+                        incident_count: incidentResponse.data.result.length,
+                        incidents: incidentResponse.data.result.map((inc) => ({
+                            number: inc.number,
+                            short_description: inc.short_description,
+                            state: inc.state
+                        }))
+                    });
+                }
+            }
+            result.related_incidents = relatedIncidents;
+        }
+        return (0, error_handler_js_1.createSuccessResult)(result, { query: processedQuery, limit, count: problems.length });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error.message);
+    }
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_query_problems.js.map

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

@@ -0,0 +1,11 @@
+/**
+ * snow_query_requests - Query service requests
+ *
+ * Queries service requests with optional inclusion of request items and fulfillment details.
+ */
+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_query_requests.d.ts.map