snow-flow 3.0.8 → 3.0.10

package/dist/agents/flow-builder-agent.d.ts

@@ -1,18 +0,0 @@
-/**
- * Flow Builder Agent
- * Specializes in creating ServiceNow Flow Designer workflows
- */
-import { BaseAgent, AgentConfig, AgentResult } from './base-agent';
-export declare class FlowBuilderAgent extends BaseAgent {
-    constructor(config?: Partial<AgentConfig>);
-    execute(instruction: string, context?: Record<string, any>): Promise<AgentResult>;
-    private analyzeFlowRequirements;
-    private checkExistingFlows;
-    private designFlowStructure;
-    private createFlowDefinition;
-    private configureTriggers;
-    private setupActions;
-    private createAction;
-    private prepareDeploymentInstructions;
-}
-//# sourceMappingURL=flow-builder-agent.d.ts.map

package/dist/agents/flow-builder-agent.js

@@ -1,197 +0,0 @@
-"use strict";
-/**
- * Flow Builder Agent
- * Specializes in creating ServiceNow Flow Designer workflows
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FlowBuilderAgent = void 0;
-const base_agent_1 = require("./base-agent");
-const mcp_execution_bridge_1 = require("../queen/mcp-execution-bridge");
-class FlowBuilderAgent extends base_agent_1.BaseAgent {
-    constructor(config, mcpBridge) {
-        super({
-            type: 'flow-builder',
-            capabilities: [
-                'Business process design',
-                'Flow Designer expertise',
-                'Approval workflow creation',
-                'Integration flow building',
-                'Condition and trigger logic',
-                'Action step configuration',
-                'Subflow creation',
-                'Error handling design',
-                'Decision table creation'
-            ],
-            mcpTools: [
-                'snow_create_flow',
-                'snow_test_flow_with_mock',
-                'snow_link_catalog_to_flow',
-                'snow_comprehensive_flow_test',
-                'snow_validate_flow_definition',
-                'snow_discover_existing_flows',
-                'snow_flow_wizard'
-            ],
-            ...config
-        });
-        // Initialize MCP bridge for real ServiceNow deployment
-        this.mcpBridge = mcpBridge || new mcp_execution_bridge_1.MCPExecutionBridge(this.memory);
-    }
-    /**
-     * Create MCP recommendation for tool execution
-     */
-    createMCPRecommendation(tool, params, action) {
-        return {
-            agentId: this.id,
-            agentType: this.type,
-            action: action,
-            tool: tool,
-            server: this.getServerForTool(tool),
-            params: params,
-            reasoning: `Flow builder executing ${action}`,
-            confidence: 0.9,
-            dependencies: []
-        };
-    }
-    /**
-     * Map MCP tools to their respective servers
-     */
-    getServerForTool(tool) {
-        const toolServerMap = {
-            'snow_create_flow': 'flow-composer',
-            'snow_test_flow_with_mock': 'operations',
-            'snow_comprehensive_flow_test': 'intelligent',
-            'snow_validate_flow_definition': 'deployment',
-            'snow_discover_existing_flows': 'intelligent',
-            'snow_link_catalog_to_flow': 'operations'
-        };
-        return toolServerMap[tool] || 'deployment';
-    }
-    /**
-     * Execute MCP tool with error handling and fallbacks
-     */
-    async executeWithFallback(tool, params, action) {
-        const recommendation = this.createMCPRecommendation(tool, params, action);
-        try {
-            const result = await this.mcpBridge.executeAgentRecommendation({ id: this.id, type: this.type }, recommendation);
-            if (!result.success) {
-                return {
-                    success: false,
-                    error: result.error || `MCP tool ${tool} execution failed`
-                };
-            }
-            if (result.fallbackUsed) {
-                console.warn(`⚠️ MCP tool ${tool} used fallback strategy`);
-            }
-            return {
-                success: true,
-                result: result.toolResult
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error)
-            };
-        }
-    }
-    async execute(instruction, context) {
-        try {
-            this.setStatus('working');
-            await this.reportProgress('🚀 Starting MCP-powered flow creation', 0);
-            // 🔍 STEP 1: Check for existing flows to avoid duplication
-            await this.reportProgress('🔍 Discovering existing flows', 10);
-            const discoveryResult = await this.executeWithFallback('snow_discover_existing_flows', { flow_purpose: instruction }, 'discover-existing-flows');
-            let existingFlowsCount = 0;
-            if (discoveryResult.success && discoveryResult.result?.found) {
-                existingFlowsCount = discoveryResult.result.found.length;
-                if (existingFlowsCount > 0) {
-                    await this.reportProgress(`📊 Found ${existingFlowsCount} similar flows for reference`, 20);
-                }
-            }
-            // 🧠 STEP 2: CREATE FLOW VIA MCP TOOL (This is the key fix!)
-            await this.reportProgress('🧠 Creating flow via intelligent MCP system', 30);
-            const createResult = await this.executeWithFallback('snow_create_flow', {
-                instruction: instruction,
-                deploy_immediately: true,
-                enable_intelligent_analysis: true,
-                create_missing_artifacts: true,
-                validation_level: 'standard'
-            }, 'create-flow');
-            if (!createResult.success) {
-                throw new Error(`❌ Flow creation via MCP failed: ${createResult.error}`);
-            }
-            await this.reportProgress('✅ Flow created and deployed to ServiceNow!', 60);
-            // 🧪 STEP 3: Test the created flow with mock data
-            await this.reportProgress('🧪 Testing flow with mock data', 70);
-            const testResult = await this.executeWithFallback('snow_test_flow_with_mock', {
-                flow_id: createResult.result.sys_id || createResult.result.flow_sys_id,
-                create_test_user: true,
-                cleanup_after_test: true,
-                simulate_approvals: true
-            }, 'test-flow');
-            let testStatus = '❓ Test status unknown';
-            if (testResult.success) {
-                testStatus = '✅ Flow tested successfully';
-            }
-            else {
-                testStatus = `⚠️ Flow test failed: ${testResult.error}`;
-            }
-            // 🎯 STEP 4: Create artifact with REAL ServiceNow data
-            const realFlowData = createResult.result;
-            const artifact = {
-                type: 'flow',
-                name: realFlowData.name || realFlowData.flow_name || 'created_flow',
-                sys_id: realFlowData.sys_id || realFlowData.flow_sys_id, // ✅ REAL sys_id from ServiceNow!
-                config: {
-                    // Store the actual flow definition returned from ServiceNow
-                    definition: realFlowData.definition || realFlowData,
-                    deployed: true,
-                    tested: testResult.success,
-                    created_via: 'snow_create_flow_mcp',
-                    metadata: {
-                        description: instruction,
-                        type: realFlowData.type || 'flow',
-                        active: realFlowData.active || true
-                    }
-                },
-                dependencies: realFlowData.dependencies || []
-            };
-            // Store artifact for other agents
-            await this.storeArtifact(artifact);
-            await this.reportProgress('📦 Flow artifact stored with real ServiceNow data', 90);
-            await this.reportProgress('🎉 MCP-powered flow creation completed!', 100);
-            this.setStatus('completed');
-            await this.logActivity('flow_creation_mcp', true, {
-                flowName: artifact.name,
-                sys_id: artifact.sys_id,
-                tested: testResult.success,
-                deployedToServiceNow: true,
-                discoveredSimilar: existingFlowsCount
-            });
-            return {
-                success: true,
-                artifacts: [artifact],
-                message: `✅ Flow "${artifact.name}" created and deployed to ServiceNow successfully! ${testStatus}`,
-                metadata: {
-                    sys_id: artifact.sys_id, // ✅ Real ServiceNow sys_id!
-                    deployed_to_servicenow: true,
-                    tested: testResult.success,
-                    test_details: testResult.result,
-                    discovered_similar_flows: existingFlowsCount,
-                    mcp_powered: true,
-                    has_content: true // ✅ No more empty flows!
-                }
-            };
-        }
-        catch (error) {
-            this.setStatus('failed');
-            await this.logActivity('flow_creation_mcp', false, { error: error.message });
-            return {
-                success: false,
-                error: error,
-                message: `❌ MCP-powered flow creation failed: ${error.message}`
-            };
-        }
-    }
-}
-exports.FlowBuilderAgent = FlowBuilderAgent;

package/dist/agents/queen-403-handler.d.ts

@@ -1,47 +0,0 @@
-/**
- * Queen Agent 403 Error Handler
- * Automatically analyzes and resolves ServiceNow permission issues using Gap Analysis Engine
- */
-import { Logger } from '../utils/logger';
-export interface Permission403Context {
-    error: any;
-    operation: string;
-    tableName?: string;
-    artifactType?: string;
-    objective: string;
-}
-export declare class Queen403Handler {
-    private logger;
-    private mcpTools;
-    constructor(logger: Logger, mcpTools: any);
-    /**
-     * Handle 403 permission errors with intelligent _analysis and resolution
-     */
-    handle403Error(context: Permission403Context): Promise<{
-        resolved: boolean;
-        _analysis: any;
-        nextSteps: string[];
-        manualActions?: string[];
-    }>;
-    /**
-     * Create specific objective for ACL analysis
-     */
-    private createACLObjective;
-    /**
-     * Generate next steps based on analysis
-     */
-    private generateNextSteps;
-    /**
-     * Extract manual actions from gap analysis
-     */
-    private extractManualActions;
-    /**
-     * Log findings for Queen Agent awareness
-     */
-    private logFindings;
-    /**
-     * Generate fallback deployment configuration
-     */
-    generateFallbackConfig(context: Permission403Context): any;
-}
-//# sourceMappingURL=queen-403-handler.d.ts.map

package/dist/agents/queen-403-handler.js

@@ -1,175 +0,0 @@
-"use strict";
-/**
- * Queen Agent 403 Error Handler
- * Automatically analyzes and resolves ServiceNow permission issues using Gap Analysis Engine
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Queen403Handler = void 0;
-const gap_analysis_engine_1 = require("../intelligence/gap-analysis-engine");
-class Queen403Handler {
-    constructor(logger, mcpTools) {
-        this.logger = logger;
-        this.mcpTools = mcpTools;
-    }
-    /**
-     * Handle 403 permission errors with intelligent _analysis and resolution
-     */
-    async handle403Error(context) {
-        this.logger.info('🚨 Queen Agent: 403 Permission Error detected - activating Gap Analysis');
-        // 1. Create specific objective for ACL analysis
-        const aclObjective = this.createACLObjective(context);
-        // 2. Run Gap Analysis specifically for permission issues
-        const gapAnalysis = await (0, gap_analysis_engine_1.analyzeGaps)(aclObjective, this.mcpTools, this.logger, {
-            autoPermissions: true,
-            environment: 'development',
-            enableAutomation: true,
-            includeManualGuides: true
-        });
-        // 3. Extract ACL-specific findings
-        const aclRequirements = gapAnalysis.requirements.filter(req => req.type === 'acl_rule' ||
-            req.type === 'user_role' ||
-            req.type === 'oauth_provider' ||
-            req.type === 'security_policy' ||
-            req.type === 'sys_property');
-        // 4. Check if any automatic fixes were applied
-        const autoFixed = gapAnalysis.automationResults.successful.filter(result => result.requirement.type === 'sys_property' &&
-            result.requirement.name?.includes('service_portal'));
-        // 5. Prepare next steps based on analysis
-        const nextSteps = this.generateNextSteps(context, gapAnalysis, aclRequirements);
-        // 6. Log findings for Queen Agent decision making
-        this.logFindings(aclRequirements, gapAnalysis);
-        return {
-            resolved: autoFixed.length > 0,
-            _analysis: {
-                totalPermissionIssues: aclRequirements.length,
-                automaticallyFixed: autoFixed.length,
-                requiresManualWork: aclRequirements.filter(r => !r.automatable).length,
-                gapAnalysis: gapAnalysis
-            },
-            nextSteps,
-            manualActions: this.extractManualActions(gapAnalysis)
-        };
-    }
-    /**
-     * Create specific objective for ACL analysis
-     */
-    createACLObjective(context) {
-        const { tableName, artifactType, operation, objective } = context;
-        let aclObjective = `Fix 403 permission error for ${operation} on `;
-        if (tableName) {
-            aclObjective += `${tableName} table `;
-        }
-        else if (artifactType) {
-            aclObjective += `${artifactType} `;
-        }
-        aclObjective += `to complete: ${objective}`;
-        // Add specific context for sp_widget
-        if (tableName === 'sp_widget' || artifactType === 'widget') {
-            aclObjective += ' including Service Portal API access, OAuth scopes, and cross-scope permissions';
-        }
-        return aclObjective;
-    }
-    /**
-     * Generate next steps based on analysis
-     */
-    generateNextSteps(context, gapAnalysis, aclRequirements) {
-        const steps = [];
-        // 1. If automatic fixes were applied, suggest retry
-        if (gapAnalysis.automationResults.successful.length > 0) {
-            steps.push('🔄 Retry the deployment - automatic fixes have been applied');
-        }
-        // 2. For sp_widget specific issues
-        if (context.tableName === 'sp_widget') {
-            steps.push('🌐 Try deployment with global scope: scope_preference: "global"');
-            steps.push('📋 Ensure active Update Set: snow_ensure_active_update_set()');
-        }
-        // 3. For OAuth issues
-        const oauthIssues = aclRequirements.filter(r => r.type === 'oauth_provider');
-        if (oauthIssues.length > 0) {
-            steps.push('🔐 Check OAuth application settings in ServiceNow');
-            steps.push('🔧 Re-authenticate: snow-flow auth login');
-        }
-        // 4. For role issues
-        const roleIssues = aclRequirements.filter(r => r.type === 'user_role');
-        if (roleIssues.length > 0) {
-            const missingRoles = roleIssues.map(r => r.name).join(', ');
-            steps.push(`👤 Add missing roles: ${missingRoles}`);
-        }
-        // 5. For ACL rule issues
-        const aclRuleIssues = aclRequirements.filter(r => r.type === 'acl_rule');
-        if (aclRuleIssues.length > 0) {
-            steps.push('🛡️ Review ACL rules on the target table');
-            steps.push('🔍 Check for custom ACLs blocking API access');
-        }
-        return steps;
-    }
-    /**
-     * Extract manual actions from gap analysis
-     */
-    extractManualActions(gapAnalysis) {
-        const actions = [];
-        if (gapAnalysis.manualGuides && gapAnalysis.manualGuides.guides) {
-            gapAnalysis.manualGuides.guides.forEach((guide) => {
-                if (guide.category === 'security_permissions' ||
-                    guide.title.includes('ACL') ||
-                    guide.title.includes('Permission')) {
-                    actions.push(`📖 ${guide.title} (${guide.totalEstimatedTime})`);
-                    // Add first few steps as preview
-                    if (guide.instructions && guide.instructions.length > 0) {
-                        guide.instructions.slice(0, 2).forEach((instruction) => {
-                            actions.push(`   • ${instruction.title}`);
-                        });
-                    }
-                }
-            });
-        }
-        return actions;
-    }
-    /**
-     * Log findings for Queen Agent awareness
-     */
-    logFindings(aclRequirements, gapAnalysis) {
-        console.log('\n🧠 Queen Agent Permission Analysis Results:');
-        console.log('━'.repeat(50));
-        console.log(`\n📊 Permission Requirements Found: ${aclRequirements.length}`);
-        aclRequirements.forEach(req => {
-            const icon = req.automatable ? '🤖' : '👤';
-            console.log(`  ${icon} ${req.type}: ${req.name || req.description}`);
-        });
-        console.log(`\n✅ Automatic Fixes Applied: ${gapAnalysis.automationResults.successful.length}`);
-        gapAnalysis.automationResults.successful.forEach((result) => {
-            console.log(`  • ${result.requirement.name}: ${result.message}`);
-        });
-        console.log(`\n📋 Manual Actions Required: ${gapAnalysis.summary.requiresManualWork}`);
-        console.log('\n💡 Recommendations:');
-        gapAnalysis.nextSteps.recommendations.forEach((rec) => {
-            console.log(`  • ${rec}`);
-        });
-    }
-    /**
-     * Generate fallback deployment configuration
-     */
-    generateFallbackConfig(context) {
-        const fallbackConfig = {
-            retry_with_global_scope: true,
-            force_update_set: true,
-            permission_escalation: 'request'
-        };
-        // For widget deployments
-        if (context.tableName === 'sp_widget' || context.artifactType === 'widget') {
-            fallbackConfig.alternative_deployment = {
-                method: 'manual_steps',
-                generate_script: true,
-                instructions: [
-                    '1. Switch to Global application scope',
-                    '2. Navigate to Service Portal > Widgets',
-                    '3. Click New and paste the generated code',
-                    '4. Ensure you have an active Update Set'
-                ]
-            };
-        }
-        return fallbackConfig;
-    }
-}
-exports.Queen403Handler = Queen403Handler;
-//# sourceMappingURL=queen-403-handler.js.map

package/dist/agents/queen-agent-example.d.ts

@@ -1,23 +0,0 @@
-/**
- * Queen Agent Example Implementation
- * Shows how to use the Queen Agent with Claude Code interface
- */
-/**
- * Example of how the Queen Agent integrates with Claude Code
- * This would be called by the Snow-Flow CLI when launching a swarm
- */
-export declare function launchQueenAgentSwarm(objective: string): Promise<void>;
-/**
- * Example of how Claude Code would interact with the Queen Agent
- * This demonstrates the TodoWrite integration pattern
- */
-export declare function claudeCodeIntegration(): void;
-/**
- * Example of complex objective handling
- */
-export declare function handleComplexObjective(): Promise<void>;
-/**
- * Example of error recovery and fallback
- */
-export declare function demonstrateErrorRecovery(): Promise<void>;
-//# sourceMappingURL=queen-agent-example.d.ts.map