snow-flow 3.0.9 → 3.0.13

package/dist/agents/base/base-snow-agent.d.ts

@@ -1,75 +0,0 @@
-/**
- * Base class for all ServiceNow agents in the adaptive system
- */
-import { SnowAgent, AgentType, AgentStatus, Task, ServiceNowContext } from '../../types/snow-flow.types.js';
-import { ServiceNowClient } from '../../utils/servicenow-client.js';
-import { Logger } from '../../utils/logger.js';
-import { EventEmitter } from 'eventemitter3';
-export interface AgentCapabilities {
-    primarySkills: string[];
-    secondarySkills: string[];
-    complexity: 'low' | 'medium' | 'high';
-    autonomy: 'guided' | 'semi-autonomous' | 'fully-autonomous';
-}
-export interface AgentMetrics {
-    tasksCompleted: number;
-    successRate: number;
-    averageExecutionTime: number;
-    lastActivity: Date;
-    errorCount: number;
-}
-export declare abstract class BaseSnowAgent extends EventEmitter {
-    protected id: string;
-    protected name: string;
-    protected type: AgentType;
-    protected status: AgentStatus;
-    protected capabilities: AgentCapabilities;
-    protected metrics: AgentMetrics;
-    protected client: ServiceNowClient;
-    protected logger: Logger;
-    protected context: ServiceNowContext | null;
-    protected currentTask: Task | null;
-    constructor(type: AgentType, name: string, capabilities: AgentCapabilities);
-    /**
-     * Get agent information
-     */
-    getInfo(): SnowAgent;
-    /**
-     * Set ServiceNow context for the agent
-     */
-    setContext(context: ServiceNowContext): void;
-    /**
-     * Execute a task - must be implemented by subclasses
-     */
-    abstract execute(task: Task, input?: any): Promise<any>;
-    /**
-     * Analyze if this agent can handle a specific requirement
-     */
-    canHandle(requirement: string, complexity?: 'low' | 'medium' | 'high'): number;
-    /**
-     * Start task execution
-     */
-    protected startTask(task: Task): Promise<void>;
-    /**
-     * Complete task execution
-     */
-    protected completeTask(result: any): Promise<void>;
-    /**
-     * Handle task error
-     */
-    protected handleError(error: Error): Promise<void>;
-    /**
-     * Terminate the agent
-     */
-    terminate(): void;
-    /**
-     * Get agent health status
-     */
-    getHealth(): {
-        status: string;
-        performance: number;
-        load: 'low' | 'medium' | 'high';
-        ready: boolean;
-    };
-}
-//# sourceMappingURL=base-snow-agent.d.ts.map

package/dist/agents/base/base-snow-agent.js

@@ -1,169 +0,0 @@
-"use strict";
-/**
- * Base class for all ServiceNow agents in the adaptive system
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseSnowAgent = void 0;
-const servicenow_client_js_1 = require("../../utils/servicenow-client.js");
-const logger_js_1 = require("../../utils/logger.js");
-const eventemitter3_1 = require("eventemitter3");
-class BaseSnowAgent extends eventemitter3_1.EventEmitter {
-    constructor(type, name, capabilities) {
-        super();
-        this.context = null;
-        this.currentTask = null;
-        this.id = `${type}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-        this.name = name;
-        this.type = type;
-        this.status = 'idle';
-        this.capabilities = capabilities;
-        this.metrics = {
-            tasksCompleted: 0,
-            successRate: 1.0,
-            averageExecutionTime: 0,
-            lastActivity: new Date(),
-            errorCount: 0
-        };
-        this.client = new servicenow_client_js_1.ServiceNowClient();
-        this.logger = new logger_js_1.Logger(`Agent:${name}`);
-    }
-    /**
-     * Get agent information
-     */
-    getInfo() {
-        return {
-            id: this.id,
-            name: this.name,
-            type: this.type,
-            status: this.status,
-            capabilities: this.capabilities.primarySkills,
-            metadata: {
-                capabilities: this.capabilities,
-                metrics: this.metrics,
-                context: this.context
-            },
-            createdAt: new Date(),
-            lastActivity: this.metrics.lastActivity
-        };
-    }
-    /**
-     * Set ServiceNow context for the agent
-     */
-    setContext(context) {
-        this.context = context;
-        this.logger.info('Context updated', { context });
-    }
-    /**
-     * Analyze if this agent can handle a specific requirement
-     */
-    canHandle(requirement, complexity = 'medium') {
-        // Base scoring algorithm
-        let score = 0;
-        const normalizedReq = requirement.toLowerCase();
-        // Primary skills matching
-        for (const skill of this.capabilities.primarySkills) {
-            if (normalizedReq.includes(skill.toLowerCase())) {
-                score += 0.8;
-            }
-        }
-        // Secondary skills matching
-        for (const skill of this.capabilities.secondarySkills) {
-            if (normalizedReq.includes(skill.toLowerCase())) {
-                score += 0.4;
-            }
-        }
-        // Complexity matching
-        const complexityMap = { 'low': 1, 'medium': 2, 'high': 3 };
-        const reqComplexity = complexityMap[complexity];
-        const agentComplexity = complexityMap[this.capabilities.complexity];
-        if (agentComplexity >= reqComplexity) {
-            score += 0.2;
-        }
-        else if (agentComplexity < reqComplexity - 1) {
-            score *= 0.5; // Penalize if agent can't handle complexity
-        }
-        // Experience bonus based on success rate
-        score *= this.metrics.successRate;
-        return Math.min(score, 1.0);
-    }
-    /**
-     * Start task execution
-     */
-    async startTask(task) {
-        this.currentTask = task;
-        this.status = 'busy';
-        this.logger.info('Starting task', { taskId: task.id, description: task.description });
-        this.emit('task:started', { agentId: this.id, taskId: task.id });
-    }
-    /**
-     * Complete task execution
-     */
-    async completeTask(result) {
-        if (this.currentTask) {
-            this.metrics.tasksCompleted++;
-            this.metrics.lastActivity = new Date();
-            // Update success rate
-            const totalTasks = this.metrics.tasksCompleted + this.metrics.errorCount;
-            this.metrics.successRate = this.metrics.tasksCompleted / totalTasks;
-            this.logger.info('Task completed', {
-                taskId: this.currentTask.id,
-                result: typeof result === 'object' ? 'object' : result
-            });
-            this.emit('task:completed', {
-                agentId: this.id,
-                taskId: this.currentTask.id,
-                result
-            });
-            this.currentTask = null;
-            this.status = 'idle';
-        }
-    }
-    /**
-     * Handle task error
-     */
-    async handleError(error) {
-        this.metrics.errorCount++;
-        this.metrics.lastActivity = new Date();
-        // Update success rate
-        const totalTasks = this.metrics.tasksCompleted + this.metrics.errorCount;
-        this.metrics.successRate = this.metrics.tasksCompleted / totalTasks;
-        this.logger.error('Task failed', {
-            taskId: this.currentTask?.id,
-            error: error.message
-        });
-        this.emit('task:failed', {
-            agentId: this.id,
-            taskId: this.currentTask?.id,
-            error
-        });
-        this.status = 'error';
-        // Reset to idle after a short delay
-        setTimeout(() => {
-            this.status = 'idle';
-        }, 5000);
-    }
-    /**
-     * Terminate the agent
-     */
-    terminate() {
-        this.status = 'terminated';
-        this.emit('agent:terminated', { agentId: this.id });
-        this.removeAllListeners();
-    }
-    /**
-     * Get agent health status
-     */
-    getHealth() {
-        const performance = this.metrics.successRate * 100;
-        const load = this.status === 'busy' ? 'high' : 'low';
-        const ready = this.status === 'idle';
-        return {
-            status: this.status,
-            performance,
-            load,
-            ready
-        };
-    }
-}
-exports.BaseSnowAgent = BaseSnowAgent;
-//# sourceMappingURL=base-snow-agent.js.map

package/dist/agents/base-snow-agent.d.ts

@@ -1,63 +0,0 @@
-import { EventEmitter } from 'eventemitter3';
-import { Logger } from 'winston';
-import { SnowAgent, AgentType, AgentStatus, Task, AgentMessage, MessageType } from '../types/snow-flow.types.js';
-import { SnowMemory } from '../memory/snow-memory.js';
-import { SnowOrchestrator } from '../orchestrator/snow-orchestrator.js';
-export interface BaseSnowAgentOptions {
-    id: string;
-    type: AgentType;
-    name: string;
-    capabilities: string[];
-    metadata: Record<string, any>;
-    orchestrator: SnowOrchestrator;
-    memory: SnowMemory;
-    logger: Logger;
-}
-export interface AgentEvents {
-    'status:changed': (status: AgentStatus) => void;
-    'task:started': (task: Task) => void;
-    'task:completed': (task: Task, result: any) => void;
-    'task:failed': (task: Task, error: Error) => void;
-    'message:received': (message: AgentMessage) => void;
-    'message:sent': (message: AgentMessage) => void;
-}
-export declare class BaseSnowAgent extends EventEmitter<AgentEvents> {
-    protected id: string;
-    protected type: AgentType;
-    protected name: string;
-    protected capabilities: string[];
-    protected metadata: Record<string, any>;
-    protected status: AgentStatus;
-    protected orchestrator: SnowOrchestrator;
-    protected memory: SnowMemory;
-    protected logger: Logger;
-    protected currentTask?: Task;
-    protected messageHandlers: Map<MessageType, (message: AgentMessage) => Promise<void>>;
-    protected createdAt: Date;
-    protected lastActivity: Date;
-    constructor(options: BaseSnowAgentOptions);
-    initialize(): Promise<void>;
-    executeTask(task: Task): Promise<any>;
-    protected performTask(task: Task): Promise<any>;
-    protected performResearch(task: Task): Promise<any>;
-    protected performDevelopment(task: Task): Promise<any>;
-    protected performAnalysis(task: Task): Promise<any>;
-    protected performTesting(task: Task): Promise<any>;
-    protected performDocumentation(task: Task): Promise<any>;
-    protected performServiceNowConfig(task: Task): Promise<any>;
-    protected performServiceNowScript(task: Task): Promise<any>;
-    protected performServiceNowWorkflow(task: Task): Promise<any>;
-    protected performServiceNowUI(task: Task): Promise<any>;
-    protected simulateWork(duration: number): Promise<void>;
-    receiveMessage(message: AgentMessage): Promise<void>;
-    sendMessage(to: string, type: MessageType, payload: any): Promise<void>;
-    protected setupDefaultMessageHandlers(): void;
-    protected setStatus(status: AgentStatus): void;
-    protected updateActivity(): void;
-    getInfo(): SnowAgent;
-    getId(): string;
-    getStatus(): AgentStatus;
-    getCapabilities(): string[];
-    terminate(): Promise<void>;
-}
-//# sourceMappingURL=base-snow-agent.d.ts.map

package/dist/agents/base-snow-agent.js

@@ -1,296 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseSnowAgent = void 0;
-const eventemitter3_1 = require("eventemitter3");
-class BaseSnowAgent extends eventemitter3_1.EventEmitter {
-    constructor(options) {
-        super();
-        this.status = 'idle';
-        this.id = options.id;
-        this.type = options.type;
-        this.name = options.name;
-        this.capabilities = options.capabilities;
-        this.metadata = options.metadata;
-        this.orchestrator = options.orchestrator;
-        this.memory = options.memory;
-        this.logger = options.logger;
-        this.messageHandlers = new Map();
-        this.createdAt = new Date();
-        this.lastActivity = new Date();
-        this.setupDefaultMessageHandlers();
-    }
-    async initialize() {
-        // Store agent info in memory for coordination
-        await this.memory.store(`agent:${this.id}`, this.getInfo(), {
-            ttl: 86400000, // 24 hours
-            namespace: 'agents'
-        });
-        this.logger.info(`Agent ${this.name} initialized`, {
-            id: this.id,
-            type: this.type,
-            capabilities: this.capabilities
-        });
-        this.setStatus('idle');
-    }
-    async executeTask(task) {
-        this.currentTask = task;
-        this.setStatus('busy');
-        this.emit('task:started', task);
-        this.updateActivity();
-        try {
-            // Log task execution
-            this.logger.info(`Agent ${this.name} executing task`, {
-                taskId: task.id,
-                taskType: task.type,
-                taskDescription: task.description
-            });
-            // Execute based on task type
-            const result = await this.performTask(task);
-            // Store result in memory for other agents
-            await this.memory.store(`task:${task.id}:result`, result, {
-                namespace: 'tasks',
-                ttl: 3600000 // 1 hour
-            });
-            this.emit('task:completed', task, result);
-            this.currentTask = undefined;
-            this.setStatus('idle');
-            return result;
-        }
-        catch (error) {
-            this.logger.error(`Agent ${this.name} task failed`, {
-                taskId: task.id,
-                error: error instanceof Error ? error.message : 'Unknown error'
-            });
-            this.emit('task:failed', task, error);
-            this.currentTask = undefined;
-            this.setStatus('idle');
-            throw error;
-        }
-    }
-    async performTask(task) {
-        // Base implementation - override in specific agent types
-        switch (task.type) {
-            case 'research':
-                return await this.performResearch(task);
-            case 'development':
-                return await this.performDevelopment(task);
-            case 'analysis':
-                return await this.performAnalysis(task);
-            case 'testing':
-                return await this.performTesting(task);
-            case 'documentation':
-                return await this.performDocumentation(task);
-            case 'servicenow-config':
-                return await this.performServiceNowConfig(task);
-            case 'servicenow-script':
-                return await this.performServiceNowScript(task);
-            case 'servicenow-workflow':
-                return await this.performServiceNowWorkflow(task);
-            case 'servicenow-ui':
-                return await this.performServiceNowUI(task);
-            default:
-                throw new Error(`Unknown task type: ${task.type}`);
-        }
-    }
-    async performResearch(task) {
-        // Simulate research task
-        await this.simulateWork(2000);
-        return {
-            findings: `Research completed for: ${task.description}`,
-            sources: ['documentation', 'best-practices', 'community-forums'],
-            recommendations: ['Consider approach A', 'Review existing patterns', 'Test thoroughly']
-        };
-    }
-    async performDevelopment(task) {
-        // Simulate development task
-        await this.simulateWork(3000);
-        return {
-            code: `// Implementation for: ${task.description}\nfunction implement() {\n  // TODO: Actual implementation\n}`,
-            files: ['src/implementation.ts'],
-            tests: ['src/implementation.test.ts']
-        };
-    }
-    async performAnalysis(task) {
-        // Simulate analysis task
-        await this.simulateWork(2500);
-        return {
-            analysis: `Analysis completed for: ${task.description}`,
-            metrics: { complexity: 'medium', performance: 'good', maintainability: 'high' },
-            issues: [],
-            recommendations: ['Optimize query performance', 'Add caching layer']
-        };
-    }
-    async performTesting(task) {
-        // Simulate testing task
-        await this.simulateWork(3500);
-        return {
-            testResults: {
-                total: 10,
-                passed: 9,
-                failed: 1,
-                skipped: 0
-            },
-            coverage: 85,
-            issues: ['Edge case in error handling']
-        };
-    }
-    async performDocumentation(task) {
-        // Simulate documentation task
-        await this.simulateWork(2000);
-        return {
-            documentation: `# Documentation\n\n${task.description}\n\n## Overview\n\nDocumentation generated by AI agent.`,
-            format: 'markdown',
-            sections: ['Overview', 'Usage', 'API Reference', 'Examples']
-        };
-    }
-    async performServiceNowConfig(task) {
-        // ServiceNow configuration task
-        await this.simulateWork(2500);
-        const context = this.orchestrator.getServiceNowContext();
-        return {
-            configuration: {
-                tables: ['incident', 'problem', 'change_request'],
-                businessRules: ['validate_priority', 'auto_assign'],
-                clientScripts: ['field_validation', 'ui_policies'],
-                aclRules: ['read_access', 'write_access']
-            },
-            updateSet: context?.updateSet || 'Default Update Set',
-            scope: context?.scope || 'global'
-        };
-    }
-    async performServiceNowScript(task) {
-        // ServiceNow script development
-        await this.simulateWork(3000);
-        return {
-            scripts: {
-                businessRule: `(function executeRule(current, previous /*null when async*/) {\n  // Business rule implementation\n  gs.info('Processing ' + current.getDisplayValue());\n})(current, previous);`,
-                scriptInclude: `var MyUtility = Class.create();\nMyUtility.prototype = {\n  initialize: function() {},\n  process: function(gr) {\n    // Implementation\n  },\n  type: 'MyUtility'\n};`
-            },
-            apiUsage: ['GlideRecord', 'GlideSystem', 'GlideDateTime']
-        };
-    }
-    async performServiceNowWorkflow(task) {
-        // ServiceNow workflow design
-        await this.simulateWork(3500);
-        return {
-            workflow: {
-                name: 'Automated Approval Process',
-                stages: ['Submit', 'Review', 'Approve', 'Implement'],
-                activities: ['User Task', 'Approval', 'Script Action', 'Notification'],
-                conditions: ['Priority Check', 'Manager Approval Required']
-            },
-            flowDesigner: {
-                triggers: ['Record Created', 'Field Changed'],
-                actions: ['Create Task', 'Send Email', 'Update Record'],
-                flows: 1
-            }
-        };
-    }
-    async performServiceNowUI(task) {
-        // ServiceNow UI development
-        await this.simulateWork(3000);
-        return {
-            ui: {
-                servicePortalWidgets: ['custom-dashboard', 'request-form'],
-                uiPages: ['custom_view', 'report_page'],
-                uiScripts: ['widget_controller.js', 'client_script.js'],
-                styles: ['custom.css', 'theme.scss']
-            },
-            components: {
-                angular: ['dashboard-component', 'form-component'],
-                templates: ['widget.html', 'page.html']
-            }
-        };
-    }
-    async simulateWork(duration) {
-        // Simulate work being done
-        await new Promise(resolve => setTimeout(resolve, duration));
-    }
-    async receiveMessage(message) {
-        this.emit('message:received', message);
-        this.updateActivity();
-        const handler = this.messageHandlers.get(message.type);
-        if (handler) {
-            await handler(message);
-        }
-        else {
-            this.logger.warn(`No handler for message type: ${message.type}`, { message });
-        }
-    }
-    async sendMessage(to, type, payload) {
-        const message = {
-            from: this.id,
-            to,
-            type,
-            payload
-        };
-        await this.orchestrator.broadcastMessage(message);
-        this.emit('message:sent', { ...message, timestamp: new Date() });
-        this.updateActivity();
-    }
-    setupDefaultMessageHandlers() {
-        // Task assignment handler
-        this.messageHandlers.set('task_assignment', async (message) => {
-            this.logger.info(`Agent ${this.name} received task assignment`, { message });
-        });
-        // Knowledge share handler
-        this.messageHandlers.set('knowledge_share', async (message) => {
-            // Store shared knowledge in memory
-            await this.memory.store(`knowledge:${message.correlationId || nanoid()}`, message.payload, { namespace: 'knowledge', ttl: 86400000 });
-            this.logger.info(`Agent ${this.name} received knowledge share`, { message });
-        });
-        // Coordination handler
-        this.messageHandlers.set('coordination', async (message) => {
-            this.logger.info(`Agent ${this.name} received coordination message`, { message });
-        });
-        // Status update handler
-        this.messageHandlers.set('status_update', async (message) => {
-            this.logger.info(`Agent ${this.name} received status update`, { message });
-        });
-        // Error handler
-        this.messageHandlers.set('error', async (message) => {
-            this.logger.error(`Agent ${this.name} received error message`, { message });
-        });
-    }
-    setStatus(status) {
-        this.status = status;
-        this.emit('status:changed', status);
-        this.updateActivity();
-    }
-    updateActivity() {
-        this.lastActivity = new Date();
-    }
-    getInfo() {
-        return {
-            id: this.id,
-            name: this.name,
-            type: this.type,
-            status: this.status,
-            capabilities: this.capabilities,
-            metadata: this.metadata,
-            createdAt: this.createdAt,
-            lastActivity: this.lastActivity
-        };
-    }
-    getId() {
-        return this.id;
-    }
-    getStatus() {
-        return this.status;
-    }
-    getCapabilities() {
-        return this.capabilities;
-    }
-    async terminate() {
-        // Clean up resources
-        await this.memory.delete(`agent:${this.id}`);
-        if (this.currentTask) {
-            this.emit('task:failed', this.currentTask, new Error('Agent terminated'));
-        }
-        this.setStatus('terminated');
-        this.removeAllListeners();
-        this.logger.info(`Agent ${this.name} terminated`);
-    }
-}
-exports.BaseSnowAgent = BaseSnowAgent;
-//# sourceMappingURL=base-snow-agent.js.map