claude-flow-novice 2.0.4 → 2.0.5

package/dist/src/web/messaging/human-intervention-system.js

@@ -0,0 +1,305 @@
+/**
+ * Human Intervention System - Allows humans to redirect agents without stopping them
+ * Supports swarm relaunching up to 10 times for iterative improvement
+ */ function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+import { EventEmitter } from "events";
+export class HumanInterventionSystem extends EventEmitter {
+    /**
+   * Send human intervention to agents with swarm relaunch capability
+   */ async sendIntervention(intervention) {
+        const interventionId = this.generateInterventionId();
+        const fullIntervention = {
+            ...intervention,
+            id: interventionId,
+            status: 'pending'
+        };
+        // Handle special case: swarm relaunch
+        if (intervention.action === 'relaunch-swarm') {
+            return await this.handleSwarmRelaunch(fullIntervention);
+        }
+        this.interventions.set(interventionId, fullIntervention);
+        // Add to swarm queue
+        if (!this.interventionQueue.has(intervention.swarmId)) {
+            this.interventionQueue.set(intervention.swarmId, []);
+        }
+        this.interventionQueue.get(intervention.swarmId).push(fullIntervention);
+        // Emit intervention event
+        this.emit('intervention', fullIntervention);
+        this.logger.info('Human intervention sent', {
+            interventionId,
+            swarmId: intervention.swarmId,
+            agentId: intervention.agentId,
+            action: intervention.action
+        });
+        return interventionId;
+    }
+    /**
+   * Handle swarm relaunch with learning from previous attempts
+   */ async handleSwarmRelaunch(intervention) {
+        const currentRelaunch = this.swarmRelaunches.get(intervention.swarmId);
+        const relaunchCount = currentRelaunch ? currentRelaunch.relaunchCount + 1 : 1;
+        if (relaunchCount > this.MAX_RELAUNCHES) {
+            this.logger.warn('Maximum relaunch attempts reached', {
+                swarmId: intervention.swarmId,
+                relaunchCount
+            });
+            intervention.status = 'rejected';
+            intervention.response = {
+                agentId: 'system',
+                message: `Cannot relaunch swarm: maximum ${this.MAX_RELAUNCHES} attempts reached`,
+                timestamp: new Date().toISOString(),
+                actionTaken: 'rejected'
+            };
+            this.interventions.set(intervention.id, intervention);
+            return intervention.id;
+        }
+        // Create relaunch configuration
+        const relaunchConfig = {
+            swarmId: intervention.swarmId,
+            reason: intervention.message,
+            modifications: {
+                agentTypes: this.determineOptimalAgentTypes(intervention),
+                objective: intervention.metadata?.newGoal,
+                constraints: intervention.metadata?.constraints,
+                priority: intervention.metadata?.newPriority
+            },
+            relaunchCount,
+            maxRelaunches: this.MAX_RELAUNCHES,
+            preserveContext: true,
+            learningsFromPrevious: this.extractLearningsFromPreviousAttempts(intervention.swarmId)
+        };
+        this.swarmRelaunches.set(intervention.swarmId, relaunchConfig);
+        intervention.metadata = {
+            ...intervention.metadata,
+            relaunchCount
+        };
+        this.interventions.set(intervention.id, intervention);
+        // Emit relaunch event
+        this.emit('swarm-relaunch-requested', {
+            intervention,
+            relaunchConfig
+        });
+        this.logger.info('Swarm relaunch initiated', {
+            swarmId: intervention.swarmId,
+            relaunchCount,
+            reason: intervention.message
+        });
+        return intervention.id;
+    }
+    /**
+   * Determine optimal agent composition based on previous attempts
+   */ determineOptimalAgentTypes(intervention) {
+        const relaunchHistory = this.swarmRelaunches.get(intervention.swarmId);
+        if (!relaunchHistory) {
+            // First attempt - balanced approach
+            return [
+                'researcher',
+                'coder',
+                'reviewer'
+            ];
+        }
+        // Adjust based on what worked/didn't work
+        const objective = intervention.metadata?.newGoal || 'general';
+        if (objective.toLowerCase().includes('research') || objective.toLowerCase().includes('analyze')) {
+            return [
+                'researcher',
+                'researcher',
+                'reviewer'
+            ]; // Research-heavy
+        }
+        if (objective.toLowerCase().includes('build') || objective.toLowerCase().includes('implement')) {
+            return [
+                'researcher',
+                'coder',
+                'coder'
+            ]; // Implementation-heavy
+        }
+        if (objective.toLowerCase().includes('review') || objective.toLowerCase().includes('quality')) {
+            return [
+                'researcher',
+                'reviewer',
+                'reviewer'
+            ]; // Quality-focused
+        }
+        // Default balanced approach
+        return [
+            'researcher',
+            'coder',
+            'reviewer'
+        ];
+    }
+    /**
+   * Extract learnings from previous swarm attempts
+   */ extractLearningsFromPreviousAttempts(swarmId) {
+        const learnings = [];
+        const interventions = Array.from(this.interventions.values()).filter((i)=>i.swarmId === swarmId).sort((a, b)=>new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+        for (const intervention of interventions){
+            if (intervention.status === 'applied' && intervention.response) {
+                learnings.push(`${intervention.action}: ${intervention.response.actionTaken}`);
+            }
+            if (intervention.metadata?.reasoning) {
+                learnings.push(`Human insight: ${intervention.metadata.reasoning}`);
+            }
+        }
+        // Add default learnings for common patterns
+        const relaunchCount = this.swarmRelaunches.get(swarmId)?.relaunchCount || 0;
+        if (relaunchCount > 0) {
+            learnings.push(`This is attempt #${relaunchCount + 1} - apply lessons from previous attempts`);
+        }
+        if (relaunchCount > 2) {
+            learnings.push('Multiple attempts suggest complexity - break down into smaller tasks');
+        }
+        if (relaunchCount > 5) {
+            learnings.push('High relaunch count - consider fundamental approach change');
+        }
+        return learnings;
+    }
+    /**
+   * Agent acknowledges intervention
+   */ async acknowledgeIntervention(interventionId, agentId) {
+        const intervention = this.interventions.get(interventionId);
+        if (!intervention) {
+            throw new Error(`Intervention ${interventionId} not found`);
+        }
+        intervention.status = 'acknowledged';
+        intervention.response = {
+            agentId,
+            message: `Intervention acknowledged by agent ${agentId}`,
+            timestamp: new Date().toISOString(),
+            actionTaken: 'acknowledged'
+        };
+        this.emit('intervention-acknowledged', intervention);
+        this.logger.debug('Intervention acknowledged', {
+            interventionId,
+            agentId,
+            swarmId: intervention.swarmId
+        });
+    }
+    /**
+   * Agent applies intervention
+   */ async applyIntervention(interventionId, agentId, actionDetails) {
+        const intervention = this.interventions.get(interventionId);
+        if (!intervention) {
+            throw new Error(`Intervention ${interventionId} not found`);
+        }
+        intervention.status = 'applied';
+        intervention.response = {
+            agentId,
+            message: `Intervention applied: ${actionDetails}`,
+            timestamp: new Date().toISOString(),
+            actionTaken: actionDetails
+        };
+        this.emit('intervention-applied', intervention);
+        this.logger.info('Intervention applied', {
+            interventionId,
+            agentId,
+            swarmId: intervention.swarmId,
+            actionTaken: actionDetails
+        });
+    }
+    /**
+   * Get pending interventions for a swarm
+   */ getPendingInterventions(swarmId) {
+        const swarmQueue = this.interventionQueue.get(swarmId) || [];
+        return swarmQueue.filter((i)=>i.status === 'pending');
+    }
+    /**
+   * Get intervention history for a swarm
+   */ getInterventionHistory(swarmId) {
+        return Array.from(this.interventions.values()).filter((i)=>i.swarmId === swarmId).sort((a, b)=>new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+    }
+    /**
+   * Get swarm relaunch information
+   */ getSwarmRelaunchInfo(swarmId) {
+        return this.swarmRelaunches.get(swarmId) || null;
+    }
+    /**
+   * Check if swarm can be relaunched
+   */ canRelaunchSwarm(swarmId) {
+        const relaunchConfig = this.swarmRelaunches.get(swarmId);
+        const currentCount = relaunchConfig?.relaunchCount || 0;
+        const remaining = this.MAX_RELAUNCHES - currentCount;
+        if (remaining <= 0) {
+            return {
+                canRelaunch: false,
+                remainingAttempts: 0,
+                reason: `Maximum ${this.MAX_RELAUNCHES} relaunches reached`
+            };
+        }
+        return {
+            canRelaunch: true,
+            remainingAttempts: remaining
+        };
+    }
+    /**
+   * Get intervention statistics
+   */ getInterventionStats(swarmId) {
+        let targetInterventions = Array.from(this.interventions.values());
+        if (swarmId) {
+            targetInterventions = targetInterventions.filter((i)=>i.swarmId === swarmId);
+        }
+        const stats = {
+            total: targetInterventions.length,
+            byStatus: {
+                pending: targetInterventions.filter((i)=>i.status === 'pending').length,
+                acknowledged: targetInterventions.filter((i)=>i.status === 'acknowledged').length,
+                applied: targetInterventions.filter((i)=>i.status === 'applied').length,
+                rejected: targetInterventions.filter((i)=>i.status === 'rejected').length
+            },
+            byAction: {},
+            swarmRelaunches: this.swarmRelaunches.size,
+            averageRelaunchCount: 0
+        };
+        // Count by action type
+        for (const intervention of targetInterventions){
+            stats.byAction[intervention.action] = (stats.byAction[intervention.action] || 0) + 1;
+        }
+        // Calculate average relaunch count
+        if (this.swarmRelaunches.size > 0) {
+            const totalRelaunches = Array.from(this.swarmRelaunches.values()).reduce((sum, config)=>sum + config.relaunchCount, 0);
+            stats.averageRelaunchCount = totalRelaunches / this.swarmRelaunches.size;
+        }
+        return stats;
+    }
+    generateInterventionId() {
+        return `intervention_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    getInterventionCount() {
+        return this.interventions.size;
+    }
+    /**
+   * Clean up old interventions
+   */ cleanupOldInterventions(maxAge = 7 * 24 * 60 * 60 * 1000) {
+        const cutoff = new Date(Date.now() - maxAge);
+        for (const [id, intervention] of this.interventions.entries()){
+            if (new Date(intervention.timestamp) < cutoff) {
+                this.interventions.delete(id);
+                // Clean up from queue
+                const swarmQueue = this.interventionQueue.get(intervention.swarmId);
+                if (swarmQueue) {
+                    const index = swarmQueue.findIndex((i)=>i.id === id);
+                    if (index > -1) {
+                        swarmQueue.splice(index, 1);
+                    }
+                }
+            }
+        }
+    }
+    constructor(logger){
+        super(), _define_property(this, "logger", void 0), _define_property(this, "interventions", void 0), _define_property(this, "swarmRelaunches", void 0), _define_property(this, "MAX_RELAUNCHES", void 0), _define_property(this, "interventionQueue", void 0 // swarmId -> interventions
+        ), this.logger = logger, this.interventions = new Map(), this.swarmRelaunches = new Map(), this.MAX_RELAUNCHES = 10, this.interventionQueue = new Map();
+        this.setMaxListeners(100);
+    }
+}

package/dist/src/web/messaging/message-filter.js

@@ -0,0 +1,302 @@
+/**
+ * Message Filter - Advanced filtering and search for agent messages
+ */ function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+export class MessageFilter {
+    /**
+   * Set filter configuration for a specific user/client
+   */ setUserFilter(userId, config) {
+        this.userFilters.set(userId, config);
+    }
+    /**
+   * Remove filter for a user/client
+   */ removeUserFilter(userId) {
+        this.userFilters.delete(userId);
+    }
+    /**
+   * Filter a message based on user preferences
+   */ filterMessage(message, userId) {
+        if (!userId) return message;
+        const filter = this.userFilters.get(userId);
+        if (!filter) return message;
+        if (!this.messagePassesFilter(message, filter)) {
+            return null; // Message filtered out
+        }
+        return message;
+    }
+    /**
+   * Filter an array of messages
+   */ filterMessages(messages, filter) {
+        return messages.filter((message)=>this.messagePassesFilter(message, filter));
+    }
+    /**
+   * Search messages with advanced criteria
+   */ searchMessages(messages, searchConfig) {
+        let results = [
+            ...messages
+        ];
+        // Apply text search
+        if (searchConfig.query) {
+            results = this.performTextSearch(results, searchConfig.query, searchConfig);
+        }
+        // Sort results
+        if (searchConfig.sortBy) {
+            results = this.sortMessages(results, searchConfig.sortBy, searchConfig.sortOrder || 'desc');
+        }
+        return results;
+    }
+    /**
+   * Get filter suggestions based on available data
+   */ getFilterSuggestions(messages) {
+        const messageTypes = [
+            ...new Set(messages.map((m)=>m.messageType))
+        ];
+        const agentTypes = [
+            ...new Set(messages.map((m)=>m.agentType))
+        ];
+        const agentIds = [
+            ...new Set(messages.map((m)=>m.agentId))
+        ];
+        const priorities = [
+            ...new Set(messages.map((m)=>m.priority))
+        ];
+        // Extract tags from metadata
+        const tags = [
+            ...new Set(messages.flatMap((m)=>m.metadata?.tags || []).filter(Boolean))
+        ];
+        // Get date range
+        const timestamps = messages.map((m)=>new Date(m.timestamp).getTime());
+        const dateRange = {
+            start: new Date(Math.min(...timestamps)).toISOString(),
+            end: new Date(Math.max(...timestamps)).toISOString()
+        };
+        return {
+            messageTypes,
+            agentTypes,
+            agentIds,
+            priorities,
+            tags,
+            dateRange
+        };
+    }
+    /**
+   * Create smart filters based on user behavior
+   */ createSmartFilter(userId, interactionHistory) {
+        const smartFilter = {};
+        // Analyze user's viewing patterns
+        const viewedMessageTypes = interactionHistory.filter((h)=>h.action === 'view').map((h)=>h.messageType);
+        if (viewedMessageTypes.length > 0) {
+            const mostViewedTypes = this.getMostFrequent(viewedMessageTypes, 3);
+            smartFilter.messageTypes = mostViewedTypes;
+        }
+        // Analyze searched keywords
+        const searchQueries = interactionHistory.filter((h)=>h.action === 'search').map((h)=>h.query);
+        if (searchQueries.length > 0) {
+            smartFilter.contentKeywords = this.extractKeywords(searchQueries);
+        }
+        // Analyze time preferences
+        const viewTimes = interactionHistory.filter((h)=>h.action === 'view').map((h)=>new Date(h.timestamp).getHours());
+        // If user typically views recent messages, prefer recent timeRange
+        const averageHour = viewTimes.reduce((sum, hour)=>sum + hour, 0) / viewTimes.length;
+        if (averageHour > 0) {
+            smartFilter.timeRange = {
+                start: new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString(),
+                end: new Date().toISOString()
+            };
+        }
+        return smartFilter;
+    }
+    messagePassesFilter(message, filter) {
+        // Message type filter
+        if (filter.messageTypes && !filter.messageTypes.includes(message.messageType)) {
+            return false;
+        }
+        // Agent type filter
+        if (filter.agentTypes && !filter.agentTypes.includes(message.agentType)) {
+            return false;
+        }
+        // Agent ID filter
+        if (filter.agentIds && !filter.agentIds.includes(message.agentId)) {
+            return false;
+        }
+        // Priority filter
+        if (filter.priorities && !filter.priorities.includes(message.priority)) {
+            return false;
+        }
+        // Time range filter
+        if (filter.timeRange) {
+            const messageTime = new Date(message.timestamp);
+            const start = new Date(filter.timeRange.start);
+            const end = new Date(filter.timeRange.end);
+            if (messageTime < start || messageTime > end) {
+                return false;
+            }
+        }
+        // Content keywords filter
+        if (filter.contentKeywords && filter.contentKeywords.length > 0) {
+            const content = message.content.toLowerCase();
+            const hasKeyword = filter.contentKeywords.some((keyword)=>content.includes(keyword.toLowerCase()));
+            if (!hasKeyword) return false;
+        }
+        // Reasoning filter
+        if (filter.hasReasoning !== undefined) {
+            const hasReasoning = !!message.metadata?.reasoning;
+            if (filter.hasReasoning !== hasReasoning) return false;
+        }
+        // Alternatives filter
+        if (filter.hasAlternatives !== undefined) {
+            const hasAlternatives = !!(message.metadata?.alternatives && message.metadata.alternatives.length > 0);
+            if (filter.hasAlternatives !== hasAlternatives) return false;
+        }
+        // Confidence range filter
+        if (filter.confidenceRange && message.metadata?.confidence !== undefined) {
+            const confidence = message.metadata.confidence;
+            if (confidence < filter.confidenceRange.min || confidence > filter.confidenceRange.max) {
+                return false;
+            }
+        }
+        // Thread ID filter
+        if (filter.threadIds && (!message.threadId || !filter.threadIds.includes(message.threadId))) {
+            return false;
+        }
+        // Tags filter
+        if (filter.tags && filter.tags.length > 0) {
+            const messageTags = message.metadata?.tags || [];
+            const hasTag = filter.tags.some((tag)=>messageTags.includes(tag));
+            if (!hasTag) return false;
+        }
+        return true;
+    }
+    performTextSearch(messages, query, config) {
+        const searchFields = config.fields || [
+            'content',
+            'metadata.reasoning'
+        ];
+        const fuzzy = config.fuzzy || false;
+        return messages.filter((message)=>{
+            for (const field of searchFields){
+                const value = this.getNestedProperty(message, field);
+                if (value && this.matchesQuery(value, query, fuzzy)) {
+                    return true;
+                }
+            }
+            return false;
+        });
+    }
+    matchesQuery(text, query, fuzzy) {
+        const normalizedText = text.toLowerCase();
+        const normalizedQuery = query.toLowerCase();
+        if (!fuzzy) {
+            return normalizedText.includes(normalizedQuery);
+        }
+        // Simple fuzzy matching - check if most query words are present
+        const queryWords = normalizedQuery.split(' ');
+        const matchedWords = queryWords.filter((word)=>normalizedText.includes(word));
+        return matchedWords.length / queryWords.length >= 0.6; // 60% word match threshold
+    }
+    sortMessages(messages, sortBy, order) {
+        return messages.sort((a, b)=>{
+            let compareValue = 0;
+            switch(sortBy){
+                case 'timestamp':
+                    compareValue = new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime();
+                    break;
+                case 'priority':
+                    const priorityOrder = {
+                        low: 1,
+                        medium: 2,
+                        high: 3,
+                        urgent: 4
+                    };
+                    compareValue = priorityOrder[a.priority] - priorityOrder[b.priority];
+                    break;
+                case 'relevance':
+                    // Simple relevance based on message metadata richness
+                    const aScore = this.calculateRelevanceScore(a);
+                    const bScore = this.calculateRelevanceScore(b);
+                    compareValue = aScore - bScore;
+                    break;
+            }
+            return order === 'asc' ? compareValue : -compareValue;
+        });
+    }
+    calculateRelevanceScore(message) {
+        let score = 0;
+        // Score based on metadata richness
+        if (message.metadata?.reasoning) score += 3;
+        if (message.metadata?.alternatives) score += 2;
+        if (message.metadata?.confidence) score += 1;
+        if (message.metadata?.dependencies) score += 1;
+        if (message.metadata?.tags) score += message.metadata.tags.length * 0.5;
+        // Score based on message type importance
+        const typeScores = {
+            decision: 5,
+            coordination: 4,
+            reasoning: 3,
+            'progress-update': 2,
+            'task-start': 2,
+            completion: 1,
+            error: 4
+        };
+        score += typeScores[message.messageType] || 1;
+        return score;
+    }
+    getNestedProperty(obj, path) {
+        return path.split('.').reduce((current, key)=>current && current[key], obj);
+    }
+    getMostFrequent(array, count) {
+        const frequency = new Map();
+        for (const item of array){
+            frequency.set(item, (frequency.get(item) || 0) + 1);
+        }
+        return Array.from(frequency.entries()).sort((a, b)=>b[1] - a[1]).slice(0, count).map((entry)=>entry[0]);
+    }
+    extractKeywords(queries) {
+        // Simple keyword extraction - split queries and find common terms
+        const words = queries.flatMap((query)=>query.toLowerCase().split(' ')).filter((word)=>word.length > 3); // Filter out short words
+        return this.getMostFrequent(words, 5);
+    }
+    /**
+   * Export filter configuration
+   */ exportFilter(userId) {
+        return this.userFilters.get(userId) || null;
+    }
+    /**
+   * Import filter configuration
+   */ importFilter(userId, config) {
+        this.userFilters.set(userId, config);
+    }
+    /**
+   * Get filter statistics
+   */ getFilterStats() {
+        const allFilters = Array.from(this.userFilters.values());
+        const filterTypes = {};
+        for (const filter of allFilters){
+            if (filter.messageTypes) filterTypes['messageTypes'] = (filterTypes['messageTypes'] || 0) + 1;
+            if (filter.agentTypes) filterTypes['agentTypes'] = (filterTypes['agentTypes'] || 0) + 1;
+            if (filter.priorities) filterTypes['priorities'] = (filterTypes['priorities'] || 0) + 1;
+            if (filter.timeRange) filterTypes['timeRange'] = (filterTypes['timeRange'] || 0) + 1;
+            if (filter.contentKeywords) filterTypes['contentKeywords'] = (filterTypes['contentKeywords'] || 0) + 1;
+            if (filter.hasReasoning !== undefined) filterTypes['hasReasoning'] = (filterTypes['hasReasoning'] || 0) + 1;
+        }
+        return {
+            totalUsers: this.userFilters.size,
+            mostUsedFilters: filterTypes,
+            averageFiltersPerUser: allFilters.length / this.userFilters.size || 0
+        };
+    }
+    constructor(){
+        _define_property(this, "userFilters", new Map());
+    }
+}