snow-flow 3.0.9 → 3.0.10

package/dist/orchestrator/snow-orchestrator.d.ts

@@ -1,49 +0,0 @@
-/**
- * ServiceNow Multi-Agent Orchestrator
- */
-import { ServiceNowConfig, AgentTask } from '../types/servicenow.types.js';
-export declare class ServiceNowOrchestrator {
-    private agents;
-    private config;
-    private logger;
-    private taskQueue;
-    private activeAgents;
-    constructor(config: ServiceNowConfig);
-    /**
-     * Initialize all ServiceNow agents
-     */
-    private initializeAgents;
-    /**
-     * Register an agent with the orchestrator
-     */
-    private registerAgent;
-    /**
-     * Submit a task to the orchestrator
-     */
-    submitTask(task: AgentTask): Promise<void>;
-    /**
-     * Process tasks from the queue
-     */
-    private processTasks;
-    /**
-     * Execute a single task
-     */
-    private executeTask;
-    /**
-     * Select the appropriate agent for a task
-     */
-    private selectAgent;
-    /**
-     * Process orchestration commands
-     */
-    private processCommands;
-    /**
-     * Get orchestrator status
-     */
-    getStatus(): any;
-    /**
-     * Create a complex ServiceNow application from requirements
-     */
-    createApplicationFromRequirements(requirements: string, options?: any): Promise<void>;
-}
-//# sourceMappingURL=snow-orchestrator.d.ts.map

package/dist/orchestrator/snow-orchestrator.js

@@ -1,235 +0,0 @@
-"use strict";
-/**
- * ServiceNow Multi-Agent Orchestrator
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServiceNowOrchestrator = void 0;
-const widget_builder_agent_js_1 = require("../agents/widget-builder.agent.js");
-const workflow_designer_agent_js_1 = require("../agents/workflow-designer.agent.js");
-const script_generator_agent_js_1 = require("../agents/script-generator.agent.js");
-const ui_builder_agent_js_1 = require("../agents/ui-builder.agent.js");
-const app_creator_agent_js_1 = require("../agents/app-creator.agent.js");
-const logger_js_1 = require("../utils/logger.js");
-class ServiceNowOrchestrator {
-    constructor(config) {
-        this.config = config;
-        this.agents = new Map();
-        this.taskQueue = [];
-        this.activeAgents = new Set();
-        this.logger = new logger_js_1.Logger('orchestrator');
-        this.initializeAgents();
-    }
-    /**
-     * Initialize all ServiceNow agents
-     */
-    initializeAgents() {
-        this.logger.info('Initializing ServiceNow agents...');
-        // Create and register agents
-        this.registerAgent(new widget_builder_agent_js_1.WidgetBuilderAgent(this.config));
-        this.registerAgent(new workflow_designer_agent_js_1.WorkflowDesignerAgent(this.config));
-        this.registerAgent(new script_generator_agent_js_1.ScriptGeneratorAgent(this.config));
-        this.registerAgent(new ui_builder_agent_js_1.UIBuilderAgent(this.config));
-        this.registerAgent(new app_creator_agent_js_1.AppCreatorAgent(this.config));
-        this.logger.info(`Initialized ${this.agents.size} agents`);
-    }
-    /**
-     * Register an agent with the orchestrator
-     */
-    registerAgent(agent) {
-        this.agents.set(agent.type, agent);
-        this.logger.info(`Registered agent: ${agent.name} (${agent.type})`);
-    }
-    /**
-     * Submit a task to the orchestrator
-     */
-    async submitTask(task) {
-        this.logger.info(`Task submitted: ${task.id} - ${task.description}`);
-        this.taskQueue.push(task);
-        // Process immediately if no other tasks are running
-        if (this.activeAgents.size === 0) {
-            await this.processTasks();
-        }
-    }
-    /**
-     * Process tasks from the queue
-     */
-    async processTasks() {
-        while (this.taskQueue.length > 0) {
-            const task = this.taskQueue.shift();
-            await this.executeTask(task);
-        }
-    }
-    /**
-     * Execute a single task
-     */
-    async executeTask(task) {
-        try {
-            // Determine which agent should handle the task
-            const agent = this.selectAgent(task);
-            if (!agent) {
-                throw new Error(`No agent available for task type: ${task.type}`);
-            }
-            this.activeAgents.add(agent.name);
-            this.logger.info(`Assigning task ${task.id} to agent: ${agent.name}`);
-            // Coordinate with other agents
-            const otherAgents = Array.from(this.agents.values()).filter(a => a !== agent);
-            await agent.coordinate(otherAgents);
-            // Execute the task
-            const result = await agent.execute(task);
-            if (result.success) {
-                this.logger.info(`Task ${task.id} completed successfully`);
-                // Process any orchestration commands
-                if (result.commands) {
-                    await this.processCommands(result.commands);
-                }
-            }
-            else {
-                this.logger.error(`Task ${task.id} failed: ${result.error}`);
-            }
-        }
-        catch (error) {
-            this.logger.error(`Task execution error: ${error.message}`);
-        }
-        finally {
-            // Remove from active agents
-            const agent = this.selectAgent(task);
-            if (agent) {
-                this.activeAgents.delete(agent.name);
-            }
-        }
-    }
-    /**
-     * Select the appropriate agent for a task
-     */
-    selectAgent(task) {
-        // Map task types to agent types
-        const taskToAgentMap = {
-            'create_widget': servicenow_types_js_1.AgentType.WIDGET_BUILDER,
-            'update_widget': servicenow_types_js_1.AgentType.WIDGET_BUILDER,
-            'generate_template': servicenow_types_js_1.AgentType.WIDGET_BUILDER,
-            'widget_from_spec': servicenow_types_js_1.AgentType.WIDGET_BUILDER,
-            'create_workflow': servicenow_types_js_1.AgentType.WORKFLOW_DESIGNER,
-            'add_workflow_components': servicenow_types_js_1.AgentType.WORKFLOW_DESIGNER,
-            'generate_flow_from_requirements': servicenow_types_js_1.AgentType.WORKFLOW_DESIGNER,
-            'optimize_workflow': servicenow_types_js_1.AgentType.WORKFLOW_DESIGNER,
-            'generate_business_rule': servicenow_types_js_1.AgentType.SCRIPT_GENERATOR,
-            'generate_script_include': servicenow_types_js_1.AgentType.SCRIPT_GENERATOR,
-            'generate_client_script': servicenow_types_js_1.AgentType.SCRIPT_GENERATOR,
-            'generate_from_requirements': servicenow_types_js_1.AgentType.SCRIPT_GENERATOR,
-            'optimize_script': servicenow_types_js_1.AgentType.SCRIPT_GENERATOR,
-            'create_ui_page': servicenow_types_js_1.AgentType.UI_BUILDER,
-            'create_ui_action': servicenow_types_js_1.AgentType.UI_BUILDER,
-            'generate_ui_from_spec': servicenow_types_js_1.AgentType.UI_BUILDER,
-            'create_form_layout': servicenow_types_js_1.AgentType.UI_BUILDER,
-            'create_ui_components': servicenow_types_js_1.AgentType.UI_BUILDER,
-            'create_application': servicenow_types_js_1.AgentType.APP_CREATOR,
-            'generate_from_requirements': servicenow_types_js_1.AgentType.APP_CREATOR,
-            'add_app_components': servicenow_types_js_1.AgentType.APP_CREATOR,
-            'package_application': servicenow_types_js_1.AgentType.APP_CREATOR
-        };
-        const agentType = taskToAgentMap[task.type];
-        return agentType ? this.agents.get(agentType) : undefined;
-    }
-    /**
-     * Process orchestration commands
-     */
-    async processCommands(commands) {
-        this.logger.info(`Processing ${commands.length} orchestration commands`);
-        // In a real implementation, these commands would be executed
-        // For now, we'll log them
-        commands.forEach(cmd => {
-            this.logger.debug(`Command: ${cmd.tool}.${cmd.action} - ${cmd.description}`);
-        });
-    }
-    /**
-     * Get orchestrator status
-     */
-    getStatus() {
-        return {
-            agents: Array.from(this.agents.entries()).map(([type, agent]) => ({
-                type,
-                name: agent.name,
-                capabilities: agent.capabilities,
-                active: this.activeAgents.has(agent.name)
-            })),
-            queueLength: this.taskQueue.length,
-            activeAgents: Array.from(this.activeAgents)
-        };
-    }
-    /**
-     * Create a complex ServiceNow application from requirements
-     */
-    async createApplicationFromRequirements(requirements, options) {
-        this.logger.info('Creating application from requirements...');
-        // Break down into coordinated tasks
-        const tasks = [
-            {
-                id: 'app-1',
-                type: 'create_application',
-                description: 'Create base application structure',
-                payload: {
-                    name: options?.name || 'Custom Application',
-                    description: requirements,
-                    vendor: options?.vendor
-                },
-                priority: 'high'
-            },
-            {
-                id: 'workflow-1',
-                type: 'generate_flow_from_requirements',
-                description: 'Generate workflows based on requirements',
-                payload: {
-                    requirements,
-                    name: 'Main Process Flow'
-                },
-                priority: 'high',
-                dependencies: ['app-1']
-            },
-            {
-                id: 'script-1',
-                type: 'generate_from_requirements',
-                description: 'Generate necessary scripts',
-                payload: {
-                    requirements,
-                    scriptType: 'business_rule'
-                },
-                priority: 'medium',
-                dependencies: ['app-1']
-            },
-            {
-                id: 'ui-1',
-                type: 'generate_ui_from_spec',
-                description: 'Generate UI components',
-                payload: {
-                    spec: {
-                        name: 'Application Dashboard',
-                        type: 'dashboard'
-                    },
-                    type: 'dashboard'
-                },
-                priority: 'medium',
-                dependencies: ['app-1']
-            },
-            {
-                id: 'widget-1',
-                type: 'widget_from_spec',
-                description: 'Create dashboard widgets',
-                payload: {
-                    name: 'Status Widget',
-                    components: [
-                        { type: 'metric', binding: 'total_count' },
-                        { type: 'list', binding: 'recent_items' }
-                    ]
-                },
-                priority: 'low',
-                dependencies: ['ui-1']
-            }
-        ];
-        // Submit all tasks
-        for (const task of tasks) {
-            await this.submitTask(task);
-        }
-    }
-}
-exports.ServiceNowOrchestrator = ServiceNowOrchestrator;
-//# sourceMappingURL=snow-orchestrator.js.map

package/dist/orchestrator/subflow-creation-handler.d.ts

@@ -1,230 +0,0 @@
-/**
- * ServiceNow Subflow Creation Handler
- *
- * This module handles the creation of subflows with proper input/output management,
- * validation, and integration with the main flow composer.
- */
-import { SubflowCandidate, SubflowInput, SubflowOutput, ComplexityLevel, ReusabilityLevel } from './flow-subflow-decision-engine.js';
-/**
- * Subflow definition structure
- */
-export interface SubflowDefinition {
-    name: string;
-    label: string;
-    description: string;
-    category: string;
-    inputs: SubflowInputDefinition[];
-    outputs: SubflowOutputDefinition[];
-    activities: SubflowActivity[];
-    connections: SubflowConnection[];
-    errorHandling: SubflowErrorHandling[];
-    metadata: SubflowMetadata;
-}
-/**
- * Enhanced subflow input definition
- */
-export interface SubflowInputDefinition extends SubflowInput {
-    label: string;
-    category: string;
-    order: number;
-    tooltip?: string;
-    placeholder?: string;
-    options?: string[];
-    dependsOn?: string[];
-    conditionalLogic?: string;
-}
-/**
- * Enhanced subflow output definition
- */
-export interface SubflowOutputDefinition extends SubflowOutput {
-    label: string;
-    category: string;
-    order: number;
-    tooltip?: string;
-    format?: string;
-    conditionalLogic?: string;
-}
-/**
- * Subflow activity definition
- */
-export interface SubflowActivity {
-    id: string;
-    name: string;
-    type: string;
-    label: string;
-    description: string;
-    inputs: Record<string, any>;
-    outputs: Record<string, any>;
-    position: {
-        x: number;
-        y: number;
-    };
-    configuration: Record<string, any>;
-    errorHandling: ActivityErrorHandling[];
-}
-/**
- * Subflow connection definition
- */
-export interface SubflowConnection {
-    id: string;
-    from: string;
-    to: string;
-    label?: string;
-    condition?: string;
-    conditionLabel?: string;
-    errorPath?: boolean;
-}
-/**
- * Subflow error handling
- */
-export interface SubflowErrorHandling {
-    id: string;
-    condition: string;
-    action: 'retry' | 'skip' | 'stop' | 'notify' | 'fallback';
-    parameters: Record<string, any>;
-    description: string;
-}
-/**
- * Activity-specific error handling
- */
-export interface ActivityErrorHandling {
-    condition: string;
-    action: string;
-    parameters: Record<string, any>;
-}
-/**
- * Subflow metadata
- */
-export interface SubflowMetadata {
-    version: string;
-    author: string;
-    created: Date;
-    updated: Date;
-    tags: string[];
-    complexity: ComplexityLevel;
-    reusability: ReusabilityLevel;
-    testCoverage: number;
-    documentation: string;
-    dependencies: string[];
-    compatibleVersions: string[];
-}
-/**
- * Subflow creation result
- */
-export interface SubflowCreationResult {
-    success: boolean;
-    subflow?: SubflowDefinition;
-    sys_id?: string;
-    url?: string;
-    validationErrors?: string[];
-    warnings?: string[];
-    recommendations?: string[];
-}
-/**
- * Subflow template
- */
-export interface SubflowTemplate {
-    name: string;
-    description: string;
-    category: string;
-    complexity: ComplexityLevel;
-    baseInputs: SubflowInputDefinition[];
-    baseOutputs: SubflowOutputDefinition[];
-    baseActivities: SubflowActivity[];
-    baseConnections: SubflowConnection[];
-    customizationPoints: string[];
-}
-/**
- * Subflow Creation Handler
- */
-export declare class SubflowCreationHandler {
-    private logger;
-    private client;
-    private templates;
-    constructor();
-    /**
-     * Create a subflow from a candidate
-     */
-    createSubflow(candidate: SubflowCandidate): Promise<SubflowCreationResult>;
-    /**
-     * Create multiple subflows from candidates
-     */
-    createMultipleSubflows(candidates: SubflowCandidate[]): Promise<SubflowCreationResult[]>;
-    /**
-     * Build subflow definition from candidate
-     */
-    private buildSubflowDefinition;
-    /**
-     * Build input definitions with enhanced metadata
-     */
-    private buildInputDefinitions;
-    /**
-     * Build output definitions with enhanced metadata
-     */
-    private buildOutputDefinitions;
-    /**
-     * Build activities for the subflow
-     */
-    private buildActivities;
-    /**
-     * Build connections between activities
-     */
-    private buildConnections;
-    /**
-     * Build error handling for the subflow
-     */
-    private buildErrorHandling;
-    /**
-     * Create activity from action string
-     */
-    private createActivityFromAction;
-    /**
-     * Validate candidate before processing
-     */
-    private validateCandidate;
-    /**
-     * Validate complete subflow definition
-     */
-    private validateSubflowDefinition;
-    /**
-     * Deploy subflow to ServiceNow
-     */
-    private deploySubflow;
-    /**
-     * Convert subflow definition to ServiceNow format
-     */
-    private convertToServiceNowFormat;
-    /**
-     * Generate recommendations for the subflow
-     */
-    private generateRecommendations;
-    /**
-     * Initialize subflow templates
-     */
-    private initializeTemplates;
-    private sanitizeName;
-    private determineCategory;
-    private findMatchingTemplate;
-    private generateTags;
-    private generateDocumentation;
-    private generateInputLabel;
-    private generateOutputLabel;
-    private categorizeInput;
-    private categorizeOutput;
-    private generatePlaceholder;
-    private generateInputOptions;
-    private findInputDependencies;
-    private generateOutputFormat;
-    private buildEndOutputs;
-    private generateConnectionLabel;
-    private mapActionToActivityType;
-    private generateActivityName;
-    private generateActivityLabel;
-    private generateActivityDescription;
-    private generateActivityInputs;
-    private generateActivityOutputs;
-    private generateActivityConfiguration;
-    private generateActivityErrorHandling;
-    private delay;
-}
-//# sourceMappingURL=subflow-creation-handler.d.ts.map