snow-flow 3.0.9 → 3.0.13

package/dist/agents/specialists/automation-specialist.agent.js

@@ -1,204 +0,0 @@
-"use strict";
-/**
- * Automation Specialist Agent - Handles workflow automation, business rules, and scheduled tasks
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AutomationSpecialistAgent = void 0;
-const base_snow_agent_js_1 = require("../base/base-snow-agent.js");
-class AutomationSpecialistAgent extends base_snow_agent_js_1.BaseSnowAgent {
-    constructor() {
-        const capabilities = {
-            primarySkills: [
-                'workflow_design',
-                'business_rules',
-                'scheduled_jobs',
-                'event_handling',
-                'process_automation'
-            ],
-            secondarySkills: [
-                'script_development',
-                'performance_optimization',
-                'error_handling',
-                'monitoring_setup'
-            ],
-            complexity: 'medium',
-            autonomy: 'semi-autonomous'
-        };
-        super('automation-specialist', 'AutomationSpecialist', capabilities);
-    }
-    async execute(task, input) {
-        await this.startTask(task);
-        try {
-            const taskType = task.metadata?.type || 'automation_analysis';
-            let result;
-            switch (taskType) {
-                case 'workflow_creation':
-                    result = await this.createWorkflow(input?.requirements || {});
-                    break;
-                case 'business_rule_setup':
-                    result = await this.setupBusinessRule(input?.config || {});
-                    break;
-                case 'scheduled_task':
-                    result = await this.createScheduledTask(input?.schedule || {});
-                    break;
-                default:
-                    result = await this.analyzeAutomationRequirements(task.description, input);
-            }
-            await this.completeTask(result);
-            return result;
-        }
-        catch (error) {
-            await this.handleError(error);
-            throw error;
-        }
-    }
-    async analyzeAutomationRequirements(description, context) {
-        const normalizedDesc = description.toLowerCase();
-        return {
-            triggerType: this.determineTriggerType(normalizedDesc),
-            targetTable: this.extractTargetTable(normalizedDesc),
-            conditions: this.extractConditions(normalizedDesc),
-            actions: this.identifyActions(normalizedDesc),
-            errorHandling: {
-                onFailure: 'stop',
-                retryAttempts: 3,
-                notifications: ['admin@company.com']
-            },
-            monitoring: {
-                trackExecution: true,
-                logLevel: 'detailed',
-                performanceMetrics: true
-            }
-        };
-    }
-    async createWorkflow(requirements) {
-        return {
-            type: 'workflow',
-            name: `auto_workflow_${Date.now()}`,
-            trigger: requirements.triggerType,
-            table: requirements.targetTable,
-            activities: requirements.actions.map((action, index) => ({
-                id: `activity_${index + 1}`,
-                type: action.type,
-                configuration: action.configuration,
-                order: action.order
-            })),
-            errorHandling: requirements.errorHandling,
-            active: true
-        };
-    }
-    async setupBusinessRule(config) {
-        return {
-            type: 'business_rule',
-            name: config.name || `auto_rule_${Date.now()}`,
-            table: config.table || 'incident',
-            when: config.when || 'before',
-            condition: config.condition || '',
-            script: this.generateBusinessRuleScript(config),
-            active: true
-        };
-    }
-    async createScheduledTask(schedule) {
-        return {
-            type: 'scheduled_job',
-            name: schedule.name || `auto_job_${Date.now()}`,
-            schedule: schedule.frequency || 'daily',
-            script: this.generateScheduledScript(schedule),
-            timezone: schedule.timezone || 'UTC',
-            active: true
-        };
-    }
-    determineTriggerType(description) {
-        if (description.includes('schedule') || description.includes('daily') || description.includes('weekly')) {
-            return 'schedule';
-        }
-        if (description.includes('manual') || description.includes('on-demand')) {
-            return 'manual';
-        }
-        if (description.includes('when') || description.includes('if')) {
-            return 'condition';
-        }
-        return 'event';
-    }
-    extractTargetTable(description) {
-        const tableMatches = description.match(/\b(incident|problem|change_request|task|sys_user)\b/);
-        return tableMatches ? tableMatches[0] : 'task';
-    }
-    extractConditions(description) {
-        const conditions = [];
-        if (description.includes('high priority'))
-            conditions.push('priority=1');
-        if (description.includes('critical'))
-            conditions.push('severity=1');
-        if (description.includes('new'))
-            conditions.push('state=1');
-        return conditions;
-    }
-    identifyActions(description) {
-        const actions = [];
-        let order = 1;
-        if (description.includes('notify') || description.includes('email')) {
-            actions.push({
-                type: 'notification',
-                configuration: { type: 'email', recipients: 'assigned_to' },
-                order: order++
-            });
-        }
-        if (description.includes('update') || description.includes('set')) {
-            actions.push({
-                type: 'field_update',
-                configuration: { field: 'state', value: 'in_progress' },
-                order: order++
-            });
-        }
-        if (description.includes('approval')) {
-            actions.push({
-                type: 'approval_request',
-                configuration: { approver: 'manager' },
-                order: order++
-            });
-        }
-        return actions;
-    }
-    generateBusinessRuleScript(config) {
-        return `
-// Auto-generated business rule script
-if (current.isValidRecord()) {
-  try {
-    // Execute automation logic
-    gs.info('Business rule executed for: ' + current.getDisplayValue());
-    
-    // Add custom logic here
-    ${config.customLogic || '// Custom logic placeholder'}
-    
-  } catch (error) {
-    gs.error('Business rule failed: ' + error.message);
-  }
-}
-    `.trim();
-    }
-    generateScheduledScript(schedule) {
-        return `
-// Auto-generated scheduled job script
-try {
-  var records = new GlideRecord('${schedule.table || 'task'}');
-  records.addQuery('${schedule.condition || 'active=true'}');
-  records.query();
-  
-  var processed = 0;
-  while (records.next()) {
-    // Process each record
-    ${schedule.logic || '// Processing logic placeholder'}
-    processed++;
-  }
-  
-  gs.info('Scheduled job completed: ' + processed + ' records processed');
-  
-} catch (error) {
-  gs.error('Scheduled job failed: ' + error.message);
-}
-    `.trim();
-    }
-}
-exports.AutomationSpecialistAgent = AutomationSpecialistAgent;
-//# sourceMappingURL=automation-specialist.agent.js.map

package/dist/agents/specialists/data-specialist.agent.d.ts

@@ -1,165 +0,0 @@
-/**
- * Data Specialist Agent - Handles data modeling, analysis, and transformation tasks
- */
-import { BaseSnowAgent } from '../base/base-snow-agent.js';
-import { Task } from '../../types/snow-flow.types.js';
-export interface DataRequirements {
-    tables: string[];
-    relationships: TableRelationship[];
-    fields: FieldDefinition[];
-    constraints: DataConstraint[];
-    transformations: DataTransformation[];
-    validationRules: ValidationRule[];
-}
-export interface DataModel {
-    name: string;
-    tables: TableDefinition[];
-    relationships: TableRelationship[];
-    views: ViewDefinition[];
-    indices: IndexDefinition[];
-    policies: DataPolicy[];
-}
-export interface TableDefinition {
-    name: string;
-    label: string;
-    fields: FieldDefinition[];
-    extends?: string;
-    accessControls?: string[];
-}
-export interface FieldDefinition {
-    name: string;
-    type: 'string' | 'integer' | 'boolean' | 'date' | 'datetime' | 'reference' | 'choice' | 'decimal';
-    label: string;
-    maxLength?: number;
-    mandatory?: boolean;
-    defaultValue?: any;
-    choiceOptions?: string[];
-    referenceTable?: string;
-}
-export interface TableRelationship {
-    fromTable: string;
-    toTable: string;
-    type: 'one-to-one' | 'one-to-many' | 'many-to-many';
-    foreignKey: string;
-    referenceField?: string;
-}
-export interface DataConstraint {
-    type: 'unique' | 'not_null' | 'check' | 'foreign_key';
-    table: string;
-    fields: string[];
-    condition?: string;
-}
-export interface DataTransformation {
-    name: string;
-    sourceFields: string[];
-    targetField: string;
-    operation: 'concat' | 'calculate' | 'lookup' | 'format' | 'validate';
-    formula?: string;
-}
-export interface ValidationRule {
-    field: string;
-    type: 'regex' | 'range' | 'enum' | 'custom';
-    rule: string;
-    errorMessage: string;
-}
-export interface ViewDefinition {
-    name: string;
-    baseTable: string;
-    fields: string[];
-    conditions: string[];
-    orderBy?: string[];
-}
-export interface IndexDefinition {
-    name: string;
-    table: string;
-    fields: string[];
-    unique: boolean;
-}
-export interface DataPolicy {
-    name: string;
-    table: string;
-    classification: 'public' | 'internal' | 'confidential' | 'restricted';
-    retention: number;
-    encryption: boolean;
-    masking: boolean;
-}
-export declare class DataSpecialistAgent extends BaseSnowAgent {
-    constructor();
-    /**
-     * Execute data-related tasks
-     */
-    execute(task: Task, input?: any): Promise<any>;
-    /**
-     * Analyze data requirements from task description
-     */
-    analyzeDataRequirements(description: string, context?: any): Promise<DataRequirements>;
-    /**
-     * Create comprehensive data model
-     */
-    createDataModel(requirements: DataRequirements): Promise<DataModel>;
-    /**
-     * Design tables based on specifications
-     */
-    designTables(specification: any): Promise<TableDefinition[]>;
-    /**
-     * Plan data migration strategy
-     */
-    planDataMigration(source: any, target: any): Promise<any>;
-    /**
-     * Validate data structure
-     */
-    validateDataStructure(data: any): Promise<any>;
-    /**
-     * Optimize data performance
-     */
-    optimizeDataPerformance(tables: string[]): Promise<any>;
-    /**
-     * Extract table names from description
-     */
-    private extractTableNames;
-    /**
-     * Identify relationships between tables
-     */
-    private identifyRelationships;
-    /**
-     * Define fields based on description
-     */
-    private defineFields;
-    /**
-     * Define data constraints
-     */
-    private defineConstraints;
-    /**
-     * Plan data transformations
-     */
-    private planTransformations;
-    /**
-     * Create validation rules
-     */
-    private createValidationRules;
-    /**
-     * Create table definitions from requirements
-     */
-    private createTableDefinitions;
-    /**
-     * Create views for complex queries
-     */
-    private createViews;
-    /**
-     * Create performance indices
-     */
-    private createIndices;
-    /**
-     * Create data governance policies
-     */
-    private createDataPolicies;
-    /**
-     * Validate complete data model
-     */
-    private validateDataModel;
-    /**
-     * Format table name to human-readable label
-     */
-    private formatLabel;
-}
-//# sourceMappingURL=data-specialist.agent.d.ts.map