snow-flow 2.6.4 → 2.6.6

package/dist/mcp/servicenow-flow-composer-mcp-refactored.d.ts

@@ -1,25 +0,0 @@
-#!/usr/bin/env node
-/**
- * servicenow-flow-composer MCP Server - REFACTORED
- * Uses BaseMCPServer to eliminate code duplication
- */
-import { BaseMCPServer, ToolResult } from './base-mcp-server.js';
-import { Tool } from '@modelcontextprotocol/sdk/types.js';
-export declare class ServiceNowFlowComposerMCP extends BaseMCPServer {
-    private flowClient;
-    private flowOAuth;
-    constructor();
-    protected setupTools(): void;
-    protected getTools(): Tool[];
-    protected executeTool(name: string, args: any): Promise<ToolResult>;
-    private handleSnowCreateFlow;
-    private handleSnowAnalyzeFlowInstruction;
-    private handleSnowDiscoverFlowArtifacts;
-    private handleSnowPreviewFlowStructure;
-    private handleSnowDeployComposedFlow;
-    private handleSnowIntelligentFlowAnalysis;
-    private handleSnowScopeOptimization;
-    private handleSnowTemplateMatching;
-    private extractFlowName;
-}
-//# sourceMappingURL=servicenow-flow-composer-mcp-refactored.d.ts.map

package/dist/mcp/servicenow-flow-composer-mcp-refactored.js

@@ -1,565 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-/**
- * servicenow-flow-composer MCP Server - REFACTORED
- * Uses BaseMCPServer to eliminate code duplication
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServiceNowFlowComposerMCP = void 0;
-const base_mcp_server_js_1 = require("./base-mcp-server.js");
-const servicenow_client_js_1 = require("../utils/servicenow-client.js");
-const snow_oauth_js_1 = require("../utils/snow-oauth.js");
-class ServiceNowFlowComposerMCP extends base_mcp_server_js_1.BaseMCPServer {
-    constructor() {
-        super({
-            name: 'servicenow-flow-composer',
-            version: '2.0.0',
-            description: 'Natural language flow creation with multi-artifact orchestration'
-        });
-        // Initialize flow-specific clients
-        this.flowClient = new servicenow_client_js_1.ServiceNowClient();
-        this.flowOAuth = new snow_oauth_js_1.ServiceNowOAuth();
-    }
-    setupTools() {
-        // Tools are defined in getTools() method
-    }
-    getTools() {
-        return [
-            {
-                name: 'snow_create_flow',
-                description: 'FULLY AUTONOMOUS flow creation - parses natural language, discovers artifacts, creates missing components, links everything, deploys automatically. ZERO MANUAL WORK!',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        instruction: {
-                            type: 'string',
-                            description: 'Natural language instruction for the flow'
-                        },
-                        deploy_immediately: {
-                            type: 'boolean',
-                            description: '⚠️ DEPLOYMENT MODE - true: Deploy REAL flow to ServiceNow immediately | false: Planning mode only',
-                            default: true
-                        },
-                        create_missing_artifacts: {
-                            type: 'boolean',
-                            description: 'Create missing artifacts as fallbacks',
-                            default: true
-                        },
-                        scope_preference: {
-                            type: 'string',
-                            enum: ['global', 'application', 'auto'],
-                            description: 'Preferred deployment scope',
-                            default: 'auto'
-                        },
-                        enable_intelligent_analysis: {
-                            type: 'boolean',
-                            description: 'Enable intelligent flow vs subflow analysis',
-                            default: true
-                        },
-                        validation_level: {
-                            type: 'string',
-                            enum: ['basic', 'standard', 'comprehensive'],
-                            description: 'Level of validation to perform',
-                            default: 'standard'
-                        }
-                    },
-                    required: ['instruction']
-                }
-            },
-            {
-                name: 'snow_analyze_flow_instruction',
-                description: 'AUTONOMOUS analysis - understands complex requirements, identifies all needed artifacts, plans optimal flow structure. SELF-LEARNING from patterns.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        instruction: {
-                            type: 'string',
-                            description: 'Natural language instruction to analyze'
-                        }
-                    },
-                    required: ['instruction']
-                }
-            },
-            {
-                name: 'snow_discover_flow_artifacts',
-                description: 'AUTONOMOUS discovery - finds all required artifacts, creates missing ones, ensures compatibility. INTELLIGENT DEPENDENCY RESOLUTION!',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        instruction: {
-                            type: 'string',
-                            description: 'Natural language instruction'
-                        },
-                        artifact_types: {
-                            type: 'array',
-                            items: {
-                                type: 'string',
-                                enum: ['script_include', 'business_rule', 'table', 'widget', 'ui_script']
-                            },
-                            description: 'Specific artifact types to search for'
-                        }
-                    },
-                    required: ['instruction']
-                }
-            },
-            {
-                name: 'snow_preview_flow_structure',
-                description: 'Preview the flow structure before deployment',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        instruction: {
-                            type: 'string',
-                            description: 'Natural language instruction'
-                        }
-                    },
-                    required: ['instruction']
-                }
-            },
-            {
-                name: 'snow_deploy_composed_flow',
-                description: 'Deploy a previously composed flow with all its artifacts',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        flow_instruction: {
-                            type: 'object',
-                            description: 'Previously composed flow instruction object'
-                        },
-                        validation_required: {
-                            type: 'boolean',
-                            description: 'Validate all artifacts before deployment',
-                            default: true
-                        }
-                    },
-                    required: ['flow_instruction']
-                }
-            },
-            {
-                name: 'snow_intelligent_flow_analysis',
-                description: 'INTELLIGENT ANALYSIS - Performs comprehensive flow vs subflow analysis with decision rationale and recommendations',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        instruction: {
-                            type: 'string',
-                            description: 'Natural language instruction to analyze'
-                        },
-                        include_templates: {
-                            type: 'boolean',
-                            description: 'Include template matching analysis',
-                            default: true
-                        },
-                        include_validation: {
-                            type: 'boolean',
-                            description: 'Include validation analysis',
-                            default: true
-                        }
-                    },
-                    required: ['instruction']
-                }
-            },
-            {
-                name: 'snow_scope_optimization',
-                description: 'SCOPE OPTIMIZATION - Analyzes and recommends optimal deployment scope with fallback strategies',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        artifact_type: {
-                            type: 'string',
-                            description: 'Type of artifact to analyze'
-                        },
-                        artifact_data: {
-                            type: 'object',
-                            description: 'Artifact data for analysis'
-                        },
-                        environment_type: {
-                            type: 'string',
-                            enum: ['development', 'testing', 'production'],
-                            description: 'Target environment type',
-                            default: 'development'
-                        }
-                    },
-                    required: ['artifact_type', 'artifact_data']
-                }
-            },
-            {
-                name: 'snow_template_matching',
-                description: 'TEMPLATE MATCHING - Finds and applies best matching flow templates for common patterns',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        instruction: {
-                            type: 'string',
-                            description: 'Natural language instruction'
-                        },
-                        template_categories: {
-                            type: 'array',
-                            items: {
-                                type: 'string',
-                                enum: ['approval', 'fulfillment', 'notification', 'integration', 'utility']
-                            },
-                            description: 'Template categories to search'
-                        },
-                        minimum_confidence: {
-                            type: 'number',
-                            description: 'Minimum confidence threshold for template matching',
-                            default: 0.6
-                        }
-                    },
-                    required: ['instruction']
-                }
-            }
-        ];
-    }
-    async executeTool(name, args) {
-        const startTime = Date.now();
-        switch (name) {
-            case 'snow_create_flow':
-                return await this.handleSnowCreateFlow(args);
-            case 'snow_analyze_flow_instruction':
-                return await this.handleSnowAnalyzeFlowInstruction(args);
-            case 'snow_discover_flow_artifacts':
-                return await this.handleSnowDiscoverFlowArtifacts(args);
-            case 'snow_preview_flow_structure':
-                return await this.handleSnowPreviewFlowStructure(args);
-            case 'snow_deploy_composed_flow':
-                return await this.handleSnowDeployComposedFlow(args);
-            case 'snow_intelligent_flow_analysis':
-                return await this.handleSnowIntelligentFlowAnalysis(args);
-            case 'snow_scope_optimization':
-                return await this.handleSnowScopeOptimization(args);
-            case 'snow_template_matching':
-                return await this.handleSnowTemplateMatching(args);
-            default:
-                return {
-                    success: false,
-                    error: `Unknown tool: ${name}`
-                };
-        }
-    }
-    // Tool handlers
-    async handleSnowCreateFlow(args) {
-        const startTime = Date.now();
-        try {
-            // Input validation
-            if (!args.instruction || typeof args.instruction !== 'string' || args.instruction.trim().length === 0) {
-                return {
-                    success: false,
-                    error: 'Invalid Input: Instruction is required and must be a non-empty string.'
-                };
-            }
-            if (args.instruction.length > 2000) {
-                return {
-                    success: false,
-                    error: 'Invalid Input: Instruction is too long (maximum 2000 characters).'
-                };
-            }
-            this.logger.info('Creating flow using direct ServiceNowClient', { instruction: args.instruction });
-            // Parse natural language instruction
-            const flowName = this.extractFlowName(args.instruction);
-            const flowDescription = args.instruction;
-            // Create basic flow structure
-            const flowData = {
-                name: flowName,
-                description: flowDescription,
-                trigger_type: 'manual',
-                activities: [
-                    {
-                        name: 'Send Notification',
-                        type: 'notification',
-                        inputs: {
-                            recipient: 'admin@test.nl',
-                            subject: 'Flow Notification',
-                            message: `Flow created: ${flowName}`
-                        }
-                    }
-                ]
-            };
-            // Deploy if requested
-            let deploymentResult = null;
-            if (args.deploy_immediately !== false) {
-                console.log('🔧 DEPLOYING via direct ServiceNowClient.createFlow');
-                deploymentResult = await this.flowClient.createFlow(flowData);
-                console.log('🔧 Direct deployment result:', deploymentResult);
-            }
-            const credentials = await this.flowOAuth.loadCredentials();
-            const flowUrl = `https://${credentials?.instance}/flow-designer/flow/${flowName}`;
-            return {
-                success: true,
-                result: {
-                    flowName,
-                    flowDescription,
-                    deploymentResult,
-                    flowUrl,
-                    deployed: args.deploy_immediately !== false && deploymentResult?.success
-                },
-                executionTime: Date.now() - startTime
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Flow creation failed',
-                executionTime: Date.now() - startTime
-            };
-        }
-    }
-    async handleSnowAnalyzeFlowInstruction(args) {
-        const startTime = Date.now();
-        try {
-            this.logger.info('Analyzing flow instruction', { instruction: args.instruction });
-            // Simplified analysis for refactored version
-            const flowName = this.extractFlowName(args.instruction);
-            const analysis = {
-                parsedIntent: {
-                    flowName,
-                    table: 'task',
-                    trigger: { type: 'manual', condition: 'None' },
-                    intents: ['create_flow'],
-                    dataFlow: ['input', 'process', 'output']
-                },
-                requiredArtifacts: [],
-                flowStructure: {
-                    name: flowName,
-                    activities: 1,
-                    variables: 0,
-                    error_handling: 0
-                }
-            };
-            return {
-                success: true,
-                result: analysis,
-                executionTime: Date.now() - Date.now()
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Flow instruction analysis failed'
-            };
-        }
-    }
-    async handleSnowDiscoverFlowArtifacts(args) {
-        try {
-            this.logger.info('Discovering flow artifacts', { instruction: args.instruction });
-            // Simplified artifact discovery
-            const artifacts = [
-                {
-                    type: 'script_include',
-                    purpose: 'Core flow logic',
-                    searchQuery: args.instruction,
-                    required: true,
-                    fallbackAction: 'Create new'
-                }
-            ];
-            // Filter by requested types if specified
-            const filteredArtifacts = args.artifact_types && args.artifact_types.length > 0
-                ? artifacts.filter(a => args.artifact_types.includes(a.type))
-                : artifacts;
-            return {
-                success: true,
-                result: { artifacts: filteredArtifacts },
-                executionTime: Date.now() - Date.now()
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Artifact discovery failed'
-            };
-        }
-    }
-    async handleSnowPreviewFlowStructure(args) {
-        try {
-            this.logger.info('Previewing flow structure', { instruction: args.instruction });
-            const flowName = this.extractFlowName(args.instruction);
-            const flowStructure = {
-                name: flowName,
-                description: `Flow for: ${args.instruction}`,
-                trigger: { type: 'manual', table: 'task', condition: '' },
-                variables: [],
-                activities: [
-                    {
-                        id: 'activity_1',
-                        name: 'Process Step',
-                        type: 'custom',
-                        inputs: { data: 'input' },
-                        outputs: { result: 'processed' }
-                    }
-                ],
-                error_handling: []
-            };
-            return {
-                success: true,
-                result: { flowStructure },
-                executionTime: Date.now() - Date.now()
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Flow structure preview failed'
-            };
-        }
-    }
-    async handleSnowDeployComposedFlow(args) {
-        try {
-            this.logger.info('Deploying composed flow', { flow: args.flow_instruction });
-            // Simulate deployment
-            const deploymentResult = {
-                success: true,
-                message: 'Flow deployed successfully',
-                flowName: args.flow_instruction?.flowStructure?.name || 'Unknown'
-            };
-            return {
-                success: true,
-                result: deploymentResult,
-                executionTime: Date.now() - Date.now()
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Flow deployment failed'
-            };
-        }
-    }
-    async handleSnowIntelligentFlowAnalysis(args) {
-        try {
-            this.logger.info('Performing intelligent flow analysis', { instruction: args.instruction });
-            const analysisResult = {
-                decision: {
-                    recommendedType: 'flow',
-                    confidence: 0.85,
-                    rationale: 'Standard flow pattern detected'
-                },
-                complexity: 'medium',
-                reusability: 'high',
-                context: 'business_process',
-                validation: {
-                    isValid: true,
-                    score: 8,
-                    maxScore: 10
-                },
-                templates: {
-                    matchCount: 2,
-                    bestMatch: 'standard_approval_flow',
-                    confidence: 0.75
-                },
-                subflowCandidates: 1,
-                alternatives: []
-            };
-            return {
-                success: true,
-                result: analysisResult,
-                executionTime: Date.now() - Date.now()
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Intelligent flow analysis failed'
-            };
-        }
-    }
-    async handleSnowScopeOptimization(args) {
-        try {
-            this.logger.info('Performing scope optimization analysis', {
-                artifactType: args.artifact_type,
-                environmentType: args.environment_type
-            });
-            const scopeAnalysis = {
-                selectedScope: 'global',
-                confidence: 0.9,
-                rationale: 'Global scope provides maximum flexibility and reusability',
-                fallbackScope: 'application',
-                validationResult: {
-                    permissions: 'Valid',
-                    compliance: 'Compliant',
-                    dependencies: 'Resolved'
-                },
-                recommendations: [
-                    'Deploy to global scope for maximum reusability',
-                    'Ensure proper naming conventions',
-                    'Document scope decision for future reference'
-                ]
-            };
-            return {
-                success: true,
-                result: scopeAnalysis,
-                executionTime: Date.now() - Date.now()
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Scope optimization failed'
-            };
-        }
-    }
-    async handleSnowTemplateMatching(args) {
-        try {
-            this.logger.info('Performing template matching', {
-                instruction: args.instruction,
-                minimumConfidence: args.minimum_confidence || 0.6
-            });
-            const matchingResults = [
-                {
-                    template: {
-                        name: 'Standard Approval Flow',
-                        category: 'approval',
-                        description: 'Basic approval workflow template',
-                        triggers: ['request_created'],
-                        activities: 3,
-                        variables: 2,
-                        customizable: true
-                    },
-                    confidence: 0.8,
-                    matchingReasons: ['Keyword match: approval', 'Pattern similarity'],
-                    scores: {
-                        keywords: 0.9,
-                        intent: 0.8,
-                        structure: 0.7,
-                        context: 0.8
-                    }
-                }
-            ];
-            // Filter by confidence and categories
-            const filteredResults = matchingResults.filter(result => result.confidence >= (args.minimum_confidence || 0.6) &&
-                (!args.template_categories || args.template_categories.includes(result.template.category)));
-            return {
-                success: true,
-                result: { templates: filteredResults },
-                executionTime: Date.now() - Date.now()
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Template matching failed'
-            };
-        }
-    }
-    // Helper methods
-    extractFlowName(instruction) {
-        const words = instruction.toLowerCase().split(' ');
-        if (words.includes('incident'))
-            return 'Incident Flow';
-        if (words.includes('user') || words.includes('gebruiker'))
-            return 'User Flow';
-        if (words.includes('request') || words.includes('aanvraag'))
-            return 'Request Flow';
-        if (words.includes('notification'))
-            return 'Notification Flow';
-        if (words.includes('approval'))
-            return 'Approval Flow';
-        return 'Custom Flow';
-    }
-}
-exports.ServiceNowFlowComposerMCP = ServiceNowFlowComposerMCP;
-// Create and run the server
-if (require.main === module) {
-    const server = new ServiceNowFlowComposerMCP();
-    server.start().catch(console.error);
-}

package/dist/mcp/servicenow-graph-memory-mcp-refactored.d.ts

@@ -1,32 +0,0 @@
-#!/usr/bin/env node
-/**
- * servicenow-graph-memory MCP Server - REFACTORED
- * Uses BaseMCPServer to eliminate code duplication
- */
-import { BaseMCPServer, ToolResult } from './base-mcp-server.js';
-import { Tool } from '@modelcontextprotocol/sdk/types.js';
-export declare class ServiceNowGraphMemoryMCP extends BaseMCPServer {
-    private neo4jDriver;
-    private neo4jConfig;
-    private neo4jAvailable;
-    constructor();
-    protected setupTools(): void;
-    protected getTools(): Tool[];
-    protected executeTool(name: string, args: any): Promise<ToolResult>;
-    private initializeNeo4j;
-    private connectToNeo4j;
-    private createFallbackResponse;
-    private handleSnowGraphIndexArtifact;
-    private handleSnowGraphFindRelated;
-    private handleSnowGraphAnalyzeImpact;
-    private handleSnowGraphSuggestArtifacts;
-    private handleSnowGraphPatternAnalysis;
-    private handleSnowGraphVisualize;
-    private handleSnowGraphExportKnowledge;
-    private calculateImpactLevel;
-    private generateImpactRecommendations;
-    private generateCypherExport;
-    private generateGraphMLExport;
-    shutdown(): Promise<void>;
-}
-//# sourceMappingURL=servicenow-graph-memory-mcp-refactored.d.ts.map