snow-flow 8.4.42 → 8.4.44

package/dist/mcp/servicenow-mcp-unified/tools/automation/snow_automation_discover.js

@@ -1,164 +0,0 @@
-"use strict";
-/**
- * snow_automation_discover - Unified Automation Discovery
- *
- * Replaces: snow_discover_automation_jobs, snow_discover_events, snow_discover_schedules
- */
-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_automation_discover',
-    description: 'Discover automation: jobs, events, schedules',
-    category: 'automation',
-    subcategory: 'script-execution',
-    use_cases: ['automation', 'monitoring', 'discovery'],
-    complexity: 'beginner',
-    frequency: 'high',
-    related_tools: ['snow_execute_script_with_output', 'snow_get_logs'],
-    inputSchema: {
-        type: 'object',
-        properties: {
-            action: {
-                type: 'string',
-                enum: ['jobs', 'events', 'schedules'],
-                description: 'Discovery type: jobs, events, or schedules'
-            },
-            active: { type: 'boolean', description: 'Filter by active status (jobs only)' },
-            table: { type: 'string', description: 'Filter by table name (events only)' },
-            type: { type: 'string', description: 'Filter by type (schedules only)' },
-            nameContains: { type: 'string', description: 'Search by name pattern' },
-            limit: { type: 'number', description: 'Maximum results', default: 50 }
-        },
-        required: ['action']
-    }
-};
-
-async function execute(args, context) {
-    const { action, active, table, type, nameContains, limit = 50 } = args;
-
-    try {
-        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
-
-        switch (action) {
-            case 'jobs':
-                return await discoverJobs(client, active, nameContains, limit);
-            case 'events':
-                return await discoverEvents(client, table, nameContains, limit);
-            case 'schedules':
-                return await discoverSchedules(client, type, nameContains, limit);
-            default:
-                return (0, error_handler_js_1.createErrorResult)(`Unknown action: ${action}`);
-        }
-    } catch (error) {
-        return (0, error_handler_js_1.createErrorResult)(error instanceof error_handler_js_1.SnowFlowError
-            ? error
-            : new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.UNKNOWN_ERROR, error.message, { originalError: error }));
-    }
-}
-
-async function discoverJobs(client, active, nameContains, limit) {
-    const queryParts = [];
-    if (active !== undefined) {
-        queryParts.push(`active=${active}`);
-    }
-    if (nameContains) {
-        queryParts.push(`nameLIKE${nameContains}`);
-    }
-    const query = queryParts.join('^');
-
-    const response = await client.get(`/api/now/table/sysauto_script?sysparm_query=${query}&sysparm_limit=${limit}&sysparm_display_value=true`);
-    const jobs = response.data.result;
-
-    const formattedJobs = jobs.map((job) => ({
-        sys_id: job.sys_id,
-        name: job.name,
-        description: job.description,
-        active: job.active === 'true',
-        run_type: job.run_type,
-        run_start: job.run_start,
-        run_dayofweek: job.run_dayofweek,
-        run_time: job.run_time,
-        script: job.script ? '(script present)' : null,
-        created_on: job.sys_created_on,
-        updated_on: job.sys_updated_on
-    }));
-
-    return (0, error_handler_js_1.createSuccessResult)({
-        action: 'jobs',
-        found: true,
-        count: formattedJobs.length,
-        jobs: formattedJobs
-    });
-}
-
-async function discoverEvents(client, table, nameContains, limit) {
-    const queryParts = [];
-    if (table) {
-        queryParts.push(`table=${table}`);
-    }
-    if (nameContains) {
-        queryParts.push(`event_nameLIKE${nameContains}`);
-    }
-    const query = queryParts.join('^');
-
-    const response = await client.get(`/api/now/table/sysevent_register?sysparm_query=${query}&sysparm_limit=${limit}&sysparm_display_value=true`);
-    const events = response.data.result;
-
-    const formattedEvents = events.map((event) => ({
-        sys_id: event.sys_id,
-        event_name: event.event_name,
-        table: event.table || null,
-        description: event.description,
-        queue: event.queue,
-        claimed_by: event.claimed_by || null,
-        state: event.state,
-        created_on: event.sys_created_on
-    }));
-
-    return (0, error_handler_js_1.createSuccessResult)({
-        action: 'events',
-        found: true,
-        count: formattedEvents.length,
-        events: formattedEvents
-    });
-}
-
-async function discoverSchedules(client, type, nameContains, limit) {
-    const queryParts = [];
-    if (type) {
-        queryParts.push(`type=${type}`);
-    }
-    if (nameContains) {
-        queryParts.push(`nameLIKE${nameContains}`);
-    }
-    const query = queryParts.join('^');
-
-    const response = await client.get(`/api/now/table/cmn_schedule?sysparm_query=${query}&sysparm_limit=${limit}&sysparm_display_value=true`);
-    const schedules = response.data.result;
-
-    const formattedSchedules = schedules.map((schedule) => ({
-        sys_id: schedule.sys_id,
-        name: schedule.name,
-        description: schedule.description,
-        type: schedule.type,
-        time_zone: schedule.time_zone,
-        parent_schedule: schedule.parent?.display_value || null,
-        created_on: schedule.sys_created_on,
-        updated_on: schedule.sys_updated_on
-    }));
-
-    return (0, error_handler_js_1.createSuccessResult)({
-        action: 'schedules',
-        found: true,
-        count: formattedSchedules.length,
-        schedules: formattedSchedules
-    });
-}
-
-exports.version = '1.0.0';
-exports.author = 'Snow-Flow MCP Optimization';
-//# sourceMappingURL=snow_automation_discover.js.map

package/dist/mcp/servicenow-mcp-unified/tools/deployment/snow_artifact_transfer.js

@@ -1,282 +0,0 @@
-"use strict";
-/**
- * snow_artifact_transfer - Unified Artifact Import/Export
- *
- * Replaces: snow_export_artifact, snow_import_artifact
- */
-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;
-    };
-})();
-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"));
-
-exports.toolDefinition = {
-    name: 'snow_artifact_transfer',
-    description: 'Transfer artifacts: export to JSON/XML, import from files',
-    category: 'development',
-    subcategory: 'deployment',
-    use_cases: ['deployment', 'backup', 'migration', 'version-control'],
-    complexity: 'intermediate',
-    frequency: 'high',
-    related_tools: ['snow_deploy', 'snow_update', 'snow_validate_deployment'],
-    inputSchema: {
-        type: 'object',
-        properties: {
-            action: {
-                type: 'string',
-                enum: ['export', 'import'],
-                description: 'Transfer action: export or import'
-            },
-            type: {
-                type: 'string',
-                enum: ['widget', 'application', 'script', 'business_rule', 'table'],
-                description: 'Artifact type'
-            },
-            sys_id: {
-                type: 'string',
-                description: 'Sys ID (required for export)'
-            },
-            file_path: {
-                type: 'string',
-                description: 'File path (required for import)'
-            },
-            format: {
-                type: 'string',
-                enum: ['json', 'xml', 'update_set'],
-                default: 'json',
-                description: 'Export/import format'
-            }
-        },
-        required: ['action', 'type']
-    }
-};
-
-async function execute(args, context) {
-    const { action, type, sys_id, file_path, format = 'json' } = args;
-
-    try {
-        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
-
-        switch (action) {
-            case 'export':
-                if (!sys_id) {
-                    throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.INVALID_REQUEST, 'sys_id is required for export action', { retryable: false });
-                }
-                return await exportArtifact(client, type, sys_id, format);
-            case 'import':
-                if (!file_path) {
-                    throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.INVALID_REQUEST, 'file_path is required for import action', { retryable: false });
-                }
-                return await importArtifact(client, type, file_path, format);
-            default:
-                return (0, error_handler_js_1.createErrorResult)(`Unknown action: ${action}`);
-        }
-    } catch (error) {
-        return (0, error_handler_js_1.createErrorResult)(error instanceof error_handler_js_1.SnowFlowError
-            ? error
-            : new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.NETWORK_ERROR, `Transfer failed: ${error.message}`, { originalError: error }));
-    }
-}
-
-async function exportArtifact(client, type, sys_id, format) {
-    const tableMap = {
-        widget: 'sp_widget',
-        application: 'sys_app',
-        script: 'sys_script_include',
-        business_rule: 'sys_script',
-        table: 'sys_db_object'
-    };
-
-    const tableName = tableMap[type];
-    if (!tableName) {
-        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.INVALID_REQUEST, `Unsupported artifact type: ${type}`, { retryable: false });
-    }
-
-    const response = await client.get(`/api/now/table/${tableName}/${sys_id}`);
-    const artifact = response.data.result;
-
-    if (!artifact) {
-        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.RESOURCE_NOT_FOUND, `Artifact not found: ${sys_id}`, { retryable: false });
-    }
-
-    let exportedData;
-    switch (format) {
-        case 'json':
-            exportedData = {
-                type,
-                sys_id: artifact.sys_id,
-                name: artifact.name || artifact.id,
-                exported_at: new Date().toISOString(),
-                data: artifact
-            };
-            break;
-        case 'xml':
-            exportedData = artifactToXML(artifact, type);
-            break;
-        case 'update_set':
-            const updateSetResponse = await client.get('/api/now/table/sys_update_xml', {
-                params: {
-                    sysparm_query: `target_name=${artifact.sys_id}`,
-                    sysparm_limit: 10
-                }
-            });
-            exportedData = {
-                type,
-                sys_id: artifact.sys_id,
-                name: artifact.name || artifact.id,
-                update_sets: updateSetResponse.data.result
-            };
-            break;
-        default:
-            throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.INVALID_REQUEST, `Unsupported format: ${format}`, { retryable: false });
-    }
-
-    return (0, error_handler_js_1.createSuccessResult)({
-        action: 'export',
-        artifact: exportedData,
-        format,
-        table: tableName,
-        sys_id,
-        name: artifact.name || artifact.id,
-        message: `✅ Artifact exported successfully (${type}, ${format})`
-    });
-}
-
-async function importArtifact(client, type, file_path, format) {
-    const fileContent = await fs.readFile(file_path, 'utf-8');
-    let artifactData;
-
-    switch (format) {
-        case 'json':
-            artifactData = JSON.parse(fileContent);
-            if (artifactData.data) {
-                artifactData = artifactData.data;
-            }
-            break;
-        case 'xml':
-            artifactData = parseSimpleXML(fileContent);
-            break;
-        case 'update_set':
-            throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.INVALID_REQUEST, 'Update set import requires XML format and should use snow_import_update_set tool', { retryable: false });
-        default:
-            throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.INVALID_REQUEST, `Unsupported format: ${format}`, { retryable: false });
-    }
-
-    const tableMap = {
-        widget: 'sp_widget',
-        application: 'sys_app',
-        script: 'sys_script_include',
-        business_rule: 'sys_script',
-        table: 'sys_db_object'
-    };
-
-    const tableName = tableMap[type];
-    if (!tableName) {
-        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.INVALID_REQUEST, `Unsupported artifact type: ${type}`, { retryable: false });
-    }
-
-    const cleanedData = { ...artifactData };
-    delete cleanedData.sys_id;
-    delete cleanedData.sys_created_on;
-    delete cleanedData.sys_created_by;
-    delete cleanedData.sys_updated_on;
-    delete cleanedData.sys_updated_by;
-    delete cleanedData.sys_mod_count;
-
-    const existingResponse = await client.get(`/api/now/table/${tableName}`, {
-        params: {
-            sysparm_query: `name=${cleanedData.name || cleanedData.id}`,
-            sysparm_limit: 1
-        }
-    });
-
-    let result;
-    if (existingResponse.data.result.length > 0) {
-        const existingSysId = existingResponse.data.result[0].sys_id;
-        const updateResponse = await client.put(`/api/now/table/${tableName}/${existingSysId}`, cleanedData);
-        result = {
-            action: 'import',
-            operation: 'updated',
-            sys_id: existingSysId,
-            artifact: updateResponse.data.result,
-            message: `✅ Artifact updated successfully (${type})`
-        };
-    } else {
-        const createResponse = await client.post(`/api/now/table/${tableName}`, cleanedData);
-        result = {
-            action: 'import',
-            operation: 'created',
-            sys_id: createResponse.data.result.sys_id,
-            artifact: createResponse.data.result,
-            message: `✅ Artifact created successfully (${type})`
-        };
-    }
-
-    return (0, error_handler_js_1.createSuccessResult)(result);
-}
-
-function artifactToXML(artifact, type) {
-    const xmlParts = ['<?xml version="1.0" encoding="UTF-8"?>'];
-    xmlParts.push(`<${type}>`);
-    for (const [key, value] of Object.entries(artifact)) {
-        if (value !== null && value !== undefined) {
-            const escaped = String(value).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-            xmlParts.push(`  <${key}>${escaped}</${key}>`);
-        }
-    }
-    xmlParts.push(`</${type}>`);
-    return xmlParts.join('\n');
-}
-
-function parseSimpleXML(xml) {
-    const result = {};
-    const tagRegex = /<(\w+)>([^<]*)<\/\1>/g;
-    let match;
-    while ((match = tagRegex.exec(xml)) !== null) {
-        const key = match[1];
-        const value = match[2]
-            .replace(/&lt;/g, '<')
-            .replace(/&gt;/g, '>')
-            .replace(/&amp;/g, '&');
-        result[key] = value;
-    }
-    return result;
-}
-
-exports.version = '1.0.0';
-exports.author = 'Snow-Flow MCP Optimization';
-//# sourceMappingURL=snow_artifact_transfer.js.map

package/dist/mcp/servicenow-mcp-unified/tools/filters/snow_build_filter.js

@@ -1,171 +0,0 @@
-"use strict";
-/**
- * snow_build_filter - Build ServiceNow query filters
- *
- * Unified tool for building encoded query filters: date filters, field filters, and complex queries.
- * Replaces: snow_date_filter, snow_field_filter, snow_query_filter
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.author = exports.version = exports.toolDefinition = void 0;
-exports.execute = execute;
-const error_handler_js_1 = require("../../shared/error-handler.js");
-exports.toolDefinition = {
-    name: 'snow_build_filter',
-    description: 'Build ServiceNow query filters: date, field, complex queries',
-    // Metadata for tool discovery (not sent to LLM)
-    category: 'utilities',
-    subcategory: 'query-building',
-    use_cases: ["query-building", "filtering", "data-retrieval"],
-    complexity: 'beginner',
-    frequency: 'very-high',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            filter_type: {
-                type: 'string',
-                enum: ['date', 'field', 'query'],
-                description: 'Filter type: date, field, or query'
-            },
-            // Common
-            field: {
-                type: 'string',
-                description: 'Field name (date/field filters)'
-            },
-            // Date filter-specific
-            relative: {
-                type: 'string',
-                enum: ['today', 'yesterday', 'thisWeek', 'lastWeek', 'thisMonth', 'lastMonth'],
-                description: 'Relative date (date filter only)'
-            },
-            start_date: {
-                type: 'string',
-                description: 'Start date YYYY-MM-DD (date filter only)'
-            },
-            end_date: {
-                type: 'string',
-                description: 'End date YYYY-MM-DD (date filter only)'
-            },
-            // Field filter-specific
-            values: {
-                type: 'array',
-                items: { type: 'string' },
-                description: 'Values to filter (field filter only)'
-            },
-            match_type: {
-                type: 'string',
-                enum: ['exact', 'contains', 'startsWith', 'endsWith'],
-                description: 'Match type (field filter only)',
-                default: 'exact'
-            },
-            // Query filter-specific
-            conditions: {
-                type: 'array',
-                items: {
-                    type: 'object',
-                    properties: {
-                        field: { type: 'string' },
-                        operator: { type: 'string', enum: ['=', '!=', '>', '<', '>=', '<=', 'LIKE', 'IN', 'STARTSWITH', 'ENDSWITH'] },
-                        value: { type: 'string' }
-                    }
-                },
-                description: 'Filter conditions (query filter only)'
-            },
-            logic: {
-                type: 'string',
-                enum: ['AND', 'OR'],
-                description: 'Condition logic (query filter only)',
-                default: 'AND'
-            }
-        },
-        required: ['filter_type']
-    }
-};
-async function execute(args, context) {
-    const { filter_type } = args;
-    try {
-        switch (filter_type) {
-            case 'date':
-                return buildDateFilter(args);
-            case 'field':
-                return buildFieldFilter(args);
-            case 'query':
-                return buildQueryFilter(args);
-            default:
-                return (0, error_handler_js_1.createErrorResult)(`Invalid filter_type: ${filter_type}`);
-        }
-    }
-    catch (error) {
-        return (0, error_handler_js_1.createErrorResult)(error.message);
-    }
-}
-function buildDateFilter(args) {
-    const { field, relative, start_date, end_date } = args;
-    if (!field) {
-        return (0, error_handler_js_1.createErrorResult)('field is required for date filter');
-    }
-    let query = '';
-    if (relative) {
-        const relativeQueries = {
-            'today': `${field}ON Today`,
-            'yesterday': `${field}ON Yesterday`,
-            'thisWeek': `${field}ON This week`,
-            'lastWeek': `${field}ON Last week`,
-            'thisMonth': `${field}ON This month`,
-            'lastMonth': `${field}ON Last month`
-        };
-        query = relativeQueries[relative] || '';
-    }
-    else if (start_date && end_date) {
-        query = `${field}BETWEEN${start_date}@${end_date}`;
-    }
-    else if (start_date) {
-        query = `${field}>=${start_date}`;
-    }
-    else if (end_date) {
-        query = `${field}<=${end_date}`;
-    }
-    return (0, error_handler_js_1.createSuccessResult)({
-        query,
-        field,
-        type: relative ? 'relative' : 'absolute'
-    });
-}
-function buildFieldFilter(args) {
-    const { field, values, match_type = 'exact' } = args;
-    if (!field) {
-        return (0, error_handler_js_1.createErrorResult)('field is required for field filter');
-    }
-    if (!values || values.length === 0) {
-        return (0, error_handler_js_1.createErrorResult)('values are required for field filter');
-    }
-    const operatorMap = {
-        'exact': '=',
-        'contains': 'LIKE',
-        'startsWith': 'STARTSWITH',
-        'endsWith': 'ENDSWITH'
-    };
-    const operator = operatorMap[match_type];
-    const query = values.map(val => `${field}${operator}${val}`).join('^OR');
-    return (0, error_handler_js_1.createSuccessResult)({
-        query,
-        field,
-        match_type,
-        value_count: values.length
-    });
-}
-function buildQueryFilter(args) {
-    const { conditions, logic = 'AND' } = args;
-    if (!conditions || conditions.length === 0) {
-        return (0, error_handler_js_1.createErrorResult)('conditions are required for query filter');
-    }
-    const separator = logic === 'AND' ? '^' : '^OR';
-    const query = conditions.map((cond) => `${cond.field}${cond.operator}${cond.value}`).join(separator);
-    return (0, error_handler_js_1.createSuccessResult)({
-        query,
-        conditions: conditions.length,
-        logic
-    });
-}
-exports.version = '1.0.0';
-exports.author = 'Snow-Flow v8.2.0';
-//# sourceMappingURL=snow_build_filter.js.map