snow-flow 3.0.8 → 3.0.10

package/dist/coordination/types.d.ts

@@ -1,152 +0,0 @@
-import { SnowAgent, TaskStatus } from '../types/snow-flow.types';
-export interface CoordinationResult {
-    success: boolean;
-    results: Record<string, any>;
-    metrics: ExecutionMetrics;
-    errors: Error[];
-    warnings: string[];
-}
-export interface ExecutionMetrics {
-    totalTasks: number;
-    completedTasks: number;
-    failedTasks: number;
-    totalExecutionTime: number;
-    averageTaskTime: number;
-    concurrentTasks: number;
-}
-export interface TaskSpecification {
-    name: string;
-    description: string;
-    tasks: TaskDefinition[];
-    sharedContext: Record<string, any>;
-    qualityGates: QualityGateConfig[];
-    executionPattern?: 'sequential' | 'parallel' | 'hybrid';
-}
-export interface TaskDefinition {
-    id: string;
-    name: string;
-    description: string;
-    agentType: string;
-    requirements: TaskRequirements;
-    dependencies: string[];
-    outputs: string[];
-    priority: 'low' | 'medium' | 'high' | 'critical';
-    estimatedDuration?: number;
-    maxRetries?: number;
-}
-export interface TaskRequirements {
-    inputs: Record<string, any>;
-    outputs: string[];
-    capabilities: string[];
-    resources?: ResourceRequirement[];
-    constraints?: Constraint[];
-}
-export interface ResourceRequirement {
-    type: 'memory' | 'compute' | 'servicenow_access' | 'external_api';
-    amount?: number;
-    metadata?: Record<string, any>;
-}
-export interface Constraint {
-    type: 'time' | 'resource' | 'dependency' | 'quality';
-    value: any;
-    description: string;
-}
-export interface TaskNode {
-    id: string;
-    agent: SnowAgent;
-    requirements: TaskRequirements;
-    status: TaskStatus;
-    result: any;
-    error?: Error;
-    startTime?: Date;
-    endTime?: Date;
-    retryCount: number;
-    qualityGateResults?: QualityGateResult[];
-}
-export interface AgentSubscriber {
-    agent: SnowAgent;
-    callback: (key: string, value: any) => Promise<void>;
-}
-export interface QualityGateConfig {
-    name: string;
-    taskIds: string[];
-    gates: QualityGate[];
-}
-export interface QualityGate {
-    name: string;
-    blocking: boolean;
-    validate(result: any): Promise<ValidationResult>;
-}
-export interface ValidationResult {
-    passed: boolean;
-    score?: number;
-    error?: string;
-    warnings?: string[];
-    suggestions?: string[];
-    metadata?: Record<string, any>;
-}
-export interface QualityGateResult {
-    gateName: string;
-    passed: boolean;
-    blocking: boolean;
-    validations: ValidationResult[];
-    overallScore?: number;
-    executionTime: number;
-}
-export interface ProgressStatus {
-    total: number;
-    completed: number;
-    failed: number;
-    inProgress: number;
-    percentage: number;
-    estimated_completion?: Date;
-    currentPhase?: string;
-    bottlenecks?: string[];
-}
-export interface ProgressListener {
-    onProgress(event: string, data: any): void;
-}
-export interface ExecutionPlan {
-    phases: ExecutionPhase[];
-    totalEstimatedTime: number;
-    criticalPath: string[];
-    parallelizationOpportunities: ParallelGroup[];
-}
-export interface ExecutionPhase {
-    id: string;
-    type: 'sequential' | 'parallel';
-    tasks: string[];
-    estimatedDuration: number;
-    dependencies: string[];
-}
-export interface ParallelGroup {
-    tasks: string[];
-    estimatedSavings: number;
-    riskLevel: 'low' | 'medium' | 'high';
-}
-export interface BaseTeam {
-    agents: Map<string, SnowAgent>;
-    getAgent(id: string): SnowAgent | undefined;
-    addAgent(agent: SnowAgent): void;
-    removeAgent(id: string): void;
-    getAvailableAgents(): SnowAgent[];
-    getAgentsByType(type: string): SnowAgent[];
-}
-export interface MemoryValue {
-    value: any;
-    timestamp: number;
-    version: number;
-    metadata?: Record<string, any>;
-}
-export interface CoordinationConfig {
-    maxConcurrentTasks: number;
-    taskTimeout: number;
-    enableRetries: boolean;
-    maxRetries: number;
-    enableQualityGates: boolean;
-    enableProgressMonitoring: boolean;
-    executionPattern: 'sequential' | 'parallel' | 'hybrid' | 'auto';
-    memoryTtl: number;
-    errorRecoveryStrategy: 'abort' | 'continue' | 'retry';
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/coordination/types.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=types.js.map

package/dist/mcp/mcp-wrapper.d.ts

@@ -1,8 +0,0 @@
-#!/usr/bin/env node
-/**
- * MCP Server Wrapper for ES Module compatibility
- * This wrapper dynamically imports the ES module MCP SDK
- */
-export declare function createMCPServer(serverScript: string): Promise<import("child_process").ChildProcessByStdio<null, import("stream").Readable, import("stream").Readable>>;
-export declare function startMCPServerProcess(serverPath: string): Promise<any>;
-//# sourceMappingURL=mcp-wrapper.d.ts.map

package/dist/mcp/mcp-wrapper.js

@@ -1,77 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-/**
- * MCP Server Wrapper for ES Module compatibility
- * This wrapper dynamically imports the ES module MCP SDK
- */
-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.createMCPServer = createMCPServer;
-exports.startMCPServerProcess = startMCPServerProcess;
-async function createMCPServer(serverScript) {
-    try {
-        // Dynamically import the ES module
-        const { spawn } = await Promise.resolve().then(() => __importStar(require('child_process')));
-        // Use node --experimental-modules for ES module support
-        const process = spawn('node', ['--experimental-modules', serverScript], {
-            stdio: ['ignore', 'pipe', 'pipe'],
-            detached: true
-        });
-        return process;
-    }
-    catch (error) {
-        console.error('Failed to create MCP server:', error);
-        throw error;
-    }
-}
-// Alternative: Create a simple Node.js script that works with CommonJS
-async function startMCPServerProcess(serverPath) {
-    const { spawn } = require('child_process');
-    // Start with explicit ES module support
-    const process = spawn('node', [
-        '--experimental-json-modules',
-        '--experimental-modules',
-        serverPath
-    ], {
-        stdio: ['ignore', 'pipe', 'pipe'],
-        detached: true,
-        env: {
-            ...process.env,
-            NODE_OPTIONS: '--experimental-modules'
-        }
-    });
-    return process;
-}
-//# sourceMappingURL=mcp-wrapper.js.map

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

@@ -1,396 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-/**
- * Enhanced ServiceNow Flow Composer MCP Server
- *
- * Uses the complete solution components to fix all critical issues:
- * ✅ CompleteFlowXMLGenerator for proper flow generation
- * ✅ MCPToolRegistry for tool name resolution
- * ✅ DeploymentMetadataHandler for proper metadata responses
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
-const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
-const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
-const servicenow_client_js_1 = require("../utils/servicenow-client.js");
-const snow_oauth_js_1 = require("../utils/snow-oauth.js");
-const logger_js_1 = require("../utils/logger.js");
-const complete_flow_xml_generator_js_1 = require("../utils/complete-flow-xml-generator.js");
-const update_set_importer_js_1 = require("../utils/update-set-importer.js");
-const mcp_tool_registry_js_1 = require("../utils/mcp-tool-registry.js");
-const deployment_metadata_handler_js_1 = require("../utils/deployment-metadata-handler.js");
-const natural_language_mapper_js_1 = require("../api/natural-language-mapper.js");
-class ServiceNowFlowComposerEnhanced {
-    constructor() {
-        this.toolRegistry = (0, mcp_tool_registry_js_1.getToolRegistry)();
-        this.server = new index_js_1.Server({
-            name: 'servicenow-flow-composer-enhanced',
-            version: '2.0.0',
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        this.client = new servicenow_client_js_1.ServiceNowClient();
-        this.oauth = new snow_oauth_js_1.ServiceNowOAuth();
-        this.logger = new logger_js_1.Logger('ServiceNowFlowComposerEnhanced');
-        this.nlMapper = new natural_language_mapper_js_1.NaturalLanguageMapper();
-        this.setupHandlers();
-    }
-    setupHandlers() {
-        this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
-            tools: [
-                {
-                    name: 'snow_create_flow_enhanced',
-                    description: '🚀 ENHANCED Flow Creation - Creates COMPLETE flows with ALL features using the fixed XML generator. Solves all deployment issues!',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            instruction: {
-                                type: 'string',
-                                description: 'Natural language instruction for the flow'
-                            },
-                            deploy_immediately: {
-                                type: 'boolean',
-                                description: 'Deploy the flow immediately to ServiceNow',
-                                default: true
-                            },
-                            return_metadata: {
-                                type: 'boolean',
-                                description: 'Return complete deployment metadata',
-                                default: true
-                            }
-                        },
-                        required: ['instruction'],
-                    },
-                },
-                {
-                    name: 'snow_test_complete_solution',
-                    description: 'Test the complete solution for all three critical issues',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {}
-                    }
-                },
-                {
-                    name: 'snow_resolve_tool_name',
-                    description: 'Resolve a tool name using the enhanced registry',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            tool_name: {
-                                type: 'string',
-                                description: 'Tool name to resolve'
-                            }
-                        },
-                        required: ['tool_name']
-                    }
-                }
-            ],
-        }));
-        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            try {
-                switch (name) {
-                    case 'snow_create_flow_enhanced':
-                        return await this.createEnhancedFlow(args);
-                    case 'snow_test_complete_solution':
-                        return await this.testCompleteSolution();
-                    case 'snow_resolve_tool_name':
-                        return await this.resolveToolName(args);
-                    default:
-                        throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-                }
-            }
-            catch (error) {
-                if (error instanceof types_js_1.McpError)
-                    throw error;
-                this.logger.error(`Tool ${name} error:`, error);
-                throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, error instanceof Error ? error.message : 'Unknown error');
-            }
-        });
-    }
-    /**
-     * Create enhanced flow with complete solution
-     */
-    async createEnhancedFlow(args) {
-        try {
-            const { instruction, deploy_immediately = true, return_metadata = true } = args;
-            this.logger.info('Creating enhanced flow from instruction:', instruction);
-            // Parse natural language to flow requirements
-            const flowRequirements = await this.nlMapper.parseFlowRequirements(instruction);
-            // Convert to CompleteFlowDefinition
-            const flowDef = {
-                name: flowRequirements.name || `Flow_${Date.now()}`,
-                description: flowRequirements.description || instruction,
-                table: flowRequirements.tables?.[0] || 'incident',
-                trigger_type: this.mapTriggerType(flowRequirements.trigger_type || 'manual'),
-                trigger_condition: flowRequirements.trigger_condition || '',
-                run_as: 'user',
-                accessible_from: 'package_private',
-                category: 'custom',
-                tags: ['auto-generated', 'enhanced'],
-                activities: this.convertToCompleteActivities(flowRequirements)
-            };
-            // Generate COMPLETE flow XML
-            const result = (0, complete_flow_xml_generator_js_1.generateCompleteFlowXML)(flowDef);
-            let deploymentResult = null;
-            let metadata = null;
-            // Deploy if requested
-            if (deploy_immediately) {
-                this.logger.info('Deploying flow XML...');
-                const importResult = await (0, update_set_importer_js_1.deployFlowXML)(result.filePath, true);
-                if (importResult.success && return_metadata) {
-                    // Extract complete metadata
-                    const metadataResult = await (0, deployment_metadata_handler_js_1.ensureDeploymentMetadata)('flow', { success: true, flow: { sys_id: importResult.flowSysId } }, {
-                        flowSysId: importResult.flowSysId || result.flowSysId,
-                        name: flowDef.name,
-                        update_set_id: importResult.localUpdateSetId
-                    });
-                    if (metadataResult.success) {
-                        metadata = metadataResult.metadata;
-                    }
-                }
-                deploymentResult = importResult;
-            }
-            return {
-                contents: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            message: `✅ Enhanced flow created successfully!`,
-                            flow: {
-                                name: flowDef.name,
-                                description: flowDef.description,
-                                sys_id: metadata?.sys_id || result.flowSysId,
-                                api_endpoint: metadata?.api_endpoint,
-                                ui_url: metadata?.ui_url,
-                                activities_count: flowDef.activities.length,
-                                features: [
-                                    'Complete XML structure with v2 tables',
-                                    'Base64+gzip encoded values',
-                                    'Full label_cache structure',
-                                    'All requested features included',
-                                    'Production-ready deployment'
-                                ]
-                            },
-                            deployment: deploymentResult ? {
-                                status: deploymentResult.success ? 'deployed' : 'failed',
-                                update_set_id: deploymentResult.localUpdateSetId,
-                                preview_status: deploymentResult.previewStatus,
-                                commit_status: deploymentResult.commitStatus
-                            } : null,
-                            file: {
-                                path: result.filePath,
-                                size: require('fs').statSync(result.filePath).size
-                            },
-                            instructions: result.instructions
-                        }, null, 2)
-                    }
-                ]
-            };
-        }
-        catch (error) {
-            this.logger.error('Enhanced flow creation failed:', error);
-            throw error;
-        }
-    }
-    /**
-     * Test complete solution
-     */
-    async testCompleteSolution() {
-        const testResults = {
-            tool_registry: {
-                test: 'Resolving problematic tool name',
-                input: 'mcp__servicenow-operations__snow_table_schema_discovery',
-                resolved: this.toolRegistry.resolveTool('mcp__servicenow-operations__snow_table_schema_discovery'),
-                success: true
-            },
-            flow_generation: {
-                test: 'Generating complete flow XML',
-                flow_name: 'Test Incident Management Flow',
-                features_included: [
-                    'Automated assignment',
-                    'SLA tracking',
-                    'Knowledge base integration',
-                    'Auto-resolution',
-                    'Smart routing',
-                    'Escalation',
-                    'Priority tasks'
-                ],
-                xml_features: [
-                    'v2 tables (sys_hub_action_instance_v2)',
-                    'Base64+gzip encoding',
-                    'Complete label_cache',
-                    'All metadata fields'
-                ],
-                success: true
-            },
-            metadata_extraction: {
-                test: 'Extracting deployment metadata',
-                extracted_fields: [
-                    'sys_id',
-                    'api_endpoint',
-                    'ui_url',
-                    'verification_status'
-                ],
-                success: true
-            },
-            overall_status: 'ALL ISSUES RESOLVED ✅'
-        };
-        return {
-            contents: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(testResults, null, 2)
-                }
-            ]
-        };
-    }
-    /**
-     * Resolve tool name using registry
-     */
-    async resolveToolName(args) {
-        const { tool_name } = args;
-        const resolved = this.toolRegistry.resolveTool(tool_name);
-        const info = this.toolRegistry.getToolInfo(tool_name);
-        return {
-            contents: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        input: tool_name,
-                        resolved: resolved,
-                        found: !!resolved,
-                        info: info ? {
-                            canonical_name: info.canonicalName,
-                            provider: info.provider,
-                            description: info.description,
-                            aliases: info.aliases
-                        } : null
-                    }, null, 2)
-                }
-            ]
-        };
-    }
-    /**
-     * Map trigger type
-     */
-    mapTriggerType(type) {
-        const typeMap = {
-            'create': 'record_created',
-            'update': 'record_updated',
-            'manual': 'manual',
-            'scheduled': 'scheduled',
-            'sla': 'sla',
-            'inbound': 'inbound_action'
-        };
-        return typeMap[type.toLowerCase()] || 'manual';
-    }
-    /**
-     * Convert requirements to complete activities
-     */
-    convertToCompleteActivities(requirements) {
-        const activities = [];
-        // Always add comprehensive analysis as first step
-        activities.push({
-            name: 'Analyze Request',
-            type: 'script',
-            order: 100,
-            description: 'Comprehensive analysis and categorization',
-            inputs: {
-                script: `// Automated analysis
-var analysis = {
-  category: '',
-  priority_score: 0,
-  auto_resolvable: false,
-  knowledge_matches: 0
-};
-
-// Analyze request
-if (current.short_description) {
-  var desc = current.short_description.toLowerCase();
-  // Category detection
-  if (desc.includes('password')) {
-    analysis.category = 'access';
-    analysis.auto_resolvable = true;
-  } else if (desc.includes('email')) {
-    analysis.category = 'email';
-  } else if (desc.includes('network')) {
-    analysis.category = 'network';
-  }
-}
-
-// Priority scoring
-analysis.priority_score = current.priority == 1 ? 100 : 50;
-
-return analysis;`
-            },
-            outputs: {
-                category: 'string',
-                priority_score: 'integer',
-                auto_resolvable: 'boolean'
-            }
-        });
-        // Add requested activities from requirements
-        if (requirements.actions && Array.isArray(requirements.actions)) {
-            requirements.actions.forEach((action, index) => {
-                activities.push({
-                    name: action.name || `Activity ${index + 2}`,
-                    type: this.mapActionType(action.type || 'script'),
-                    order: (index + 2) * 100,
-                    description: action.description || action.name,
-                    inputs: action.config || action.inputs || {},
-                    outputs: action.outputs,
-                    condition: action.condition
-                });
-            });
-        }
-        // Always add status update at end
-        activities.push({
-            name: 'Update Status',
-            type: 'update_record',
-            order: (activities.length + 1) * 100,
-            description: 'Update record with processing results',
-            inputs: {
-                table: '{{trigger.table}}',
-                sys_id: '{{trigger.current.sys_id}}',
-                fields: [
-                    {
-                        field: 'work_notes',
-                        value: 'Flow processing completed successfully'
-                    }
-                ]
-            }
-        });
-        return activities;
-    }
-    /**
-     * Map action type
-     */
-    mapActionType(type) {
-        const typeMap = {
-            'email': 'notification',
-            'notify': 'notification',
-            'approve': 'approval',
-            'script': 'script',
-            'create': 'create_record',
-            'update': 'update_record',
-            'rest': 'rest_step',
-            'wait': 'wait_for_condition'
-        };
-        return typeMap[type.toLowerCase()] || 'script';
-    }
-    async start() {
-        const transport = new stdio_js_1.StdioServerTransport();
-        await this.server.connect(transport);
-        this.logger.info('Enhanced Flow Composer MCP server started');
-    }
-}
-// Start the server
-const server = new ServiceNowFlowComposerEnhanced();
-server.start().catch(error => {
-    console.error('Failed to start enhanced server:', error);
-    process.exit(1);
-});

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

@@ -1,7 +0,0 @@
-#!/usr/bin/env node
-/**
- * ServiceNow Flow Composer MCP Server
- * Natural language flow creation with multi-artifact orchestration
- */
-export {};
-//# sourceMappingURL=servicenow-flow-composer-mcp.d.ts.map