snow-flow 3.0.8 → 3.0.10

package/dist/queen/mock-mcp-client.js

@@ -1,317 +0,0 @@
-"use strict";
-/**
- * Mock MCP Client for Queen Agent Testing
- *
- * Simulates MCP tool responses without requiring live ServiceNow connections
- * Tests Queen ↔ MCP communication patterns
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MockMcpClient = void 0;
-class MockMcpClient {
-    constructor() {
-        this.callHistory = [];
-    }
-    /**
-     * Mock snow_deploy tool
-     */
-    async snow_deploy(params) {
-        const startTime = Date.now();
-        this.callHistory.push({
-            tool: 'snow_deploy',
-            params,
-            timestamp: new Date()
-        });
-        // Simulate deployment delay
-        await this.simulateDelay(1000, 3000);
-        if (params.type === 'widget') {
-            return {
-                success: true,
-                result: {
-                    sys_id: 'mock-widget-' + Math.random().toString(36).substring(7),
-                    name: params.config?.name || 'mock_widget',
-                    type: 'widget',
-                    deployed: true,
-                    update_set: 'mock-update-set-123'
-                },
-                toolUsed: 'snow_deploy',
-                executionTime: Date.now() - startTime
-            };
-        }
-        if (params.type === 'flow') {
-            return {
-                success: true,
-                result: {
-                    sys_id: 'mock-flow-' + Math.random().toString(36).substring(7),
-                    name: 'Mock Approval Flow',
-                    type: 'flow',
-                    deployed: true,
-                    update_set: 'mock-update-set-123'
-                },
-                toolUsed: 'snow_deploy',
-                executionTime: Date.now() - startTime
-            };
-        }
-        return {
-            success: false,
-            error: `Unsupported deployment type: ${params.type}`,
-            toolUsed: 'snow_deploy',
-            executionTime: Date.now() - startTime
-        };
-    }
-    /**
-     * Mock snow_create_flow tool
-     */
-    async snow_create_flow(params) {
-        const startTime = Date.now();
-        this.callHistory.push({
-            tool: 'snow_create_flow',
-            params,
-            timestamp: new Date()
-        });
-        await this.simulateDelay(2000, 5000);
-        if (!params.instruction || params.instruction.length < 10) {
-            return {
-                success: false,
-                error: 'Flow instruction too short or missing',
-                toolUsed: 'snow_create_flow',
-                executionTime: Date.now() - startTime
-            };
-        }
-        return {
-            success: true,
-            result: {
-                sys_id: 'mock-flow-' + Math.random().toString(36).substring(7),
-                name: 'AI Generated Flow',
-                instruction: params.instruction,
-                flow_type: params.flow_type || 'flow',
-                deployed: params.deploy_immediately || false,
-                analysis: {
-                    complexity: 'medium',
-                    estimated_steps: 4,
-                    requires_approval: true
-                }
-            },
-            toolUsed: 'snow_create_flow',
-            executionTime: Date.now() - startTime
-        };
-    }
-    /**
-     * Mock snow_find_artifact tool
-     */
-    async snow_find_artifact(params) {
-        const startTime = Date.now();
-        this.callHistory.push({
-            tool: 'snow_find_artifact',
-            params,
-            timestamp: new Date()
-        });
-        await this.simulateDelay(500, 1500);
-        const mockArtifacts = [
-            {
-                sys_id: 'mock-widget-001',
-                name: 'incident_dashboard_widget',
-                type: 'widget',
-                description: 'Dashboard widget for incident statistics'
-            },
-            {
-                sys_id: 'mock-flow-001',
-                name: 'approval_workflow',
-                type: 'flow',
-                description: 'Approval workflow for service requests'
-            },
-            {
-                sys_id: 'mock-script-001',
-                name: 'data_processor_script',
-                type: 'script',
-                description: 'Data processing script include'
-            }
-        ];
-        // Filter based on query and type
-        let results = mockArtifacts;
-        if (params.type && params.type !== 'any') {
-            results = results.filter(a => a.type === params.type);
-        }
-        if (params.query) {
-            const query = params.query.toLowerCase();
-            results = results.filter(a => a.name.toLowerCase().includes(query) ||
-                a.description.toLowerCase().includes(query));
-        }
-        return {
-            success: true,
-            result: {
-                artifacts: results,
-                total_found: results.length,
-                query: params.query,
-                type_filter: params.type
-            },
-            toolUsed: 'snow_find_artifact',
-            executionTime: Date.now() - startTime
-        };
-    }
-    /**
-     * Mock snow_catalog_item_search tool
-     */
-    async snow_catalog_item_search(params) {
-        const startTime = Date.now();
-        this.callHistory.push({
-            tool: 'snow_catalog_item_search',
-            params,
-            timestamp: new Date()
-        });
-        await this.simulateDelay(800, 2000);
-        const mockCatalogItems = [
-            {
-                sys_id: 'mock-catalog-iphone',
-                name: 'iPhone 6S',
-                short_description: 'iPhone 6S mobile device',
-                price: '599.00',
-                category: 'Mobile Devices'
-            },
-            {
-                sys_id: 'mock-catalog-laptop',
-                name: 'MacBook Pro',
-                short_description: 'MacBook Pro laptop computer',
-                price: '2399.00',
-                category: 'Laptops'
-            }
-        ];
-        // Simple fuzzy search
-        let results = mockCatalogItems;
-        if (params.query) {
-            const query = params.query.toLowerCase();
-            results = results.filter(item => item.name.toLowerCase().includes(query) ||
-                item.short_description.toLowerCase().includes(query));
-        }
-        return {
-            success: true,
-            result: {
-                catalog_items: results,
-                total_found: results.length,
-                fuzzy_match: params.fuzzy_match || false
-            },
-            toolUsed: 'snow_catalog_item_search',
-            executionTime: Date.now() - startTime
-        };
-    }
-    /**
-     * Mock snow_test_flow_with_mock tool
-     */
-    async snow_test_flow_with_mock(params) {
-        const startTime = Date.now();
-        this.callHistory.push({
-            tool: 'snow_test_flow_with_mock',
-            params,
-            timestamp: new Date()
-        });
-        await this.simulateDelay(3000, 8000);
-        if (!params.flow_id) {
-            return {
-                success: false,
-                error: 'flow_id parameter is required',
-                toolUsed: 'snow_test_flow_with_mock',
-                executionTime: Date.now() - startTime
-            };
-        }
-        return {
-            success: true,
-            result: {
-                flow_id: params.flow_id,
-                test_status: 'completed',
-                test_user_created: params.create_test_user || false,
-                mock_items_created: params.mock_catalog_items || false,
-                test_results: {
-                    steps_executed: 4,
-                    approvals_simulated: params.simulate_approvals ? 1 : 0,
-                    execution_time_ms: 2500,
-                    errors: [],
-                    warnings: ['Mock data used - not production ready']
-                },
-                cleanup_performed: params.cleanup_after_test || false
-            },
-            toolUsed: 'snow_test_flow_with_mock',
-            executionTime: Date.now() - startTime
-        };
-    }
-    /**
-     * Mock snow_update_set_create tool
-     */
-    async snow_update_set_create(params) {
-        const startTime = Date.now();
-        this.callHistory.push({
-            tool: 'snow_update_set_create',
-            params,
-            timestamp: new Date()
-        });
-        await this.simulateDelay(1000, 2000);
-        return {
-            success: true,
-            result: {
-                sys_id: 'mock-update-set-' + Math.random().toString(36).substring(7),
-                name: params.name,
-                description: params.description,
-                state: 'in_progress',
-                created_by: 'mock-user',
-                created_on: new Date().toISOString(),
-                is_active: true
-            },
-            toolUsed: 'snow_update_set_create',
-            executionTime: Date.now() - startTime
-        };
-    }
-    /**
-     * Get call history for analysis
-     */
-    getCallHistory() {
-        return [...this.callHistory];
-    }
-    /**
-     * Get usage statistics
-     */
-    getUsageStats() {
-        const toolUsage = {};
-        for (const call of this.callHistory) {
-            toolUsage[call.tool] = (toolUsage[call.tool] || 0) + 1;
-        }
-        return {
-            totalCalls: this.callHistory.length,
-            toolUsage,
-            avgResponseTime: 2000 // Mock average
-        };
-    }
-    /**
-     * Clear call history
-     */
-    clearHistory() {
-        this.callHistory = [];
-    }
-    /**
-     * Simulate realistic API delay
-     */
-    async simulateDelay(minMs, maxMs) {
-        const delay = Math.random() * (maxMs - minMs) + minMs;
-        return new Promise(resolve => setTimeout(resolve, delay));
-    }
-    /**
-     * COMPATIBILITY FIX: makeRequest method for phantom calls
-     * MockMcpClient simulates HTTP requests
-     */
-    async makeRequest(config) {
-        console.log('🔧 MockMcpClient.makeRequest called with config:', config);
-        // Simulate delay
-        await this.simulateDelay(100, 500);
-        // Return mock response
-        return {
-            success: true,
-            data: {
-                message: 'Mock HTTP response from MockMcpClient',
-                method: config.method || 'GET',
-                url: config.url || config.endpoint,
-                timestamp: new Date().toISOString()
-            },
-            status: 200
-        };
-    }
-}
-exports.MockMcpClient = MockMcpClient;
-exports.default = MockMcpClient;
-//# sourceMappingURL=mock-mcp-client.js.map

package/dist/queen/run-integration-tests.d.ts

@@ -1,9 +0,0 @@
-#!/usr/bin/env node
-/**
- * Queen Agent Integration Test Runner
- *
- * Simplified runner for Queen Agent integration tests
- * Can be called from npm scripts or directly
- */
-export {};
-//# sourceMappingURL=run-integration-tests.d.ts.map

package/dist/queen/run-integration-tests.js

@@ -1,27 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-/**
- * Queen Agent Integration Test Runner
- *
- * Simplified runner for Queen Agent integration tests
- * Can be called from npm scripts or directly
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const integration_test_js_1 = require("./integration-test.js");
-async function runTests() {
-    console.log('🐝 QUEEN AGENT INTEGRATION TESTER');
-    console.log('=================================');
-    console.log('Testing Queen Agent with MCP tools...\n');
-    const tester = new integration_test_js_1.QueenIntegrationTester();
-    try {
-        await tester.runAllTests();
-        console.log('\n🎉 Integration tests completed!');
-        process.exit(0);
-    }
-    catch (error) {
-        console.error('\n💥 Integration tests failed:', error);
-        process.exit(1);
-    }
-}
-// Run tests
-runTests().catch(console.error);

package/dist/sparc/coordinators/adaptive-coordinator.d.ts

@@ -1,54 +0,0 @@
-/**
- * Adaptive Coordinator Agent
- * Dynamically assembles and coordinates teams based on task requirements
- */
-import { TaskAnalysis } from '../../utils/agent-detector.js';
-import { TeamExecutionResult, TeamSparcOptions } from '../team-sparc.js';
-export interface AdaptiveTask {
-    description: string;
-    analysis: TaskAnalysis;
-    options: TeamSparcOptions;
-}
-export interface DynamicAgent {
-    type: string;
-    name: string;
-    confidence: number;
-    capabilities: string[];
-    workload: number;
-    status: 'available' | 'busy' | 'offline';
-    estimatedEffort: string;
-}
-export interface AdaptiveTeamComposition {
-    teamSize: number;
-    primaryAgent: DynamicAgent;
-    supportingAgents: DynamicAgent[];
-    totalConfidence: number;
-    estimatedDuration: string;
-    riskLevel: 'low' | 'medium' | 'high';
-}
-export interface TaskDomainAnalysis {
-    domains: string[];
-    complexity: 'simple' | 'medium' | 'complex' | 'enterprise';
-    crossDomainCount: number;
-    unknownElements: string[];
-    confidenceScore: number;
-}
-export declare class AdaptiveCoordinatorAgent {
-    private availableAgents;
-    private domainKnowledge;
-    private performanceHistory;
-    constructor();
-    executeAdaptiveTask(task: AdaptiveTask): Promise<TeamExecutionResult>;
-    private initializeAgentPool;
-    private initializeDomainKnowledge;
-    private analyzeDomains;
-    private assessTaskComplexity;
-    private composeAdaptiveTeam;
-    private assessRiskLevel;
-    private estimateTeamDuration;
-    private executeAdaptiveCoordination;
-    private generateAdaptivePhases;
-    private updatePerformanceHistory;
-    private generateAdaptiveWarnings;
-}
-//# sourceMappingURL=adaptive-coordinator.d.ts.map