snow-flow 3.0.9 → 3.0.10

package/dist/agents/teams/base-team.js

@@ -1,253 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TeamFactory = exports.BaseTeam = exports.BaseSnowAgent = void 0;
-/**
- * Abstract base class for all specialized agents
- */
-class BaseSnowAgent {
-    constructor(id, name, role, capabilities, specialization, config) {
-        this.status = 'available';
-        this.id = id;
-        this.name = name;
-        this.role = role;
-        this.capabilities = capabilities;
-        this.specialization = specialization;
-        this.config = config;
-    }
-    // Common agent methods
-    getId() {
-        return this.id;
-    }
-    getName() {
-        return this.name;
-    }
-    getRole() {
-        return this.role;
-    }
-    getCapabilities() {
-        return this.capabilities;
-    }
-    getStatus() {
-        return this.status;
-    }
-    setStatus(status) {
-        this.status = status;
-    }
-    // Check if agent can handle a specific requirement
-    canHandle(requirement) {
-        return this.specialization.primary.includes(requirement) ||
-            this.specialization.secondary.includes(requirement);
-    }
-    // Get proficiency for a specific capability
-    getProficiency(capability) {
-        const cap = this.capabilities.find(c => c.name === capability);
-        return cap ? cap.proficiency : 0;
-    }
-    // Common error handling
-    handleError(error) {
-        console.error(`Agent ${this.name} encountered error:`, error);
-        return {
-            success: false,
-            error: error.message || 'Unknown error occurred',
-            metadata: {
-                duration: 0,
-                performance: null,
-                quality: null
-            }
-        };
-    }
-    // Common validation
-    validateRequirements(requirements) {
-        return requirements !== null && requirements !== undefined;
-    }
-}
-exports.BaseSnowAgent = BaseSnowAgent;
-/**
- * Abstract base class for specialized teams
- */
-class BaseTeam {
-    constructor(id, name, architect, specialists, coordinationStrategy, config) {
-        this.id = id;
-        this.name = name;
-        this.architect = architect;
-        this.specialists = specialists;
-        this.coordinationStrategy = coordinationStrategy;
-        this.config = config;
-    }
-    // Common team methods
-    getId() {
-        return this.id;
-    }
-    getName() {
-        return this.name;
-    }
-    getArchitect() {
-        return this.architect;
-    }
-    getSpecialists() {
-        return this.specialists;
-    }
-    getAllMembers() {
-        return [this.architect, ...this.specialists];
-    }
-    // Find best agent for a specific task
-    findBestAgent(requirement) {
-        const allAgents = this.getAllMembers();
-        // Sort by proficiency for the requirement
-        const sortedAgents = allAgents
-            .filter(agent => agent.canHandle(requirement))
-            .sort((a, b) => b.getProficiency(requirement) - a.getProficiency(requirement));
-        return sortedAgents[0] || this.architect;
-    }
-    // Execute task with coordination strategy
-    async coordinatedExecution(specification) {
-        try {
-            this.setAllAgentsStatus('busy');
-            const startTime = Date.now();
-            let result;
-            switch (this.coordinationStrategy.type) {
-                case 'sequential':
-                    result = await this.executeSequential(specification);
-                    break;
-                case 'parallel':
-                    result = await this.executeParallel(specification);
-                    break;
-                case 'hybrid':
-                    result = await this.executeHybrid(specification);
-                    break;
-                default:
-                    result = await this.executeSequential(specification);
-            }
-            const duration = Date.now() - startTime;
-            if (result.metadata) {
-                result.metadata.duration = duration;
-            }
-            this.setAllAgentsStatus('available');
-            return result;
-        }
-        catch (error) {
-            this.setAllAgentsStatus('available');
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error',
-                metadata: {
-                    duration: 0,
-                    performance: null,
-                    quality: null
-                }
-            };
-        }
-    }
-    // Sequential execution strategy
-    async executeSequential(specification) {
-        // First, architect analyzes and creates plan
-        const architectPlan = await this.architect.analyzeRequirements(specification.requirements);
-        // Then, execute specialists in order
-        let currentResult = architectPlan;
-        for (const specialist of this.specialists) {
-            currentResult = await specialist.execute(currentResult);
-            if (!currentResult.success) {
-                return currentResult;
-            }
-        }
-        return currentResult;
-    }
-    // Parallel execution strategy
-    async executeParallel(specification) {
-        // Architect creates plan
-        const architectPlan = await this.architect.analyzeRequirements(specification.requirements);
-        // Execute specialists in parallel
-        const specialistPromises = this.specialists.map(specialist => specialist.execute(architectPlan));
-        const results = await Promise.all(specialistPromises);
-        // Combine results
-        return this.combineResults(results);
-    }
-    // Hybrid execution strategy
-    async executeHybrid(specification) {
-        // Implement based on dependencies
-        const architectPlan = await this.architect.analyzeRequirements(specification.requirements);
-        // Execute based on dependency graph
-        return await this.executeDependencyGraph(architectPlan);
-    }
-    // Combine multiple specialist results
-    combineResults(results) {
-        const failed = results.find(r => !r.success);
-        if (failed) {
-            return failed;
-        }
-        return {
-            success: true,
-            artifact: results.map(r => r.artifact),
-            metadata: {
-                duration: Math.max(...results.map(r => r.metadata?.duration || 0)),
-                performance: results.map(r => r.metadata?.performance),
-                quality: results.map(r => r.metadata?.quality)
-            }
-        };
-    }
-    // Execute based on dependency graph
-    async executeDependencyGraph(plan) {
-        // Simplified implementation - can be enhanced with proper dependency resolution
-        const dependencies = this.coordinationStrategy.dependencies;
-        const executed = new Set();
-        const results = [];
-        // Execute agents in dependency order
-        for (const specialist of this.specialists) {
-            const agentId = specialist.getId();
-            const deps = dependencies.filter(d => d.to === agentId);
-            // Wait for dependencies
-            const depsSatisfied = deps.every(d => executed.has(d.from));
-            if (depsSatisfied) {
-                const result = await specialist.execute(plan);
-                results.push(result);
-                executed.add(agentId);
-                if (!result.success) {
-                    return result;
-                }
-            }
-        }
-        return this.combineResults(results);
-    }
-    // Utility methods
-    setAllAgentsStatus(status) {
-        this.architect.setStatus(status);
-        this.specialists.forEach(agent => agent.setStatus(status));
-    }
-    // Get team status
-    getTeamStatus() {
-        return {
-            architect: this.architect.getStatus(),
-            specialists: this.specialists.map(s => ({
-                name: s.getName(),
-                status: s.getStatus()
-            }))
-        };
-    }
-    // Validate team readiness
-    isTeamReady() {
-        return this.getAllMembers().every(agent => agent.getStatus() === 'available');
-    }
-}
-exports.BaseTeam = BaseTeam;
-/**
- * Team factory for creating specialized teams
- */
-class TeamFactory {
-    static createTeam(type, config) {
-        switch (type) {
-            case 'widget':
-                // Will be implemented in widget team files
-                throw new Error('Widget team factory not implemented yet');
-            case 'flow':
-                // Will be implemented in flow team files
-                throw new Error('Flow team factory not implemented yet');
-            case 'application':
-                // Will be implemented in application team files
-                throw new Error('Application team factory not implemented yet');
-            default:
-                throw new Error(`Unknown team type: ${type}`);
-        }
-    }
-}
-exports.TeamFactory = TeamFactory;
-//# sourceMappingURL=base-team.js.map

package/dist/agents/teams/team-types.d.ts

@@ -1,265 +0,0 @@
-export interface TeamSpecification {
-    id: string;
-    requirements: any;
-    complexity: 'simple' | 'medium' | 'complex';
-    estimatedTime: number;
-    dependencies: string[];
-    assignedTo?: string;
-}
-export interface TeamMember {
-    id: string;
-    name: string;
-    role: string;
-    specialization: string[];
-    capabilities: string[];
-    status: 'available' | 'busy' | 'offline';
-}
-export interface TeamResult {
-    success: boolean;
-    artifact?: any;
-    error?: string;
-    metadata?: {
-        duration: number;
-        performance: any;
-        quality: any;
-    };
-}
-export interface WidgetSpecification extends TeamSpecification {
-    requirements: WidgetRequirements;
-}
-export interface WidgetRequirements {
-    type: 'dashboard' | 'form' | 'list' | 'chart' | 'custom';
-    data: {
-        source: string;
-        fields: string[];
-        filters?: any;
-    };
-    ui: {
-        responsive: boolean;
-        theme: string;
-        accessibility: boolean;
-    };
-    functionality: {
-        interactive: boolean;
-        realtime: boolean;
-        export?: boolean;
-    };
-    integrations?: string[];
-}
-export interface FrontendRequirements {
-    template: {
-        layout: string;
-        components: string[];
-        responsive: boolean;
-    };
-    styling: {
-        theme: string;
-        customCSS?: string;
-        accessibility: boolean;
-    };
-    clientScript: {
-        framework: 'angular' | 'vanilla' | 'react';
-        events: string[];
-        apiCalls: string[];
-    };
-}
-export interface BackendRequirements {
-    serverScript: {
-        dataProcessing: string[];
-        apiIntegrations: string[];
-        businessLogic: string[];
-    };
-    performance: {
-        caching: boolean;
-        optimization: string[];
-    };
-    security: {
-        validation: string[];
-        authorization: string[];
-    };
-}
-export interface DesignRequirements {
-    uiPattern: string;
-    accessibility: {
-        wcag: string;
-        screenReader: boolean;
-        keyboard: boolean;
-    };
-    userExperience: {
-        workflow: string[];
-        feedback: string[];
-    };
-}
-export interface DesignSpec {
-    colorScheme: string;
-    typography: any;
-    layout: any;
-    interactions: any;
-    accessibility: any;
-}
-export interface UsabilityReport {
-    score: number;
-    issues: any[];
-    recommendations: string[];
-}
-export interface FlowSpecification extends TeamSpecification {
-    requirements: FlowRequirements;
-}
-export interface FlowRequirements {
-    type: 'approval' | 'automation' | 'integration' | 'notification' | 'custom';
-    trigger: {
-        type: string;
-        condition: string;
-        table?: string;
-    };
-    process: {
-        steps: FlowStep[];
-        branches: FlowBranch[];
-        decisions: FlowDecision[];
-    };
-    data: {
-        inputs: any[];
-        outputs: any[];
-        transformations: any[];
-    };
-    security: {
-        permissions: string[];
-        compliance: string[];
-    };
-}
-export interface FlowStep {
-    id: string;
-    name: string;
-    type: string;
-    configuration: any;
-    order: number;
-}
-export interface FlowBranch {
-    condition: string;
-    steps: FlowStep[];
-}
-export interface FlowDecision {
-    condition: string;
-    truePath: string;
-    falsePath: string;
-}
-export interface ProcessRequirements {
-    logic: string[];
-    steps: FlowStep[];
-    errorHandling: string[];
-}
-export interface TriggerRequirements {
-    events: string[];
-    conditions: string[];
-    schedules?: string[];
-}
-export interface DataRequirements {
-    sources: string[];
-    transformations: string[];
-    destinations: string[];
-}
-export interface SecurityRequirements {
-    authentication: string[];
-    authorization: string[];
-    compliance: string[];
-}
-export interface ApplicationSpecification extends TeamSpecification {
-    requirements: ApplicationRequirements;
-}
-export interface ApplicationRequirements {
-    scope: 'global' | 'scoped';
-    database: {
-        tables: TableDefinition[];
-        relationships: any[];
-    };
-    businessLogic: {
-        rules: BusinessRuleDefinition[];
-        scripts: ScriptDefinition[];
-    };
-    interface: {
-        forms: FormDefinition[];
-        lists: ListDefinition[];
-        modules: ModuleDefinition[];
-    };
-    security: {
-        roles: RoleDefinition[];
-        acls: ACLDefinition[];
-    };
-}
-export interface TableDefinition {
-    name: string;
-    label: string;
-    fields: FieldDefinition[];
-    extends?: string;
-}
-export interface FieldDefinition {
-    name: string;
-    label: string;
-    type: string;
-    required: boolean;
-    reference?: string;
-}
-export interface BusinessRuleDefinition {
-    name: string;
-    table: string;
-    when: string;
-    script: string;
-}
-export interface ScriptDefinition {
-    name: string;
-    type: 'script_include' | 'client_script' | 'ui_script';
-    script: string;
-}
-export interface FormDefinition {
-    name: string;
-    table: string;
-    sections: any[];
-}
-export interface ListDefinition {
-    name: string;
-    table: string;
-    fields: string[];
-}
-export interface ModuleDefinition {
-    name: string;
-    table: string;
-    role?: string;
-}
-export interface RoleDefinition {
-    name: string;
-    description: string;
-    contains?: string[];
-}
-export interface ACLDefinition {
-    table: string;
-    operation: string;
-    roles: string[];
-}
-export interface TeamCoordinationStrategy {
-    type: 'sequential' | 'parallel' | 'hybrid';
-    dependencies: TeamDependency[];
-    communication: CommunicationProtocol;
-}
-export interface TeamDependency {
-    from: string;
-    to: string;
-    type: 'blocking' | 'data' | 'approval';
-}
-export interface CommunicationProtocol {
-    channels: string[];
-    updates: 'realtime' | 'periodic';
-    notifications: boolean;
-}
-export interface AgentCapability {
-    name: string;
-    description: string;
-    proficiency: number;
-    tools: string[];
-}
-export interface SpecializationProfile {
-    primary: string[];
-    secondary: string[];
-    tools: string[];
-    experience: number;
-}
-//# sourceMappingURL=team-types.d.ts.map

package/dist/agents/teams/team-types.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=team-types.js.map

package/dist/agents/teams/widget/widget-architect.agent.d.ts

@@ -1,61 +0,0 @@
-/**
- * Widget Architect Agent - Coordinates widget development team
- * Analyzes requirements and orchestrates specialized team members
- */
-import { BaseSnowAgent } from '../base-team';
-import { WidgetSpecification, WidgetRequirements, TeamResult } from '../team-types';
-import { ServiceNowAgentConfig } from '../../../types/servicenow.types';
-export declare class WidgetArchitectAgent extends BaseSnowAgent {
-    private frontendAgent?;
-    private backendAgent?;
-    private uiuxAgent?;
-    private platformAgent?;
-    constructor(config: ServiceNowAgentConfig);
-    /**
-     * Set team members that this architect will coordinate
-     */
-    setTeamMembers(frontendAgent: BaseSnowAgent, backendAgent: BaseSnowAgent, uiuxAgent: BaseSnowAgent, platformAgent: BaseSnowAgent): void;
-    /**
-     * Analyze widget requirements and create technical specification
-     */
-    analyzeRequirements(requirements: WidgetRequirements): Promise<WidgetSpecification>;
-    /**
-     * Coordinate the entire widget development team
-     */
-    execute(specification: WidgetSpecification): Promise<TeamResult>;
-    /**
-     * Break down widget specification into specialized tasks
-     */
-    private createTaskBreakdown;
-    /**
-     * Coordinate team execution with proper dependency management
-     */
-    private coordinateTeam;
-    /**
-     * Integrate all components into final widget
-     */
-    private integrateComponents;
-    /**
-     * Deploy the integrated widget
-     */
-    private deployWidget;
-    private assessComplexity;
-    private estimateTime;
-    private identifyDependencies;
-    private determineLayout;
-    private identifyComponents;
-    private identifyClientEvents;
-    private identifyApiCalls;
-    private identifyDataProcessing;
-    private identifyBusinessLogic;
-    private requiresCaching;
-    private identifyOptimizations;
-    private identifyValidations;
-    private identifyAuthorization;
-    private determineUIPattern;
-    private identifyWorkflows;
-    private identifyFeedbackNeeds;
-    private identifyPlatformDependencies;
-    private identifyPermissions;
-}
-//# sourceMappingURL=widget-architect.agent.d.ts.map