snow-flow 3.0.9 → 3.0.13

package/dist/specialists/base-specialist.d.ts

@@ -1,19 +0,0 @@
-export interface SpecialistOptions {
-    sharedMemory?: boolean;
-    context?: any;
-    outputFormat?: 'json' | 'markdown' | 'code';
-}
-export declare abstract class BaseSpecialist {
-    protected name: string;
-    protected role: string;
-    protected expertise: string[];
-    protected options: SpecialistOptions;
-    constructor(name: string, role: string, expertise: string[], options?: SpecialistOptions);
-    abstract execute(task: string, context?: any): Promise<any>;
-    protected logProgress(message: string): Promise<void>;
-    protected analyzeTask(task: string): Promise<any>;
-    protected assessComplexity(task: string): 'low' | 'medium' | 'high';
-    protected estimateTime(task: string): string;
-    protected identifyDependencies(task: string): string[];
-}
-//# sourceMappingURL=base-specialist.d.ts.map

package/dist/specialists/base-specialist.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseSpecialist = void 0;
-class BaseSpecialist {
-    constructor(name, role, expertise, options = {}) {
-        this.name = name;
-        this.role = role;
-        this.expertise = expertise;
-        this.options = options;
-    }
-    async logProgress(message) {
-        console.log(`${this.role} ${this.name}: ${message}`);
-    }
-    async analyzeTask(task) {
-        return {
-            task,
-            complexity: this.assessComplexity(task),
-            estimatedTime: this.estimateTime(task),
-            dependencies: this.identifyDependencies(task)
-        };
-    }
-    assessComplexity(task) {
-        if (task.length > 200 || task.includes('complex') || task.includes('advanced')) {
-            return 'high';
-        }
-        if (task.length > 100 || task.includes('integrate') || task.includes('optimize')) {
-            return 'medium';
-        }
-        return 'low';
-    }
-    estimateTime(task) {
-        const complexity = this.assessComplexity(task);
-        switch (complexity) {
-            case 'high': return '30-60 minutes';
-            case 'medium': return '15-30 minutes';
-            case 'low': return '5-15 minutes';
-        }
-    }
-    identifyDependencies(task) {
-        const dependencies = [];
-        if (task.includes('database') || task.includes('table')) {
-            dependencies.push('database_design');
-        }
-        if (task.includes('API') || task.includes('integration')) {
-            dependencies.push('api_specification');
-        }
-        if (task.includes('security') || task.includes('permission')) {
-            dependencies.push('security_requirements');
-        }
-        return dependencies;
-    }
-}
-exports.BaseSpecialist = BaseSpecialist;
-//# sourceMappingURL=base-specialist.js.map

package/dist/specialists/flow-specialists.d.ts

@@ -1,113 +0,0 @@
-import { BaseSpecialist, SpecialistOptions } from './base-specialist.js';
-export declare class ProcessSpecialist extends BaseSpecialist {
-    constructor(options?: SpecialistOptions);
-    execute(task: string, context?: any): Promise<any>;
-    private identifyFlowType;
-    private analyzeBusinessLogic;
-    private identifyProcessSteps;
-    private identifyDecisionPoints;
-    private analyzeApprovalRequirements;
-    private identifyApprovers;
-    private identifyApprovalCriteria;
-    private analyzeAutomationOpportunities;
-    private designFlowArchitecture;
-    private selectArchitecturePattern;
-    private identifyRequiredComponents;
-    private identifyIntegrationPoints;
-    private assessScalabilityNeeds;
-    private assessPerformanceRequirements;
-    private createFlowDefinition;
-    private generateFlowName;
-    private generateFlowDescription;
-    private createTriggerDefinition;
-    private createStepDefinitions;
-    private createStepProperties;
-    private createVariableDefinitions;
-}
-export declare class TriggerSpecialist extends BaseSpecialist {
-    constructor(options?: SpecialistOptions);
-    execute(task: string, context?: any): Promise<any>;
-    private identifyEventTypes;
-    private analyzeTriggerConditions;
-    private analyzeTriggerTiming;
-    private identifyTriggerFilters;
-    private analyzeTriggerPerformance;
-    private createTriggerDesign;
-    private selectTriggerPattern;
-    private identifyTriggerComponents;
-    private designErrorHandling;
-    private designScalability;
-    private designMonitoring;
-    private createTriggerConfiguration;
-    private generateTriggerName;
-    private generateTriggerDescription;
-}
-export declare class DataSpecialist extends BaseSpecialist {
-    constructor(options?: SpecialistOptions);
-    execute(task: string, context?: any): Promise<any>;
-    private analyzeDataModel;
-    private identifyRelationships;
-    private identifyVariables;
-    private identifyTransformations;
-    private analyzeValidationNeeds;
-    private analyzeStorageRequirements;
-    private determineRetentionPolicy;
-    private createDataArchitecture;
-    private designIndexingStrategy;
-    private designCachingStrategy;
-    private designOptimizationStrategy;
-    private createDataStrategy;
-}
-export declare class IntegrationSpecialist extends BaseSpecialist {
-    constructor(options?: SpecialistOptions);
-    execute(task: string, context?: any): Promise<any>;
-    private identifyExternalSystems;
-    private analyzeApiRequirements;
-    private determineAuthMethod;
-    private identifyProtocols;
-    private analyzeDataMapping;
-    private identifyDataTransformations;
-    private identifyMappingValidation;
-    private analyzeSecurityRequirements;
-    private identifyRequiredScopes;
-    private analyzeErrorHandling;
-    private createIntegrationArchitecture;
-    private selectIntegrationPattern;
-    private identifyArchitecturalComponents;
-    private designDataFlow;
-    private designSecurityArchitecture;
-    private designScalability;
-    private createImplementationPlan;
-    private createImplementationPhases;
-    private estimateTimeline;
-    private identifyRequiredResources;
-    private identifyImplementationRisks;
-    private createTestingStrategy;
-}
-export declare class SecuritySpecialist extends BaseSpecialist {
-    constructor(options?: SpecialistOptions);
-    execute(task: string, context?: any): Promise<any>;
-    private analyzeAuthenticationNeeds;
-    private identifyAuthMethods;
-    private createPasswordPolicy;
-    private analyzeAuthorizationNeeds;
-    private identifyRequiredRoles;
-    private identifyRequiredPermissions;
-    private analyzeDataProtectionNeeds;
-    private classifyDataSensitivity;
-    private defineRetentionPolicy;
-    private analyzeComplianceNeeds;
-    private defineAuditRequirements;
-    private defineReportingRequirements;
-    private defineComplianceControls;
-    private identifyVulnerabilities;
-    private analyzeMonitoringNeeds;
-    private createSecurityControls;
-    private createPreventiveControls;
-    private createDetectiveControls;
-    private createCorrectiveControls;
-    private createCompensatingControls;
-    private createSecurityPlan;
-    private createSecurityPhases;
-}
-//# sourceMappingURL=flow-specialists.d.ts.map