snow-flow 3.0.8 → 3.0.10

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

@@ -1,54 +0,0 @@
-/**
- * Reporting Specialist Agent - Handles reports, dashboards, and analytics
- */
-import { BaseSnowAgent } from '../base/base-snow-agent.js';
-import { Task } from '../../types/snow-flow.types.js';
-export interface ReportingRequirements {
-    reportType: 'list' | 'chart' | 'dashboard' | 'kpi';
-    dataSource: string;
-    fields: string[];
-    filters: ReportFilter[];
-    grouping?: string[];
-    aggregations?: ReportAggregation[];
-    visualization?: VisualizationConfig;
-    scheduling?: ScheduleConfig;
-}
-export interface ReportFilter {
-    field: string;
-    operator: 'equals' | 'not_equals' | 'contains' | 'greater_than' | 'less_than';
-    value: string;
-}
-export interface ReportAggregation {
-    field: string;
-    function: 'count' | 'sum' | 'average' | 'min' | 'max';
-    alias?: string;
-}
-export interface VisualizationConfig {
-    chartType: 'bar' | 'line' | 'pie' | 'donut' | 'scatter' | 'gauge';
-    colors?: string[];
-    title: string;
-    xAxis?: string;
-    yAxis?: string;
-}
-export interface ScheduleConfig {
-    frequency: 'daily' | 'weekly' | 'monthly';
-    recipients: string[];
-    format: 'pdf' | 'excel' | 'csv';
-}
-export declare class ReportingSpecialistAgent extends BaseSnowAgent {
-    constructor();
-    execute(task: Task, input?: any): Promise<any>;
-    analyzeReportingRequirements(description: string, context?: any): Promise<ReportingRequirements>;
-    createReport(requirements: ReportingRequirements): Promise<any>;
-    createDashboard(config: any): Promise<any>;
-    setupKPI(metrics: any): Promise<any>;
-    private determineReportType;
-    private identifyDataSource;
-    private extractFields;
-    private extractFilters;
-    private extractGrouping;
-    private extractAggregations;
-    private configureVisualization;
-    private extractScheduling;
-}
-//# sourceMappingURL=reporting-specialist.agent.d.ts.map

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

@@ -1,193 +0,0 @@
-"use strict";
-/**
- * Reporting Specialist Agent - Handles reports, dashboards, and analytics
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReportingSpecialistAgent = void 0;
-const base_snow_agent_js_1 = require("../base/base-snow-agent.js");
-class ReportingSpecialistAgent extends base_snow_agent_js_1.BaseSnowAgent {
-    constructor() {
-        const capabilities = {
-            primarySkills: [
-                'report_creation',
-                'dashboard_design',
-                'data_visualization',
-                'analytics_setup',
-                'kpi_tracking'
-            ],
-            secondarySkills: [
-                'data_analysis',
-                'performance_metrics',
-                'automated_reporting',
-                'chart_configuration'
-            ],
-            complexity: 'medium',
-            autonomy: 'semi-autonomous'
-        };
-        super('reporting-specialist', 'ReportingSpecialist', capabilities);
-    }
-    async execute(task, input) {
-        await this.startTask(task);
-        try {
-            const taskType = task.metadata?.type || 'report_analysis';
-            let result;
-            switch (taskType) {
-                case 'report_creation':
-                    result = await this.createReport(input?.requirements || {});
-                    break;
-                case 'dashboard_creation':
-                    result = await this.createDashboard(input?.config || {});
-                    break;
-                case 'kpi_setup':
-                    result = await this.setupKPI(input?.metrics || {});
-                    break;
-                default:
-                    result = await this.analyzeReportingRequirements(task.description, input);
-            }
-            await this.completeTask(result);
-            return result;
-        }
-        catch (error) {
-            await this.handleError(error);
-            throw error;
-        }
-    }
-    async analyzeReportingRequirements(description, context) {
-        const normalizedDesc = description.toLowerCase();
-        return {
-            reportType: this.determineReportType(normalizedDesc),
-            dataSource: this.identifyDataSource(normalizedDesc),
-            fields: this.extractFields(normalizedDesc),
-            filters: this.extractFilters(normalizedDesc),
-            grouping: this.extractGrouping(normalizedDesc),
-            aggregations: this.extractAggregations(normalizedDesc),
-            visualization: this.configureVisualization(normalizedDesc),
-            scheduling: this.extractScheduling(normalizedDesc)
-        };
-    }
-    async createReport(requirements) {
-        return {
-            type: 'report',
-            name: `auto_report_${Date.now()}`,
-            table: requirements.dataSource,
-            fields: requirements.fields,
-            filters: requirements.filters,
-            groupBy: requirements.grouping,
-            orderBy: ['sys_created_on DESC'],
-            format: 'list',
-            sharing: 'public',
-            schedule: requirements.scheduling
-        };
-    }
-    async createDashboard(config) {
-        return {
-            type: 'dashboard',
-            name: config.name || `auto_dashboard_${Date.now()}`,
-            layout: 'grid',
-            widgets: [
-                {
-                    type: 'report_widget',
-                    title: 'Summary Statistics',
-                    report: config.primaryReport,
-                    size: 'medium'
-                },
-                {
-                    type: 'chart_widget',
-                    title: 'Trend Analysis',
-                    chartType: 'line',
-                    dataSource: config.dataSource,
-                    size: 'large'
-                }
-            ],
-            filters: config.globalFilters || [],
-            refreshInterval: config.refreshInterval || 300000 // 5 minutes
-        };
-    }
-    async setupKPI(metrics) {
-        return {
-            type: 'kpi',
-            name: metrics.name || `auto_kpi_${Date.now()}`,
-            metric: metrics.metric || 'count',
-            table: metrics.table || 'incident',
-            condition: metrics.condition || '',
-            target: metrics.target || 100,
-            thresholds: {
-                green: metrics.green || 90,
-                yellow: metrics.yellow || 70,
-                red: metrics.red || 50
-            },
-            updateFrequency: metrics.frequency || 'hourly'
-        };
-    }
-    determineReportType(description) {
-        if (description.includes('dashboard'))
-            return 'dashboard';
-        if (description.includes('chart') || description.includes('graph'))
-            return 'chart';
-        if (description.includes('kpi') || description.includes('metric'))
-            return 'kpi';
-        return 'list';
-    }
-    identifyDataSource(description) {
-        const tableMatches = description.match(/\b(incident|problem|change_request|task|sys_user)\b/);
-        return tableMatches ? tableMatches[0] : 'incident';
-    }
-    extractFields(description) {
-        const fields = ['number', 'short_description', 'state', 'priority', 'assigned_to'];
-        if (description.includes('date'))
-            fields.push('sys_created_on');
-        if (description.includes('category'))
-            fields.push('category');
-        return fields;
-    }
-    extractFilters(description) {
-        const filters = [];
-        if (description.includes('active')) {
-            filters.push({ field: 'active', operator: 'equals', value: 'true' });
-        }
-        if (description.includes('high priority')) {
-            filters.push({ field: 'priority', operator: 'equals', value: '1' });
-        }
-        return filters;
-    }
-    extractGrouping(description) {
-        if (description.includes('by state'))
-            return ['state'];
-        if (description.includes('by priority'))
-            return ['priority'];
-        if (description.includes('by category'))
-            return ['category'];
-        return undefined;
-    }
-    extractAggregations(description) {
-        const aggregations = [];
-        if (description.includes('count')) {
-            aggregations.push({ field: 'sys_id', function: 'count', alias: 'total_count' });
-        }
-        return aggregations.length > 0 ? aggregations : undefined;
-    }
-    configureVisualization(description) {
-        if (description.includes('chart') || description.includes('graph')) {
-            return {
-                chartType: description.includes('pie') ? 'pie' : 'bar',
-                title: 'Auto-generated Chart',
-                xAxis: 'state',
-                yAxis: 'count'
-            };
-        }
-        return undefined;
-    }
-    extractScheduling(description) {
-        if (description.includes('daily') || description.includes('weekly') || description.includes('monthly')) {
-            return {
-                frequency: description.includes('daily') ? 'daily' :
-                    description.includes('weekly') ? 'weekly' : 'monthly',
-                recipients: ['admin@company.com'],
-                format: 'pdf'
-            };
-        }
-        return undefined;
-    }
-}
-exports.ReportingSpecialistAgent = ReportingSpecialistAgent;
-//# sourceMappingURL=reporting-specialist.agent.js.map

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

@@ -1,85 +0,0 @@
-/**
- * Security Specialist Agent - Handles security, compliance, and access control
- */
-import { BaseSnowAgent } from '../base/base-snow-agent.js';
-import { Task } from '../../types/snow-flow.types.js';
-export interface SecurityRequirements {
-    accessControls: AccessControlRule[];
-    dataClassification: DataClassification;
-    complianceFrameworks: string[];
-    auditRequirements: AuditConfig;
-    encryptionNeeds: EncryptionConfig;
-    riskAssessment: RiskAssessment;
-}
-export interface AccessControlRule {
-    table: string;
-    operation: 'read' | 'write' | 'create' | 'delete';
-    roles: string[];
-    conditions?: string;
-    fieldLevel?: FieldAccessControl[];
-}
-export interface FieldAccessControl {
-    field: string;
-    access: 'read' | 'write' | 'none';
-    roles: string[];
-}
-export interface DataClassification {
-    level: 'public' | 'internal' | 'confidential' | 'restricted';
-    categories: string[];
-    retentionPeriod: number;
-    dataResidency?: string;
-}
-export interface AuditConfig {
-    enabled: boolean;
-    events: string[];
-    retention: number;
-    realTimeMonitoring: boolean;
-    alerting: AlertConfig[];
-}
-export interface AlertConfig {
-    event: string;
-    severity: 'low' | 'medium' | 'high' | 'critical';
-    recipients: string[];
-    channels: ('email' | 'sms' | 'slack')[];
-}
-export interface EncryptionConfig {
-    atRest: boolean;
-    inTransit: boolean;
-    keyManagement: 'internal' | 'external' | 'cloud';
-    algorithm?: string;
-}
-export interface RiskAssessment {
-    level: 'low' | 'medium' | 'high' | 'critical';
-    factors: RiskFactor[];
-    mitigations: Mitigation[];
-    residualRisk: 'low' | 'medium' | 'high';
-}
-export interface RiskFactor {
-    type: 'data_exposure' | 'unauthorized_access' | 'system_compromise' | 'compliance_violation';
-    likelihood: 'low' | 'medium' | 'high';
-    impact: 'low' | 'medium' | 'high';
-    description: string;
-}
-export interface Mitigation {
-    control: string;
-    effectiveness: 'low' | 'medium' | 'high';
-    implementation: 'immediate' | 'short_term' | 'long_term';
-    cost: 'low' | 'medium' | 'high';
-}
-export declare class SecuritySpecialistAgent extends BaseSnowAgent {
-    constructor();
-    execute(task: Task, input?: any): Promise<any>;
-    analyzeSecurityRequirements(description: string, context?: any): Promise<SecurityRequirements>;
-    setupAccessControls(requirements: SecurityRequirements): Promise<any>;
-    performComplianceCheck(framework: any): Promise<any>;
-    conductRiskAssessment(scope: any): Promise<RiskAssessment>;
-    setupAuditing(config: any): Promise<any>;
-    private defineAccessControls;
-    private classifyData;
-    private identifyComplianceFrameworks;
-    private defineAuditRequirements;
-    private assessEncryptionNeeds;
-    private assessRisk;
-    private createFieldLevelSecurity;
-}
-//# sourceMappingURL=security-specialist.agent.d.ts.map

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

@@ -1,309 +0,0 @@
-"use strict";
-/**
- * Security Specialist Agent - Handles security, compliance, and access control
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SecuritySpecialistAgent = void 0;
-const base_snow_agent_js_1 = require("../base/base-snow-agent.js");
-class SecuritySpecialistAgent extends base_snow_agent_js_1.BaseSnowAgent {
-    constructor() {
-        const capabilities = {
-            primarySkills: [
-                'access_control',
-                'security_policies',
-                'compliance_management',
-                'risk_assessment',
-                'audit_configuration',
-                'encryption_setup'
-            ],
-            secondarySkills: [
-                'security_monitoring',
-                'incident_response',
-                'vulnerability_assessment',
-                'data_protection'
-            ],
-            complexity: 'high',
-            autonomy: 'guided'
-        };
-        super('security-specialist', 'SecuritySpecialist', capabilities);
-    }
-    async execute(task, input) {
-        await this.startTask(task);
-        try {
-            const taskType = task.metadata?.type || 'security_analysis';
-            let result;
-            switch (taskType) {
-                case 'access_control_setup':
-                    result = await this.setupAccessControls(input?.requirements || {});
-                    break;
-                case 'compliance_check':
-                    result = await this.performComplianceCheck(input?.framework || {});
-                    break;
-                case 'risk_assessment':
-                    result = await this.conductRiskAssessment(input?.scope || {});
-                    break;
-                case 'audit_setup':
-                    result = await this.setupAuditing(input?.config || {});
-                    break;
-                default:
-                    result = await this.analyzeSecurityRequirements(task.description, input);
-            }
-            await this.completeTask(result);
-            return result;
-        }
-        catch (error) {
-            await this.handleError(error);
-            throw error;
-        }
-    }
-    async analyzeSecurityRequirements(description, context) {
-        const normalizedDesc = description.toLowerCase();
-        return {
-            accessControls: this.defineAccessControls(normalizedDesc),
-            dataClassification: this.classifyData(normalizedDesc),
-            complianceFrameworks: this.identifyComplianceFrameworks(normalizedDesc),
-            auditRequirements: this.defineAuditRequirements(normalizedDesc),
-            encryptionNeeds: this.assessEncryptionNeeds(normalizedDesc),
-            riskAssessment: this.assessRisk(normalizedDesc)
-        };
-    }
-    async setupAccessControls(requirements) {
-        return {
-            type: 'access_control_setup',
-            rules: requirements.accessControls.map(rule => ({
-                name: `acl_${rule.table}_${rule.operation}`,
-                table: rule.table,
-                operation: rule.operation,
-                roles: rule.roles,
-                condition: rule.conditions || '',
-                active: true,
-                order: 100
-            })),
-            fieldLevelSecurity: this.createFieldLevelSecurity(requirements.accessControls),
-            implementation: {
-                phases: ['development', 'testing', 'production'],
-                rollback: 'Disable rules and revert to previous state',
-                validation: 'User access testing required'
-            }
-        };
-    }
-    async performComplianceCheck(framework) {
-        const complianceResults = {
-            framework: framework.name || 'Generic',
-            overallStatus: 'compliant',
-            score: 85, // percentage
-            requirements: [
-                {
-                    id: 'access_control',
-                    name: 'Access Control Management',
-                    status: 'compliant',
-                    evidence: 'ACL rules configured',
-                    gaps: []
-                },
-                {
-                    id: 'data_protection',
-                    name: 'Data Protection',
-                    status: 'partial',
-                    evidence: 'Encryption enabled',
-                    gaps: ['Data masking not configured']
-                },
-                {
-                    id: 'audit_logging',
-                    name: 'Audit Logging',
-                    status: 'compliant',
-                    evidence: 'Audit rules active',
-                    gaps: []
-                }
-            ],
-            recommendations: [
-                'Implement data masking for sensitive fields',
-                'Enable real-time monitoring alerts',
-                'Schedule regular compliance reviews'
-            ],
-            nextReview: new Date(Date.now() + 90 * 24 * 60 * 60 * 1000) // 90 days
-        };
-        return complianceResults;
-    }
-    async conductRiskAssessment(scope) {
-        const riskFactors = [
-            {
-                type: 'data_exposure',
-                likelihood: 'medium',
-                impact: 'high',
-                description: 'Sensitive data accessible without proper controls'
-            },
-            {
-                type: 'unauthorized_access',
-                likelihood: 'low',
-                impact: 'medium',
-                description: 'Weak authentication mechanisms'
-            }
-        ];
-        const mitigations = [
-            {
-                control: 'Role-based access control implementation',
-                effectiveness: 'high',
-                implementation: 'immediate',
-                cost: 'medium'
-            },
-            {
-                control: 'Multi-factor authentication',
-                effectiveness: 'high',
-                implementation: 'short_term',
-                cost: 'low'
-            }
-        ];
-        return {
-            level: 'medium',
-            factors: riskFactors,
-            mitigations,
-            residualRisk: 'low'
-        };
-    }
-    async setupAuditing(config) {
-        return {
-            type: 'audit_configuration',
-            policies: [
-                {
-                    name: 'Data Access Audit',
-                    table: config.table || 'sys_user',
-                    events: ['read', 'write', 'delete'],
-                    retention: 2555, // 7 years
-                    realTime: true
-                },
-                {
-                    name: 'Security Configuration Audit',
-                    table: 'sys_security',
-                    events: ['create', 'update', 'delete'],
-                    retention: 2555,
-                    realTime: true
-                }
-            ],
-            monitoring: {
-                dashboards: ['security_overview', 'compliance_status'],
-                alerts: [
-                    {
-                        event: 'unauthorized_access_attempt',
-                        severity: 'high',
-                        recipients: ['security-team@company.com'],
-                        channels: ['email', 'slack']
-                    }
-                ]
-            }
-        };
-    }
-    defineAccessControls(description) {
-        const rules = [];
-        // Default security rules
-        rules.push({
-            table: '*',
-            operation: 'read',
-            roles: ['user'],
-            conditions: 'sys_domain=javascript:gs.getUser().getDomainID()'
-        });
-        if (description.includes('confidential') || description.includes('sensitive')) {
-            rules.push({
-                table: '*',
-                operation: 'write',
-                roles: ['admin', 'security_admin'],
-                conditions: 'u_data_classification=confidential'
-            });
-        }
-        return rules;
-    }
-    classifyData(description) {
-        let level = 'internal';
-        if (description.includes('public'))
-            level = 'public';
-        else if (description.includes('confidential') || description.includes('sensitive'))
-            level = 'confidential';
-        else if (description.includes('restricted') || description.includes('secret'))
-            level = 'restricted';
-        return {
-            level,
-            categories: ['business_data'],
-            retentionPeriod: level === 'restricted' ? 2555 : 1095, // 7 years or 3 years
-            dataResidency: 'local'
-        };
-    }
-    identifyComplianceFrameworks(description) {
-        const frameworks = [];
-        if (description.includes('gdpr'))
-            frameworks.push('GDPR');
-        if (description.includes('sox') || description.includes('sarbanes'))
-            frameworks.push('SOX');
-        if (description.includes('hipaa'))
-            frameworks.push('HIPAA');
-        if (description.includes('iso'))
-            frameworks.push('ISO 27001');
-        if (description.includes('pci'))
-            frameworks.push('PCI DSS');
-        // Default framework if none specified
-        if (frameworks.length === 0)
-            frameworks.push('Internal Security Policy');
-        return frameworks;
-    }
-    defineAuditRequirements(description) {
-        return {
-            enabled: true,
-            events: ['create', 'update', 'delete', 'read'],
-            retention: 2555, // 7 years
-            realTimeMonitoring: description.includes('real-time') || description.includes('immediate'),
-            alerting: [
-                {
-                    event: 'security_violation',
-                    severity: 'high',
-                    recipients: ['security-team@company.com'],
-                    channels: ['email']
-                }
-            ]
-        };
-    }
-    assessEncryptionNeeds(description) {
-        return {
-            atRest: description.includes('encrypt') || description.includes('confidential'),
-            inTransit: true, // Always encrypt in transit
-            keyManagement: 'internal',
-            algorithm: 'AES-256'
-        };
-    }
-    assessRisk(description) {
-        let level = 'medium';
-        if (description.includes('critical') || description.includes('high risk'))
-            level = 'high';
-        else if (description.includes('low risk') || description.includes('minimal'))
-            level = 'low';
-        return {
-            level,
-            factors: [
-                {
-                    type: 'data_exposure',
-                    likelihood: 'low',
-                    impact: 'medium',
-                    description: 'Standard business data exposure risk'
-                }
-            ],
-            mitigations: [
-                {
-                    control: 'Access controls and monitoring',
-                    effectiveness: 'high',
-                    implementation: 'immediate',
-                    cost: 'low'
-                }
-            ],
-            residualRisk: 'low'
-        };
-    }
-    createFieldLevelSecurity(accessControls) {
-        return accessControls
-            .filter(rule => rule.fieldLevel)
-            .flatMap(rule => rule.fieldLevel.map(field => ({
-            table: rule.table,
-            field: field.field,
-            access: field.access,
-            roles: field.roles
-        })));
-    }
-}
-exports.SecuritySpecialistAgent = SecuritySpecialistAgent;
-//# sourceMappingURL=security-specialist.agent.js.map