@dollhousemcp/mcp-server 1.3.0

package/dist/elements/FeedbackProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FeedbackProcessor.d.ts","sourceRoot":"","sources":["../../src/elements/FeedbackProcessor.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,kBAAkB,EAClB,iBAAiB,EAElB,MAAM,4BAA4B,CAAC;AAKpC,qBAAa,iBAAkB,YAAW,kBAAkB;IAE1D,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAQ;IAG5C,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAW;IAG9C,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CA6ChC;IAGF,OAAO,CAAC,QAAQ,CAAC,eAAe,CAG9B;IAGF,OAAO,CAAC,QAAQ,CAAC,aAAa,CAG5B;;IAcF;;OAEG;IACU,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAwDlE;;OAEG;IACU,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,UAAU,GAAG,SAAS,CAAC;IA6CzF;;OAEG;IACU,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAgD9D;;OAEG;IACU,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAuChE;;OAEG;IACH,OAAO,CAAC,eAAe;IA+DvB;;OAEG;IACH,OAAO,CAAC,eAAe;IAiCvB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAgBxB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAY1B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAwB3B;;OAEG;IACH,OAAO,CAAC,0BAA0B;IAuBlC;;OAEG;IACH,OAAO,CAAC,kBAAkB;CAG3B"}

package/dist/elements/FeedbackProcessor.js

@@ -0,0 +1,418 @@
+/**
+ * Natural language feedback processor for extracting ratings and insights from user feedback.
+ */
+import { logger } from '../utils/logger.js';
+import { UnicodeValidator } from '../security/validators/unicodeValidator.js';
+import { SecurityMonitor } from '../security/securityMonitor.js';
+export class FeedbackProcessor {
+    // Maximum input length to prevent ReDoS attacks
+    MAX_FEEDBACK_LENGTH = 5000;
+    // Pre-compiled regex patterns for better performance
+    suggestionPatterns;
+    // Sentiment patterns with ratings
+    sentimentPatterns = {
+        veryPositive: {
+            patterns: [
+                'excellent', 'amazing', 'perfect', 'fantastic', 'love it',
+                'brilliant', 'outstanding', 'superb', 'exceptional', 'flawless',
+                'incredible', 'wonderful', 'best', 'awesome'
+            ],
+            rating: 5.0,
+            sentiment: 'positive'
+        },
+        positive: {
+            patterns: [
+                'good', 'helpful', 'useful', 'works well', 'nice', 'like it',
+                'great', 'effective', 'solid', 'reliable', 'appreciate',
+                'satisfied', 'happy', 'pleased'
+            ],
+            rating: 4.0,
+            sentiment: 'positive'
+        },
+        neutral: {
+            patterns: [
+                'okay', 'fine', 'adequate', 'acceptable', 'alright', 'decent',
+                'average', 'satisfactory', 'reasonable', 'fair', 'moderate'
+            ],
+            rating: 3.0,
+            sentiment: 'neutral'
+        },
+        negative: {
+            patterns: [
+                'disappointing', 'not great', 'could be better', 'expected better',
+                'issues', 'problems', 'lacking', 'subpar', 'mediocre', 'weak',
+                'frustrating', 'confused', 'unclear'
+            ],
+            rating: 2.0,
+            sentiment: 'negative'
+        },
+        veryNegative: {
+            patterns: [
+                'terrible', 'useless', 'broken', 'awful', 'hate it', 'worst',
+                'horrible', 'unacceptable', 'failed', 'disaster', 'worthless',
+                'completely broken', 'does not work'
+            ],
+            rating: 1.0,
+            sentiment: 'negative'
+        }
+    };
+    // Feature keywords for entity extraction
+    featureKeywords = [
+        'feature', 'functionality', 'capability', 'ability', 'option',
+        'tool', 'function', 'component', 'module', 'system'
+    ];
+    // Issue keywords for entity extraction
+    issueKeywords = [
+        'bug', 'error', 'issue', 'problem', 'crash', 'fail', 'broken',
+        'doesn\'t work', 'not working', 'glitch', 'defect', 'flaw'
+    ];
+    constructor() {
+        // Pre-compile regex patterns for performance
+        this.suggestionPatterns = [
+            /(?:should|could|would|might)\s+(?:be\s+)?(.+?)(?:\.|,|;|$)/g,
+            /(?:suggest|recommend|propose)\s+(?:that\s+)?(.+?)(?:\.|,|;|$)/g,
+            /(?:try|consider|think about)\s+(.+?)(?:\.|,|;|$)/g,
+            /(?:it would be (?:better|nice|good) if)\s+(.+?)(?:\.|,|;|$)/g,
+            /(?:needs?|requires?)\s+(?:to\s+)?(?:have\s+)?(?:be\s+)?(.+?)(?:\.|,|;|$)/g,
+            /(?:add|include|implement)\s+(.+?)(?:\.|,|;|$)/g
+        ];
+    }
+    /**
+     * Process natural language feedback into structured data.
+     */
+    async process(feedback) {
+        // Normalize Unicode input to prevent security issues
+        const validationResult = UnicodeValidator.normalize(feedback);
+        let normalizedFeedback = validationResult.normalizedContent;
+        // Log security event for feedback processing
+        SecurityMonitor.logSecurityEvent({
+            type: 'CONTENT_INJECTION_ATTEMPT',
+            severity: 'LOW',
+            source: 'FeedbackProcessor.process',
+            details: `Natural language feedback processed`,
+            additionalData: {
+                feedbackLength: feedback.length,
+                normalizedLength: normalizedFeedback.length,
+                hasUnicodeIssues: !validationResult.isValid,
+                detectedIssues: validationResult.detectedIssues
+            }
+        });
+        // Validate input length to prevent ReDoS
+        if (normalizedFeedback.length > this.MAX_FEEDBACK_LENGTH) {
+            logger.warn(`Feedback truncated from ${normalizedFeedback.length} to ${this.MAX_FEEDBACK_LENGTH} characters`);
+            normalizedFeedback = normalizedFeedback.substring(0, this.MAX_FEEDBACK_LENGTH);
+        }
+        const feedbackLower = normalizedFeedback.toLowerCase();
+        // Analyze sentiment
+        const sentiment = await this.analyzeSentiment(normalizedFeedback);
+        // Infer rating
+        const inferredRating = await this.inferRating(normalizedFeedback);
+        // Extract keywords
+        const keywords = this.extractKeywords(normalizedFeedback);
+        // Extract suggestions
+        const suggestions = await this.extractSuggestions(normalizedFeedback);
+        // Extract entities
+        const entities = this.extractEntities(normalizedFeedback);
+        // Calculate confidence based on clarity of feedback
+        const confidence = this.calculateConfidence(normalizedFeedback, sentiment, inferredRating);
+        return {
+            originalFeedback: normalizedFeedback,
+            sentiment,
+            inferredRating: inferredRating ?? undefined,
+            confidence,
+            keywords,
+            suggestions,
+            entities
+        };
+    }
+    /**
+     * Analyze sentiment from text.
+     */
+    async analyzeSentiment(text) {
+        const normalized = text.toLowerCase();
+        const scores = {
+            positive: 0,
+            negative: 0,
+            neutral: 0
+        };
+        // Check each sentiment category
+        for (const [category, config] of Object.entries(this.sentimentPatterns)) {
+            for (const pattern of config.patterns) {
+                if (normalized.includes(pattern)) {
+                    scores[config.sentiment] += this.getPatternWeight(pattern, normalized);
+                }
+            }
+        }
+        // Adjust for negations - more sophisticated handling
+        const negationPatterns = ['not', 'no', 'never', 'neither', 'nor', 'n\'t'];
+        for (const negation of negationPatterns) {
+            // Check for common positive negation patterns
+            if (normalized.includes(`${negation} bad`) ||
+                normalized.includes(`${negation} terrible`) ||
+                normalized.includes(`${negation} poor`)) {
+                scores.positive += 1;
+                scores.negative = Math.max(0, scores.negative - 1);
+            }
+            // Check for negative negation patterns
+            else if (normalized.includes(`${negation} good`) ||
+                normalized.includes(`${negation} great`)) {
+                scores.negative += 1;
+                scores.positive = Math.max(0, scores.positive - 1);
+            }
+        }
+        // Determine dominant sentiment
+        if (scores.positive > scores.negative && scores.positive > scores.neutral) {
+            return 'positive';
+        }
+        else if (scores.negative > scores.positive && scores.negative > scores.neutral) {
+            return 'negative';
+        }
+        return 'neutral';
+    }
+    /**
+     * Infer numeric rating from text.
+     */
+    async inferRating(text) {
+        const normalized = text.toLowerCase();
+        // Check for explicit ratings
+        const explicitPatterns = [
+            /(\d+)\s*(stars?|\/\s*5|out\s*of\s*5)/,
+            /rate\s*(?:it\s*)?(\d+)/,
+            /rating[:\s]+(\d+)/,
+            /score[:\s]+(\d+)/
+        ];
+        for (const pattern of explicitPatterns) {
+            const match = normalized.match(pattern);
+            if (match) {
+                const rating = parseInt(match[1]);
+                if (rating >= 1 && rating <= 5) {
+                    return rating;
+                }
+            }
+        }
+        // Check for percentage ratings
+        const percentMatch = normalized.match(/(\d+)\s*%/);
+        if (percentMatch) {
+            const percent = parseInt(percentMatch[1]);
+            if (percent >= 0 && percent <= 100) {
+                return Math.round(percent / 20); // Convert to 1-5 scale
+            }
+        }
+        // Infer from sentiment patterns
+        let bestMatch = { rating: null, weight: 0 };
+        for (const [category, config] of Object.entries(this.sentimentPatterns)) {
+            for (const pattern of config.patterns) {
+                if (normalized.includes(pattern)) {
+                    const weight = this.getPatternWeight(pattern, normalized);
+                    if (weight > bestMatch.weight) {
+                        bestMatch = { rating: config.rating, weight };
+                    }
+                }
+            }
+        }
+        // Return null if weight is too low (not confident)
+        return bestMatch.weight > 0.3 ? bestMatch.rating : null;
+    }
+    /**
+     * Extract improvement suggestions from feedback.
+     */
+    async extractSuggestions(text) {
+        // Length check to prevent ReDoS
+        if (text.length > this.MAX_FEEDBACK_LENGTH) {
+            text = text.substring(0, this.MAX_FEEDBACK_LENGTH);
+        }
+        const suggestions = [];
+        const normalized = text.toLowerCase();
+        // Use pre-compiled patterns with error handling
+        try {
+            for (const pattern of this.suggestionPatterns) {
+                // Reset regex state
+                pattern.lastIndex = 0;
+                let match;
+                let iterations = 0;
+                const MAX_ITERATIONS = 100; // Prevent infinite loops
+                while ((match = pattern.exec(normalized)) !== null && iterations < MAX_ITERATIONS) {
+                    iterations++;
+                    const suggestion = match[1].trim();
+                    if (suggestion.length > 10 && suggestion.length < 200) {
+                        suggestions.push(this.capitalizeSentence(suggestion));
+                    }
+                }
+            }
+        }
+        catch (error) {
+            logger.error('Error extracting suggestions', { error });
+        }
+        // Remove duplicates and clean up
+        return [...new Set(suggestions)].filter(s => !s.includes('undefined') &&
+            !s.includes('null') &&
+            s.split(' ').length > 2);
+    }
+    /**
+     * Extract entities (features, issues, etc.) from feedback.
+     */
+    extractEntities(text) {
+        const entities = [];
+        const sentences = text.split(/[.!?]+/);
+        for (const sentence of sentences) {
+            const normalized = sentence.toLowerCase().trim();
+            if (!normalized)
+                continue;
+            // Check for features
+            for (const keyword of this.featureKeywords) {
+                if (normalized.includes(keyword)) {
+                    entities.push({
+                        type: 'feature',
+                        text: sentence.trim(),
+                        relevance: this.calculateRelevance(keyword, normalized)
+                    });
+                    break;
+                }
+            }
+            // Check for issues
+            for (const keyword of this.issueKeywords) {
+                if (normalized.includes(keyword)) {
+                    entities.push({
+                        type: 'issue',
+                        text: sentence.trim(),
+                        relevance: this.calculateRelevance(keyword, normalized)
+                    });
+                    break;
+                }
+            }
+            // Check for praise
+            const praiseKeywords = ['love', 'excellent', 'perfect', 'great', 'amazing'];
+            for (const keyword of praiseKeywords) {
+                if (normalized.includes(keyword) && !normalized.includes('not')) {
+                    entities.push({
+                        type: 'praise',
+                        text: sentence.trim(),
+                        relevance: this.calculateRelevance(keyword, normalized)
+                    });
+                    break;
+                }
+            }
+            // Check for criticism
+            const criticismKeywords = ['hate', 'terrible', 'awful', 'bad', 'poor'];
+            for (const keyword of criticismKeywords) {
+                if (normalized.includes(keyword) && !normalized.includes('not')) {
+                    entities.push({
+                        type: 'criticism',
+                        text: sentence.trim(),
+                        relevance: this.calculateRelevance(keyword, normalized)
+                    });
+                    break;
+                }
+            }
+        }
+        // Sort by relevance
+        return entities.sort((a, b) => b.relevance - a.relevance);
+    }
+    /**
+     * Extract meaningful keywords from feedback.
+     */
+    extractKeywords(text) {
+        // Remove common words
+        const stopWords = new Set([
+            'the', 'is', 'it', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for',
+            'of', 'with', 'by', 'from', 'as', 'this', 'that', 'these', 'those',
+            'a', 'an', 'be', 'been', 'being', 'have', 'has', 'had', 'do', 'does',
+            'did', 'will', 'would', 'should', 'could', 'may', 'might', 'must',
+            'can', 'i', 'you', 'he', 'she', 'we', 'they', 'me', 'him', 'her'
+        ]);
+        // Extract words
+        const words = text.toLowerCase()
+            .replace(/[^\w\s]/g, ' ')
+            .split(/\s+/)
+            .filter(word => word.length > 2 &&
+            !stopWords.has(word) &&
+            !word.match(/^\d+$/));
+        // Count frequencies
+        const frequencies = new Map();
+        for (const word of words) {
+            frequencies.set(word, (frequencies.get(word) || 0) + 1);
+        }
+        // Sort by frequency and return top keywords
+        return Array.from(frequencies.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 10)
+            .map(([word]) => word);
+    }
+    /**
+     * Calculate pattern weight based on context.
+     */
+    getPatternWeight(pattern, text) {
+        const index = text.indexOf(pattern);
+        if (index === -1)
+            return 0;
+        // Higher weight if pattern appears early in text
+        const positionWeight = 1 - (index / text.length) * 0.3;
+        // Higher weight for longer patterns
+        const lengthWeight = Math.min(pattern.length / 10, 1);
+        // Check for emphasis (caps, exclamation marks)
+        const emphasisWeight = text.includes(pattern.toUpperCase()) ? 1.2 : 1;
+        return positionWeight * lengthWeight * emphasisWeight;
+    }
+    /**
+     * Calculate relevance of a keyword in context.
+     */
+    calculateRelevance(keyword, text) {
+        const keywordCount = (text.match(new RegExp(keyword, 'g')) || []).length;
+        const textLength = text.split(' ').length;
+        const density = keywordCount / textLength;
+        // Position bonus (earlier = more relevant)
+        const position = text.indexOf(keyword) / text.length;
+        const positionBonus = 1 - position * 0.5;
+        return Math.min(density * 10 * positionBonus, 1);
+    }
+    /**
+     * Calculate confidence in the analysis.
+     */
+    calculateConfidence(text, sentiment, rating) {
+        let confidence = 0.5; // Base confidence
+        // Increase confidence for longer, more detailed feedback
+        const wordCount = text.split(/\s+/).length;
+        if (wordCount > 20)
+            confidence += 0.2;
+        if (wordCount > 50)
+            confidence += 0.1;
+        // Increase confidence if rating was explicitly stated
+        if (rating !== null && text.match(/\d+\s*(stars?|\/\s*5|out\s*of\s*5)/)) {
+            confidence += 0.3;
+        }
+        // Increase confidence for clear sentiment signals
+        const sentimentStrength = this.calculateSentimentStrength(text);
+        confidence += sentimentStrength * 0.2;
+        return Math.min(confidence, 1);
+    }
+    /**
+     * Calculate how strongly sentiment is expressed.
+     */
+    calculateSentimentStrength(text) {
+        const normalized = text.toLowerCase();
+        let strength = 0;
+        // Check for strong positive/negative words
+        const strongWords = [
+            'excellent', 'terrible', 'amazing', 'awful', 'perfect', 'horrible',
+            'fantastic', 'disaster', 'love', 'hate', 'best', 'worst'
+        ];
+        for (const word of strongWords) {
+            if (normalized.includes(word)) {
+                strength += 0.3;
+            }
+        }
+        // Check for emphasis (caps, multiple exclamation/question marks)
+        if (text !== text.toLowerCase())
+            strength += 0.1; // Has caps
+        if (text.match(/[!?]{2,}/))
+            strength += 0.1; // Multiple punctuation
+        return Math.min(strength, 1);
+    }
+    /**
+     * Capitalize first letter of sentence.
+     */
+    capitalizeSentence(text) {
+        return text.charAt(0).toUpperCase() + text.slice(1);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FeedbackProcessor.js","sourceRoot":"","sources":["../../src/elements/FeedbackProcessor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Natural language feedback processor for extracting ratings and insights from user feedback.\n */\n\nimport { \n  IFeedbackProcessor, \n  ProcessedFeedback, \n  FeedbackEntity \n} from '../types/elements/index.js';\nimport { logger } from '../utils/logger.js';\nimport { UnicodeValidator } from '../security/validators/unicodeValidator.js';\nimport { SecurityMonitor } from '../security/securityMonitor.js';\n\nexport class FeedbackProcessor implements IFeedbackProcessor {\n  // Maximum input length to prevent ReDoS attacks\n  private readonly MAX_FEEDBACK_LENGTH = 5000;\n  \n  // Pre-compiled regex patterns for better performance\n  private readonly suggestionPatterns: RegExp[];\n  \n  // Sentiment patterns with ratings\n  private readonly sentimentPatterns = {\n    veryPositive: {\n      patterns: [\n        'excellent', 'amazing', 'perfect', 'fantastic', 'love it', \n        'brilliant', 'outstanding', 'superb', 'exceptional', 'flawless',\n        'incredible', 'wonderful', 'best', 'awesome'\n      ],\n      rating: 5.0,\n      sentiment: 'positive' as const\n    },\n    positive: {\n      patterns: [\n        'good', 'helpful', 'useful', 'works well', 'nice', 'like it',\n        'great', 'effective', 'solid', 'reliable', 'appreciate',\n        'satisfied', 'happy', 'pleased'\n      ],\n      rating: 4.0,\n      sentiment: 'positive' as const\n    },\n    neutral: {\n      patterns: [\n        'okay', 'fine', 'adequate', 'acceptable', 'alright', 'decent',\n        'average', 'satisfactory', 'reasonable', 'fair', 'moderate'\n      ],\n      rating: 3.0,\n      sentiment: 'neutral' as const\n    },\n    negative: {\n      patterns: [\n        'disappointing', 'not great', 'could be better', 'expected better',\n        'issues', 'problems', 'lacking', 'subpar', 'mediocre', 'weak',\n        'frustrating', 'confused', 'unclear'\n      ],\n      rating: 2.0,\n      sentiment: 'negative' as const\n    },\n    veryNegative: {\n      patterns: [\n        'terrible', 'useless', 'broken', 'awful', 'hate it', 'worst',\n        'horrible', 'unacceptable', 'failed', 'disaster', 'worthless',\n        'completely broken', 'does not work'\n      ],\n      rating: 1.0,\n      sentiment: 'negative' as const\n    }\n  };\n  \n  // Feature keywords for entity extraction\n  private readonly featureKeywords = [\n    'feature', 'functionality', 'capability', 'ability', 'option',\n    'tool', 'function', 'component', 'module', 'system'\n  ];\n  \n  // Issue keywords for entity extraction\n  private readonly issueKeywords = [\n    'bug', 'error', 'issue', 'problem', 'crash', 'fail', 'broken',\n    'doesn\\'t work', 'not working', 'glitch', 'defect', 'flaw'\n  ];\n  \n  constructor() {\n    // Pre-compile regex patterns for performance\n    this.suggestionPatterns = [\n      /(?:should|could|would|might)\\s+(?:be\\s+)?(.+?)(?:\\.|,|;|$)/g,\n      /(?:suggest|recommend|propose)\\s+(?:that\\s+)?(.+?)(?:\\.|,|;|$)/g,\n      /(?:try|consider|think about)\\s+(.+?)(?:\\.|,|;|$)/g,\n      /(?:it would be (?:better|nice|good) if)\\s+(.+?)(?:\\.|,|;|$)/g,\n      /(?:needs?|requires?)\\s+(?:to\\s+)?(?:have\\s+)?(?:be\\s+)?(.+?)(?:\\.|,|;|$)/g,\n      /(?:add|include|implement)\\s+(.+?)(?:\\.|,|;|$)/g\n    ];\n  }\n  \n  /**\n   * Process natural language feedback into structured data.\n   */\n  public async process(feedback: string): Promise<ProcessedFeedback> {\n    // Normalize Unicode input to prevent security issues\n    const validationResult = UnicodeValidator.normalize(feedback);\n    let normalizedFeedback = validationResult.normalizedContent;\n    \n    // Log security event for feedback processing\n    SecurityMonitor.logSecurityEvent({\n      type: 'CONTENT_INJECTION_ATTEMPT',\n      severity: 'LOW',\n      source: 'FeedbackProcessor.process',\n      details: `Natural language feedback processed`,\n      additionalData: { \n        feedbackLength: feedback.length,\n        normalizedLength: normalizedFeedback.length,\n        hasUnicodeIssues: !validationResult.isValid,\n        detectedIssues: validationResult.detectedIssues\n      }\n    });\n    \n    // Validate input length to prevent ReDoS\n    if (normalizedFeedback.length > this.MAX_FEEDBACK_LENGTH) {\n      logger.warn(`Feedback truncated from ${normalizedFeedback.length} to ${this.MAX_FEEDBACK_LENGTH} characters`);\n      normalizedFeedback = normalizedFeedback.substring(0, this.MAX_FEEDBACK_LENGTH);\n    }\n    \n    const feedbackLower = normalizedFeedback.toLowerCase();\n    \n    // Analyze sentiment\n    const sentiment = await this.analyzeSentiment(normalizedFeedback);\n    \n    // Infer rating\n    const inferredRating = await this.inferRating(normalizedFeedback);\n    \n    // Extract keywords\n    const keywords = this.extractKeywords(normalizedFeedback);\n    \n    // Extract suggestions\n    const suggestions = await this.extractSuggestions(normalizedFeedback);\n    \n    // Extract entities\n    const entities = this.extractEntities(normalizedFeedback);\n    \n    // Calculate confidence based on clarity of feedback\n    const confidence = this.calculateConfidence(normalizedFeedback, sentiment, inferredRating);\n    \n    return {\n      originalFeedback: normalizedFeedback,\n      sentiment,\n      inferredRating: inferredRating ?? undefined,\n      confidence,\n      keywords,\n      suggestions,\n      entities\n    };\n  }\n  \n  /**\n   * Analyze sentiment from text.\n   */\n  public async analyzeSentiment(text: string): Promise<'positive' | 'negative' | 'neutral'> {\n    const normalized = text.toLowerCase();\n    const scores = {\n      positive: 0,\n      negative: 0,\n      neutral: 0\n    };\n    \n    // Check each sentiment category\n    for (const [category, config] of Object.entries(this.sentimentPatterns)) {\n      for (const pattern of config.patterns) {\n        if (normalized.includes(pattern)) {\n          scores[config.sentiment] += this.getPatternWeight(pattern, normalized);\n        }\n      }\n    }\n    \n    // Adjust for negations - more sophisticated handling\n    const negationPatterns = ['not', 'no', 'never', 'neither', 'nor', 'n\\'t'];\n    for (const negation of negationPatterns) {\n      // Check for common positive negation patterns\n      if (normalized.includes(`${negation} bad`) || \n          normalized.includes(`${negation} terrible`) ||\n          normalized.includes(`${negation} poor`)) {\n        scores.positive += 1;\n        scores.negative = Math.max(0, scores.negative - 1);\n      }\n      // Check for negative negation patterns\n      else if (normalized.includes(`${negation} good`) ||\n               normalized.includes(`${negation} great`)) {\n        scores.negative += 1;\n        scores.positive = Math.max(0, scores.positive - 1);\n      }\n    }\n    \n    // Determine dominant sentiment\n    if (scores.positive > scores.negative && scores.positive > scores.neutral) {\n      return 'positive';\n    } else if (scores.negative > scores.positive && scores.negative > scores.neutral) {\n      return 'negative';\n    }\n    \n    return 'neutral';\n  }\n  \n  /**\n   * Infer numeric rating from text.\n   */\n  public async inferRating(text: string): Promise<number | null> {\n    const normalized = text.toLowerCase();\n    \n    // Check for explicit ratings\n    const explicitPatterns = [\n      /(\\d+)\\s*(stars?|\\/\\s*5|out\\s*of\\s*5)/,\n      /rate\\s*(?:it\\s*)?(\\d+)/,\n      /rating[:\\s]+(\\d+)/,\n      /score[:\\s]+(\\d+)/\n    ];\n    \n    for (const pattern of explicitPatterns) {\n      const match = normalized.match(pattern);\n      if (match) {\n        const rating = parseInt(match[1]);\n        if (rating >= 1 && rating <= 5) {\n          return rating;\n        }\n      }\n    }\n    \n    // Check for percentage ratings\n    const percentMatch = normalized.match(/(\\d+)\\s*%/);\n    if (percentMatch) {\n      const percent = parseInt(percentMatch[1]);\n      if (percent >= 0 && percent <= 100) {\n        return Math.round(percent / 20); // Convert to 1-5 scale\n      }\n    }\n    \n    // Infer from sentiment patterns\n    let bestMatch = { rating: null as number | null, weight: 0 };\n    \n    for (const [category, config] of Object.entries(this.sentimentPatterns)) {\n      for (const pattern of config.patterns) {\n        if (normalized.includes(pattern)) {\n          const weight = this.getPatternWeight(pattern, normalized);\n          if (weight > bestMatch.weight) {\n            bestMatch = { rating: config.rating, weight };\n          }\n        }\n      }\n    }\n    \n    // Return null if weight is too low (not confident)\n    return bestMatch.weight > 0.3 ? bestMatch.rating : null;\n  }\n  \n  /**\n   * Extract improvement suggestions from feedback.\n   */\n  public async extractSuggestions(text: string): Promise<string[]> {\n    // Length check to prevent ReDoS\n    if (text.length > this.MAX_FEEDBACK_LENGTH) {\n      text = text.substring(0, this.MAX_FEEDBACK_LENGTH);\n    }\n    \n    const suggestions: string[] = [];\n    const normalized = text.toLowerCase();\n    \n    // Use pre-compiled patterns with error handling\n    try {\n      for (const pattern of this.suggestionPatterns) {\n        // Reset regex state\n        pattern.lastIndex = 0;\n        \n        let match;\n        let iterations = 0;\n        const MAX_ITERATIONS = 100; // Prevent infinite loops\n        \n        while ((match = pattern.exec(normalized)) !== null && iterations < MAX_ITERATIONS) {\n          iterations++;\n          const suggestion = match[1].trim();\n          if (suggestion.length > 10 && suggestion.length < 200) {\n            suggestions.push(this.capitalizeSentence(suggestion));\n          }\n        }\n      }\n    } catch (error) {\n      logger.error('Error extracting suggestions', { error });\n    }\n    \n    // Remove duplicates and clean up\n    return [...new Set(suggestions)].filter(s => \n      !s.includes('undefined') && \n      !s.includes('null') &&\n      s.split(' ').length > 2\n    );\n  }\n  \n  /**\n   * Extract entities (features, issues, etc.) from feedback.\n   */\n  private extractEntities(text: string): FeedbackEntity[] {\n    const entities: FeedbackEntity[] = [];\n    const sentences = text.split(/[.!?]+/);\n    \n    for (const sentence of sentences) {\n      const normalized = sentence.toLowerCase().trim();\n      if (!normalized) continue;\n      \n      // Check for features\n      for (const keyword of this.featureKeywords) {\n        if (normalized.includes(keyword)) {\n          entities.push({\n            type: 'feature',\n            text: sentence.trim(),\n            relevance: this.calculateRelevance(keyword, normalized)\n          });\n          break;\n        }\n      }\n      \n      // Check for issues\n      for (const keyword of this.issueKeywords) {\n        if (normalized.includes(keyword)) {\n          entities.push({\n            type: 'issue',\n            text: sentence.trim(),\n            relevance: this.calculateRelevance(keyword, normalized)\n          });\n          break;\n        }\n      }\n      \n      // Check for praise\n      const praiseKeywords = ['love', 'excellent', 'perfect', 'great', 'amazing'];\n      for (const keyword of praiseKeywords) {\n        if (normalized.includes(keyword) && !normalized.includes('not')) {\n          entities.push({\n            type: 'praise',\n            text: sentence.trim(),\n            relevance: this.calculateRelevance(keyword, normalized)\n          });\n          break;\n        }\n      }\n      \n      // Check for criticism\n      const criticismKeywords = ['hate', 'terrible', 'awful', 'bad', 'poor'];\n      for (const keyword of criticismKeywords) {\n        if (normalized.includes(keyword) && !normalized.includes('not')) {\n          entities.push({\n            type: 'criticism',\n            text: sentence.trim(),\n            relevance: this.calculateRelevance(keyword, normalized)\n          });\n          break;\n        }\n      }\n    }\n    \n    // Sort by relevance\n    return entities.sort((a, b) => b.relevance - a.relevance);\n  }\n  \n  /**\n   * Extract meaningful keywords from feedback.\n   */\n  private extractKeywords(text: string): string[] {\n    // Remove common words\n    const stopWords = new Set([\n      'the', 'is', 'it', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for',\n      'of', 'with', 'by', 'from', 'as', 'this', 'that', 'these', 'those',\n      'a', 'an', 'be', 'been', 'being', 'have', 'has', 'had', 'do', 'does',\n      'did', 'will', 'would', 'should', 'could', 'may', 'might', 'must',\n      'can', 'i', 'you', 'he', 'she', 'we', 'they', 'me', 'him', 'her'\n    ]);\n    \n    // Extract words\n    const words = text.toLowerCase()\n      .replace(/[^\\w\\s]/g, ' ')\n      .split(/\\s+/)\n      .filter(word => \n        word.length > 2 && \n        !stopWords.has(word) &&\n        !word.match(/^\\d+$/)\n      );\n    \n    // Count frequencies\n    const frequencies = new Map<string, number>();\n    for (const word of words) {\n      frequencies.set(word, (frequencies.get(word) || 0) + 1);\n    }\n    \n    // Sort by frequency and return top keywords\n    return Array.from(frequencies.entries())\n      .sort((a, b) => b[1] - a[1])\n      .slice(0, 10)\n      .map(([word]) => word);\n  }\n  \n  /**\n   * Calculate pattern weight based on context.\n   */\n  private getPatternWeight(pattern: string, text: string): number {\n    const index = text.indexOf(pattern);\n    if (index === -1) return 0;\n    \n    // Higher weight if pattern appears early in text\n    const positionWeight = 1 - (index / text.length) * 0.3;\n    \n    // Higher weight for longer patterns\n    const lengthWeight = Math.min(pattern.length / 10, 1);\n    \n    // Check for emphasis (caps, exclamation marks)\n    const emphasisWeight = text.includes(pattern.toUpperCase()) ? 1.2 : 1;\n    \n    return positionWeight * lengthWeight * emphasisWeight;\n  }\n  \n  /**\n   * Calculate relevance of a keyword in context.\n   */\n  private calculateRelevance(keyword: string, text: string): number {\n    const keywordCount = (text.match(new RegExp(keyword, 'g')) || []).length;\n    const textLength = text.split(' ').length;\n    const density = keywordCount / textLength;\n    \n    // Position bonus (earlier = more relevant)\n    const position = text.indexOf(keyword) / text.length;\n    const positionBonus = 1 - position * 0.5;\n    \n    return Math.min(density * 10 * positionBonus, 1);\n  }\n  \n  /**\n   * Calculate confidence in the analysis.\n   */\n  private calculateConfidence(\n    text: string, \n    sentiment: string, \n    rating: number | null\n  ): number {\n    let confidence = 0.5; // Base confidence\n    \n    // Increase confidence for longer, more detailed feedback\n    const wordCount = text.split(/\\s+/).length;\n    if (wordCount > 20) confidence += 0.2;\n    if (wordCount > 50) confidence += 0.1;\n    \n    // Increase confidence if rating was explicitly stated\n    if (rating !== null && text.match(/\\d+\\s*(stars?|\\/\\s*5|out\\s*of\\s*5)/)) {\n      confidence += 0.3;\n    }\n    \n    // Increase confidence for clear sentiment signals\n    const sentimentStrength = this.calculateSentimentStrength(text);\n    confidence += sentimentStrength * 0.2;\n    \n    return Math.min(confidence, 1);\n  }\n  \n  /**\n   * Calculate how strongly sentiment is expressed.\n   */\n  private calculateSentimentStrength(text: string): number {\n    const normalized = text.toLowerCase();\n    let strength = 0;\n    \n    // Check for strong positive/negative words\n    const strongWords = [\n      'excellent', 'terrible', 'amazing', 'awful', 'perfect', 'horrible',\n      'fantastic', 'disaster', 'love', 'hate', 'best', 'worst'\n    ];\n    \n    for (const word of strongWords) {\n      if (normalized.includes(word)) {\n        strength += 0.3;\n      }\n    }\n    \n    // Check for emphasis (caps, multiple exclamation/question marks)\n    if (text !== text.toLowerCase()) strength += 0.1; // Has caps\n    if (text.match(/[!?]{2,}/)) strength += 0.1; // Multiple punctuation\n    \n    return Math.min(strength, 1);\n  }\n  \n  /**\n   * Capitalize first letter of sentence.\n   */\n  private capitalizeSentence(text: string): string {\n    return text.charAt(0).toUpperCase() + text.slice(1);\n  }\n}"]}

package/dist/elements/agents/Agent.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Agent element implementation.
+ * Autonomous goal-oriented actors with decision-making capabilities.
+ *
+ * SECURITY MEASURES IMPLEMENTED:
+ * 1. Goal validation to prevent malicious objectives
+ * 2. Decision framework sandboxing
+ * 3. State size limits to prevent DoS
+ * 4. Risk assessment for damage prevention
+ * 5. Audit logging for all decisions and actions
+ */
+import { BaseElement } from '../BaseElement.js';
+import { IElement, ElementValidationResult } from '../../types/elements/index.js';
+import { AgentGoal, AgentDecision, AgentState, AgentMetadata } from './types.js';
+import { RuleEngineConfig } from './ruleEngineConfig.js';
+export declare class Agent extends BaseElement implements IElement {
+    private state;
+    private isDirtyState;
+    private ruleEngineConfig;
+    constructor(metadata: Partial<AgentMetadata>);
+    /**
+     * Add a new goal with security validation
+     */
+    addGoal(goal: Partial<AgentGoal>): AgentGoal;
+    /**
+     * Make a decision for a goal
+     */
+    makeDecision(goalId: string, context?: Record<string, any>): Promise<AgentDecision>;
+    /**
+     * Execute decision framework
+     */
+    private executeDecisionFramework;
+    /**
+     * Rule-based decision making
+     */
+    private ruleBasedDecision;
+    /**
+     * Programmatic decision making
+     */
+    private programmaticDecision;
+    /**
+     * Assess risk for a decision
+     */
+    private assessRisk;
+    /**
+     * Calculate Eisenhower quadrant
+     */
+    private calculateEisenhowerQuadrant;
+    /**
+     * Validate goal for security threats
+     */
+    private validateGoalSecurity;
+    /**
+     * Get agent state
+     */
+    getState(): Readonly<AgentState>;
+    /**
+     * Update agent context
+     */
+    updateContext(key: string, value: any): void;
+    /**
+     * Complete a goal
+     */
+    completeGoal(goalId: string, outcome?: 'success' | 'failure' | 'partial'): void;
+    /**
+     * Detect dependency cycles in goal dependencies
+     * MEDIUM PRIORITY IMPROVEMENT: Prevents circular dependencies between goals
+     */
+    private detectDependencyCycle;
+    /**
+     * Get goals by status
+     */
+    getGoalsByStatus(status: AgentGoal['status']): AgentGoal[];
+    /**
+     * Get goals by quadrant
+     */
+    getGoalsByQuadrant(quadrant: AgentGoal['eisenhowerQuadrant']): AgentGoal[];
+    /**
+     * Calculate agent performance metrics
+     * MEDIUM PRIORITY IMPROVEMENT: Enhanced to include decision timing metrics
+     */
+    getPerformanceMetrics(): {
+        successRate: number;
+        averageCompletionTime: number;
+        goalsCompleted: number;
+        goalsInProgress: number;
+        decisionAccuracy: number;
+        averageDecisionTimeMs?: number;
+        averageFrameworkTimeMs?: number;
+        averageRiskAssessmentTimeMs?: number;
+    };
+    /**
+     * Validate the agent
+     */
+    validate(): ElementValidationResult;
+    /**
+     * Serialize agent including state
+     */
+    serialize(): string;
+    /**
+     * Deserialize agent including state
+     */
+    deserialize(data: string): void;
+    /**
+     * Agent activation
+     */
+    activate(): Promise<void>;
+    /**
+     * Agent deactivation
+     */
+    deactivate(): Promise<void>;
+    /**
+     * Check if agent needs state persistence
+     */
+    needsStatePersistence(): boolean;
+    /**
+     * Mark state as persisted
+     */
+    markStatePersisted(): void;
+    /**
+     * Create a goal from a template
+     * LOW PRIORITY IMPROVEMENT: Goal template system for common patterns
+     */
+    addGoalFromTemplate(templateId: string, customFields: Record<string, any>): AgentGoal;
+    /**
+     * Get template recommendations based on goal description
+     */
+    getGoalTemplateRecommendations(description: string): string[];
+    /**
+     * Validate a goal against its template
+     */
+    validateGoalTemplate(goalId: string): {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * Update rule engine configuration
+     */
+    updateRuleEngineConfig(config: Partial<RuleEngineConfig>): void;
+    /**
+     * Get current rule engine configuration
+     */
+    getRuleEngineConfig(): Readonly<RuleEngineConfig>;
+}
+//# sourceMappingURL=Agent.d.ts.map

package/dist/elements/agents/Agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Agent.d.ts","sourceRoot":"","sources":["../../../src/elements/agents/Agent.ts"],"names":[],"mappings":"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"}