@dollhousemcp/mcp-server 1.3.0

package/dist/test/src/constants/defaultPersonas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultPersonas.d.ts","sourceRoot":"","sources":["../../../../src/constants/defaultPersonas.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,gBAAgB,iJAOnB,CAAC;AAEX,MAAM,MAAM,sBAAsB,GAAG,OAAO,gBAAgB,CAAC,MAAM,CAAC,CAAC;AAErE;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAE1D"}

package/dist/test/src/constants/defaultPersonas.js

@@ -0,0 +1,18 @@
+/**
+ * Default personas that ship with DollhouseMCP
+ */
+export const DEFAULT_PERSONAS = [
+    'business-consultant.md',
+    'creative-writer.md',
+    'debug-detective.md',
+    'eli5-explainer.md',
+    'excel-expert.md',
+    'technical-analyst.md'
+];
+/**
+ * Check if a filename is a default persona
+ */
+export function isDefaultPersona(filename) {
+    return DEFAULT_PERSONAS.includes(filename);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdFBlcnNvbmFzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2NvbnN0YW50cy9kZWZhdWx0UGVyc29uYXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxnQkFBZ0IsR0FBRztJQUM5Qix3QkFBd0I7SUFDeEIsb0JBQW9CO0lBQ3BCLG9CQUFvQjtJQUNwQixtQkFBbUI7SUFDbkIsaUJBQWlCO0lBQ2pCLHNCQUFzQjtDQUNkLENBQUM7QUFJWDs7R0FFRztBQUNILE1BQU0sVUFBVSxnQkFBZ0IsQ0FBQyxRQUFnQjtJQUMvQyxPQUFPLGdCQUFnQixDQUFDLFFBQVEsQ0FBQyxRQUFrQyxDQUFDLENBQUM7QUFDdkUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRGVmYXVsdCBwZXJzb25hcyB0aGF0IHNoaXAgd2l0aCBEb2xsaG91c2VNQ1BcbiAqL1xuZXhwb3J0IGNvbnN0IERFRkFVTFRfUEVSU09OQVMgPSBbXG4gICdidXNpbmVzcy1jb25zdWx0YW50Lm1kJyxcbiAgJ2NyZWF0aXZlLXdyaXRlci5tZCcsXG4gICdkZWJ1Zy1kZXRlY3RpdmUubWQnLFxuICAnZWxpNS1leHBsYWluZXIubWQnLFxuICAnZXhjZWwtZXhwZXJ0Lm1kJyxcbiAgJ3RlY2huaWNhbC1hbmFseXN0Lm1kJ1xuXSBhcyBjb25zdDtcblxuZXhwb3J0IHR5cGUgRGVmYXVsdFBlcnNvbmFGaWxlbmFtZSA9IHR5cGVvZiBERUZBVUxUX1BFUlNPTkFTW251bWJlcl07XG5cbi8qKlxuICogQ2hlY2sgaWYgYSBmaWxlbmFtZSBpcyBhIGRlZmF1bHQgcGVyc29uYVxuICovXG5leHBvcnQgZnVuY3Rpb24gaXNEZWZhdWx0UGVyc29uYShmaWxlbmFtZTogc3RyaW5nKTogYm9vbGVhbiB7XG4gIHJldHVybiBERUZBVUxUX1BFUlNPTkFTLmluY2x1ZGVzKGZpbGVuYW1lIGFzIERlZmF1bHRQZXJzb25hRmlsZW5hbWUpO1xufSJdfQ==

package/dist/test/src/constants/limits.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Size and limit constants for DollhouseMCP
+ */
+export declare const MAX_PERSONA_SIZE: number;
+export declare const MAX_BUNDLE_SIZE: number;
+export declare const MAX_PERSONAS_PER_BUNDLE = 50;
+export declare const GITHUB_API_RATE_LIMIT = 60;
+export declare const GITHUB_API_RATE_LIMIT_AUTH = 5000;
+export declare const MAX_URL_LENGTH = 2048;
+//# sourceMappingURL=limits.d.ts.map

package/dist/test/src/constants/limits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"limits.d.ts","sourceRoot":"","sources":["../../../../src/constants/limits.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,eAAO,MAAM,gBAAgB,QAAa,CAAC;AAC3C,eAAO,MAAM,eAAe,QAAc,CAAC;AAC3C,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAG1C,eAAO,MAAM,qBAAqB,KAAK,CAAC;AACxC,eAAO,MAAM,0BAA0B,OAAO,CAAC;AAG/C,eAAO,MAAM,cAAc,OAAO,CAAC"}

package/dist/test/src/constants/limits.js

@@ -0,0 +1,13 @@
+/**
+ * Size and limit constants for DollhouseMCP
+ */
+// Export/Import limits
+export const MAX_PERSONA_SIZE = 100 * 1024; // 100KB per persona
+export const MAX_BUNDLE_SIZE = 1024 * 1024; // 1MB for bundles
+export const MAX_PERSONAS_PER_BUNDLE = 50; // Maximum personas in a single bundle
+// GitHub API limits
+export const GITHUB_API_RATE_LIMIT = 60; // Requests per hour for unauthenticated
+export const GITHUB_API_RATE_LIMIT_AUTH = 5000; // Requests per hour for authenticated
+// URL limits
+export const MAX_URL_LENGTH = 2048; // Maximum URL length for safety
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGltaXRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2NvbnN0YW50cy9saW1pdHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCx1QkFBdUI7QUFDdkIsTUFBTSxDQUFDLE1BQU0sZ0JBQWdCLEdBQUcsR0FBRyxHQUFHLElBQUksQ0FBQyxDQUFDLG9CQUFvQjtBQUNoRSxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsSUFBSSxHQUFHLElBQUksQ0FBQyxDQUFDLGtCQUFrQjtBQUM5RCxNQUFNLENBQUMsTUFBTSx1QkFBdUIsR0FBRyxFQUFFLENBQUMsQ0FBQyxzQ0FBc0M7QUFFakYsb0JBQW9CO0FBQ3BCLE1BQU0sQ0FBQyxNQUFNLHFCQUFxQixHQUFHLEVBQUUsQ0FBQyxDQUFDLHdDQUF3QztBQUNqRixNQUFNLENBQUMsTUFBTSwwQkFBMEIsR0FBRyxJQUFJLENBQUMsQ0FBQyxzQ0FBc0M7QUFFdEYsYUFBYTtBQUNiLE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBRyxJQUFJLENBQUMsQ0FBQyxnQ0FBZ0MiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFNpemUgYW5kIGxpbWl0IGNvbnN0YW50cyBmb3IgRG9sbGhvdXNlTUNQXG4gKi9cblxuLy8gRXhwb3J0L0ltcG9ydCBsaW1pdHNcbmV4cG9ydCBjb25zdCBNQVhfUEVSU09OQV9TSVpFID0gMTAwICogMTAyNDsgLy8gMTAwS0IgcGVyIHBlcnNvbmFcbmV4cG9ydCBjb25zdCBNQVhfQlVORExFX1NJWkUgPSAxMDI0ICogMTAyNDsgLy8gMU1CIGZvciBidW5kbGVzXG5leHBvcnQgY29uc3QgTUFYX1BFUlNPTkFTX1BFUl9CVU5ETEUgPSA1MDsgLy8gTWF4aW11bSBwZXJzb25hcyBpbiBhIHNpbmdsZSBidW5kbGVcblxuLy8gR2l0SHViIEFQSSBsaW1pdHNcbmV4cG9ydCBjb25zdCBHSVRIVUJfQVBJX1JBVEVfTElNSVQgPSA2MDsgLy8gUmVxdWVzdHMgcGVyIGhvdXIgZm9yIHVuYXV0aGVudGljYXRlZFxuZXhwb3J0IGNvbnN0IEdJVEhVQl9BUElfUkFURV9MSU1JVF9BVVRIID0gNTAwMDsgLy8gUmVxdWVzdHMgcGVyIGhvdXIgZm9yIGF1dGhlbnRpY2F0ZWRcblxuLy8gVVJMIGxpbWl0c1xuZXhwb3J0IGNvbnN0IE1BWF9VUkxfTEVOR1RIID0gMjA0ODsgLy8gTWF4aW11bSBVUkwgbGVuZ3RoIGZvciBzYWZldHkiXX0=

package/dist/test/src/elements/BaseElement.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Base abstract class implementing IElement interface.
+ * Provides common functionality that all element types can extend.
+ */
+import { IElement, IElementMetadata, ElementStatus, ElementRatings, Reference, ElementValidationResult, FeedbackContext } from '../types/elements/index.js';
+import { ElementType } from '../portfolio/types.js';
+export declare abstract class BaseElement implements IElement {
+    id: string;
+    type: ElementType;
+    version: string;
+    metadata: IElementMetadata;
+    references?: Reference[];
+    extensions?: Record<string, any>;
+    ratings?: ElementRatings;
+    protected _status: ElementStatus;
+    protected _isDirty: boolean;
+    private readonly MAX_FEEDBACK_HISTORY;
+    constructor(type: ElementType, metadata?: Partial<IElementMetadata>);
+    /**
+     * Generate a unique ID for the element based on its name and type.
+     * Format: type_name-slug_timestamp
+     */
+    protected generateId(name: string): string;
+    /**
+     * Core validation that all elements share.
+     * Subclasses should override and call super.validate() first.
+     */
+    validate(): ElementValidationResult;
+    /**
+     * Default serialization to JSON.
+     * Subclasses can override for custom formats.
+     */
+    serialize(): string;
+    /**
+     * Default deserialization from JSON.
+     * Subclasses can override for custom formats.
+     */
+    deserialize(data: string): void;
+    /**
+     * Process user feedback and update ratings.
+     */
+    receiveFeedback(feedback: string, context?: FeedbackContext): void;
+    /**
+     * Simple sentiment analysis.
+     * Subclasses can override for more sophisticated analysis.
+     */
+    protected analyzeSentiment(feedback: string): 'positive' | 'negative' | 'neutral';
+    /**
+     * Simple rating inference from feedback.
+     * Subclasses can override for more sophisticated inference.
+     */
+    protected inferRating(feedback: string): number | undefined;
+    /**
+     * Update user rating with a new value.
+     */
+    protected updateUserRating(newRating: number): void;
+    /**
+     * Get current element status.
+     */
+    getStatus(): ElementStatus;
+    /**
+     * Default lifecycle methods - subclasses should override as needed.
+     */
+    beforeActivate(): Promise<void>;
+    activate(): Promise<void>;
+    afterActivate(): Promise<void>;
+    deactivate(): Promise<void>;
+    /**
+     * Mark element as modified.
+     */
+    protected markDirty(): void;
+    /**
+     * Check if element has unsaved changes.
+     */
+    isDirty(): boolean;
+    /**
+     * Mark element as saved.
+     */
+    markClean(): void;
+}
+//# sourceMappingURL=BaseElement.d.ts.map

package/dist/test/src/elements/BaseElement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseElement.d.ts","sourceRoot":"","sources":["../../../../src/elements/BaseElement.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,QAAQ,EACR,gBAAgB,EAChB,aAAa,EACb,cAAc,EACd,SAAS,EACT,uBAAuB,EAGvB,eAAe,EAEhB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAMpD,8BAAsB,WAAY,YAAW,QAAQ;IAE5C,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,WAAW,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAGhB,QAAQ,EAAE,gBAAgB,CAAC;IAG3B,UAAU,CAAC,EAAE,SAAS,EAAE,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACjC,OAAO,CAAC,EAAE,cAAc,CAAC;IAGhC,SAAS,CAAC,OAAO,EAAE,aAAa,CAA0B;IAC1D,SAAS,CAAC,QAAQ,EAAE,OAAO,CAAS;IAGpC,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAO;gBAEhC,IAAI,EAAE,WAAW,EAAE,QAAQ,GAAE,OAAO,CAAC,gBAAgB,CAAM;IAgCvE;;;OAGG;IACH,SAAS,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAW1C;;;OAGG;IACI,QAAQ,IAAI,uBAAuB;IA8F1C;;;OAGG;IACI,SAAS,IAAI,MAAM;IAc1B;;;OAGG;IACI,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IA2BtC;;OAEG;IACI,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,IAAI;IA6DzE;;;OAGG;IACH,SAAS,CAAC,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,GAAG,UAAU,GAAG,SAAS;IAcjF;;;OAGG;IACH,SAAS,CAAC,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAyB3D;;OAEG;IACH,SAAS,CAAC,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IA+BnD;;OAEG;IACI,SAAS,IAAI,aAAa;IAIjC;;OAEG;IACU,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IAK/B,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAKzB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAI9B,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAOxC;;OAEG;IACH,SAAS,CAAC,SAAS,IAAI,IAAI;IAK3B;;OAEG;IACI,OAAO,IAAI,OAAO;IAIzB;;OAEG;IACI,SAAS,IAAI,IAAI;CAGzB"}

package/dist/test/src/elements/BaseElement.js

@@ -0,0 +1,381 @@
+/**
+ * Base abstract class implementing IElement interface.
+ * Provides common functionality that all element types can extend.
+ */
+import { ElementStatus } from '../types/elements/index.js';
+import { v4 as uuidv4 } from 'uuid';
+import { logger } from '../utils/logger.js';
+import { UnicodeValidator } from '../security/validators/unicodeValidator.js';
+import { SecurityMonitor } from '../security/securityMonitor.js';
+export class BaseElement {
+    // Identity
+    id;
+    type;
+    version;
+    // Metadata
+    metadata;
+    // Features
+    references;
+    extensions;
+    ratings;
+    // Internal state
+    _status = ElementStatus.INACTIVE;
+    _isDirty = false;
+    // Constants
+    MAX_FEEDBACK_HISTORY = 100;
+    constructor(type, metadata = {}) {
+        this.type = type;
+        this.id = metadata.name ? this.generateId(metadata.name) : uuidv4();
+        this.version = metadata.version || '1.0.0';
+        // Initialize metadata with defaults
+        this.metadata = {
+            name: metadata.name || 'Unnamed Element',
+            description: metadata.description || '',
+            author: metadata.author,
+            version: this.version,
+            created: metadata.created || new Date().toISOString(),
+            modified: metadata.modified || new Date().toISOString(),
+            tags: metadata.tags || [],
+            dependencies: metadata.dependencies || [],
+            custom: metadata.custom || {}
+        };
+        // Initialize optional features
+        this.references = [];
+        this.extensions = {};
+        this.ratings = {
+            aiRating: 0,
+            userRating: undefined,
+            ratingCount: 0,
+            lastEvaluated: new Date(),
+            confidence: 0,
+            trend: 'stable',
+            feedbackHistory: []
+        };
+    }
+    /**
+     * Generate a unique ID for the element based on its name and type.
+     * Format: type_name-slug_timestamp
+     */
+    generateId(name) {
+        const typeSlug = this.type.toLowerCase();
+        const nameSlug = name
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '-')
+            .replace(/^-|-$/g, '');
+        const timestamp = Date.now();
+        return `${typeSlug}_${nameSlug}_${timestamp}`;
+    }
+    /**
+     * Core validation that all elements share.
+     * Subclasses should override and call super.validate() first.
+     */
+    validate() {
+        // Log security-relevant validation event
+        SecurityMonitor.logSecurityEvent({
+            type: 'YAML_PARSE_SUCCESS',
+            severity: 'LOW',
+            source: 'BaseElement.validate',
+            details: `Element validation performed for ${this.type}:${this.id}`,
+            additionalData: { elementType: this.type, elementId: this.id }
+        });
+        const errors = [];
+        const warnings = [];
+        const suggestions = [];
+        // Validate required fields
+        if (!this.id) {
+            errors.push({ field: 'id', message: 'Element ID is required' });
+        }
+        if (!this.metadata.name || this.metadata.name.trim() === '') {
+            errors.push({ field: 'metadata.name', message: 'Element name is required' });
+        }
+        if (!this.metadata.description || this.metadata.description.trim() === '') {
+            warnings.push({
+                field: 'metadata.description',
+                message: 'Element description is recommended',
+                severity: 'medium'
+            });
+        }
+        // Validate version format (semver)
+        const semverRegex = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?(\+[a-zA-Z0-9.-]+)?$/;
+        if (!semverRegex.test(this.version)) {
+            errors.push({
+                field: 'version',
+                message: 'Version must follow semantic versioning (e.g., 1.0.0)',
+                code: 'INVALID_VERSION_FORMAT'
+            });
+        }
+        // Validate references
+        if (this.references) {
+            this.references.forEach((ref, index) => {
+                if (!ref.uri || ref.uri.trim() === '') {
+                    errors.push({
+                        field: `references[${index}].uri`,
+                        message: 'Reference URI is required'
+                    });
+                }
+                if (!ref.title || ref.title.trim() === '') {
+                    warnings.push({
+                        field: `references[${index}].title`,
+                        message: 'Reference title is recommended',
+                        severity: 'low'
+                    });
+                }
+            });
+        }
+        // Validate ratings if present
+        if (this.ratings) {
+            if (this.ratings.aiRating < 0 || this.ratings.aiRating > 5) {
+                errors.push({
+                    field: 'ratings.aiRating',
+                    message: 'AI rating must be between 0 and 5'
+                });
+            }
+            if (this.ratings.userRating !== undefined &&
+                (this.ratings.userRating < 0 || this.ratings.userRating > 5)) {
+                errors.push({
+                    field: 'ratings.userRating',
+                    message: 'User rating must be between 0 and 5'
+                });
+            }
+        }
+        // Add suggestions
+        if (!this.metadata.tags || this.metadata.tags.length === 0) {
+            suggestions.push('Consider adding tags to improve discoverability');
+        }
+        if (!this.metadata.author) {
+            suggestions.push('Consider adding author information');
+        }
+        return {
+            valid: errors.length === 0,
+            errors: errors.length > 0 ? errors : undefined,
+            warnings: warnings.length > 0 ? warnings : undefined,
+            suggestions: suggestions.length > 0 ? suggestions : undefined
+        };
+    }
+    /**
+     * Default serialization to JSON.
+     * Subclasses can override for custom formats.
+     */
+    serialize() {
+        const data = {
+            id: this.id,
+            type: this.type,
+            version: this.version,
+            metadata: this.metadata,
+            references: this.references,
+            extensions: this.extensions,
+            ratings: this.ratings
+        };
+        return JSON.stringify(data, null, 2);
+    }
+    /**
+     * Default deserialization from JSON.
+     * Subclasses can override for custom formats.
+     */
+    deserialize(data) {
+        try {
+            // Normalize Unicode input before parsing
+            const validationResult = UnicodeValidator.normalize(data);
+            const parsed = JSON.parse(validationResult.normalizedContent);
+            // Validate required fields
+            if (!parsed.id || !parsed.type || !parsed.metadata) {
+                throw new Error('Invalid element data: missing required fields');
+            }
+            // Update properties
+            this.id = parsed.id;
+            this.type = parsed.type;
+            this.version = parsed.version || '1.0.0';
+            this.metadata = parsed.metadata;
+            this.references = parsed.references || [];
+            this.extensions = parsed.extensions || {};
+            this.ratings = parsed.ratings;
+            this._isDirty = false;
+        }
+        catch (error) {
+            logger.error('Failed to deserialize element', { error, data });
+            throw new Error(`Failed to deserialize element: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Process user feedback and update ratings.
+     */
+    receiveFeedback(feedback, context) {
+        // Normalize Unicode input to prevent security issues
+        const validationResult = UnicodeValidator.normalize(feedback);
+        const normalizedFeedback = validationResult.normalizedContent;
+        // Log security event for feedback processing
+        SecurityMonitor.logSecurityEvent({
+            type: 'CONTENT_INJECTION_ATTEMPT',
+            severity: 'LOW',
+            source: 'BaseElement.receiveFeedback',
+            details: `Feedback processed for element ${this.type}:${this.id}`,
+            additionalData: {
+                elementType: this.type,
+                elementId: this.id,
+                feedbackLength: feedback.length,
+                hasUnicodeIssues: !validationResult.isValid
+            }
+        });
+        if (!this.ratings) {
+            this.ratings = {
+                aiRating: 0,
+                userRating: undefined,
+                ratingCount: 0,
+                lastEvaluated: new Date(),
+                confidence: 0,
+                trend: 'stable',
+                feedbackHistory: []
+            };
+        }
+        // Create feedback entry with normalized content
+        const userFeedback = {
+            timestamp: new Date(),
+            feedback: normalizedFeedback,
+            sentiment: this.analyzeSentiment(normalizedFeedback),
+            inferredRating: this.inferRating(normalizedFeedback),
+            context,
+            elementVersion: this.version
+        };
+        // Add to history with bounds checking
+        if (!this.ratings.feedbackHistory) {
+            this.ratings.feedbackHistory = [];
+        }
+        this.ratings.feedbackHistory.push(userFeedback);
+        // Prevent unbounded growth
+        if (this.ratings.feedbackHistory.length > this.MAX_FEEDBACK_HISTORY) {
+            this.ratings.feedbackHistory = this.ratings.feedbackHistory.slice(-this.MAX_FEEDBACK_HISTORY);
+            logger.debug(`Feedback history trimmed to ${this.MAX_FEEDBACK_HISTORY} entries for element ${this.id}`);
+        }
+        // Update user rating if we inferred one
+        if (userFeedback.inferredRating !== undefined) {
+            this.updateUserRating(userFeedback.inferredRating);
+        }
+        this._isDirty = true;
+    }
+    /**
+     * Simple sentiment analysis.
+     * Subclasses can override for more sophisticated analysis.
+     */
+    analyzeSentiment(feedback) {
+        const lower = feedback.toLowerCase();
+        const positiveWords = ['excellent', 'great', 'good', 'helpful', 'useful', 'perfect', 'amazing', 'love'];
+        const negativeWords = ['bad', 'poor', 'terrible', 'useless', 'broken', 'hate', 'awful', 'disappointing'];
+        const positiveCount = positiveWords.filter(word => lower.includes(word)).length;
+        const negativeCount = negativeWords.filter(word => lower.includes(word)).length;
+        if (positiveCount > negativeCount)
+            return 'positive';
+        if (negativeCount > positiveCount)
+            return 'negative';
+        return 'neutral';
+    }
+    /**
+     * Simple rating inference from feedback.
+     * Subclasses can override for more sophisticated inference.
+     */
+    inferRating(feedback) {
+        const sentiment = this.analyzeSentiment(feedback);
+        const lower = feedback.toLowerCase();
+        // Look for explicit ratings
+        const ratingMatch = lower.match(/(\d+)\s*(stars?|\/5|out of 5)/);
+        if (ratingMatch) {
+            const rating = parseInt(ratingMatch[1]);
+            if (rating >= 1 && rating <= 5)
+                return rating;
+        }
+        // Infer from sentiment
+        if (sentiment === 'positive') {
+            if (lower.includes('perfect') || lower.includes('excellent'))
+                return 5;
+            if (lower.includes('great') || lower.includes('very good'))
+                return 4;
+            return 4;
+        }
+        else if (sentiment === 'negative') {
+            if (lower.includes('terrible') || lower.includes('awful'))
+                return 1;
+            if (lower.includes('poor') || lower.includes('bad'))
+                return 2;
+            return 2;
+        }
+        return 3; // Neutral
+    }
+    /**
+     * Update user rating with a new value.
+     */
+    updateUserRating(newRating) {
+        if (!this.ratings)
+            return;
+        if (this.ratings.userRating === undefined) {
+            this.ratings.userRating = newRating;
+            this.ratings.ratingCount = 1;
+        }
+        else {
+            // Calculate running average
+            const totalRating = this.ratings.userRating * this.ratings.ratingCount + newRating;
+            this.ratings.ratingCount++;
+            this.ratings.userRating = totalRating / this.ratings.ratingCount;
+        }
+        // Update delta and trend
+        this.ratings.ratingDelta = this.ratings.userRating - this.ratings.aiRating;
+        // Simple trend calculation based on recent feedback
+        const recentFeedback = this.ratings.feedbackHistory?.slice(-5) || [];
+        const recentSentiments = recentFeedback.map(f => f.sentiment);
+        const positiveCount = recentSentiments.filter(s => s === 'positive').length;
+        const negativeCount = recentSentiments.filter(s => s === 'negative').length;
+        if (positiveCount > negativeCount + 1) {
+            this.ratings.trend = 'improving';
+        }
+        else if (negativeCount > positiveCount + 1) {
+            this.ratings.trend = 'declining';
+        }
+        else {
+            this.ratings.trend = 'stable';
+        }
+    }
+    /**
+     * Get current element status.
+     */
+    getStatus() {
+        return this._status;
+    }
+    /**
+     * Default lifecycle methods - subclasses should override as needed.
+     */
+    async beforeActivate() {
+        logger.debug(`Preparing to activate ${this.type} element: ${this.metadata.name}`);
+        this._status = ElementStatus.ACTIVATING;
+    }
+    async activate() {
+        logger.info(`Activating ${this.type} element: ${this.metadata.name}`);
+        this._status = ElementStatus.ACTIVE;
+    }
+    async afterActivate() {
+        logger.debug(`Completed activation of ${this.type} element: ${this.metadata.name}`);
+    }
+    async deactivate() {
+        logger.info(`Deactivating ${this.type} element: ${this.metadata.name}`);
+        this._status = ElementStatus.DEACTIVATING;
+        // Subclasses should implement cleanup logic
+        this._status = ElementStatus.INACTIVE;
+    }
+    /**
+     * Mark element as modified.
+     */
+    markDirty() {
+        this._isDirty = true;
+        this.metadata.modified = new Date().toISOString();
+    }
+    /**
+     * Check if element has unsaved changes.
+     */
+    isDirty() {
+        return this._isDirty;
+    }
+    /**
+     * Mark element as saved.
+     */
+    markClean() {
+        this._isDirty = false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BaseElement.js","sourceRoot":"","sources":["../../../../src/elements/BaseElement.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Base abstract class implementing IElement interface.\n * Provides common functionality that all element types can extend.\n */\n\nimport {\n  IElement,\n  IElementMetadata,\n  ElementStatus,\n  ElementRatings,\n  Reference,\n  ElementValidationResult,\n  ValidationError,\n  ValidationWarning,\n  FeedbackContext,\n  UserFeedback\n} from '../types/elements/index.js';\nimport { ElementType } from '../portfolio/types.js';\nimport { v4 as uuidv4 } from 'uuid';\nimport { logger } from '../utils/logger.js';\nimport { UnicodeValidator } from '../security/validators/unicodeValidator.js';\nimport { SecurityMonitor } from '../security/securityMonitor.js';\n\nexport abstract class BaseElement implements IElement {\n  // Identity\n  public id: string;\n  public type: ElementType;\n  public version: string;\n  \n  // Metadata\n  public metadata: IElementMetadata;\n  \n  // Features\n  public references?: Reference[];\n  public extensions?: Record<string, any>;\n  public ratings?: ElementRatings;\n  \n  // Internal state\n  protected _status: ElementStatus = ElementStatus.INACTIVE;\n  protected _isDirty: boolean = false;\n  \n  // Constants\n  private readonly MAX_FEEDBACK_HISTORY = 100;\n  \n  constructor(type: ElementType, metadata: Partial<IElementMetadata> = {}) {\n    this.type = type;\n    this.id = metadata.name ? this.generateId(metadata.name) : uuidv4();\n    this.version = metadata.version || '1.0.0';\n    \n    // Initialize metadata with defaults\n    this.metadata = {\n      name: metadata.name || 'Unnamed Element',\n      description: metadata.description || '',\n      author: metadata.author,\n      version: this.version,\n      created: metadata.created || new Date().toISOString(),\n      modified: metadata.modified || new Date().toISOString(),\n      tags: metadata.tags || [],\n      dependencies: metadata.dependencies || [],\n      custom: metadata.custom || {}\n    };\n    \n    // Initialize optional features\n    this.references = [];\n    this.extensions = {};\n    this.ratings = {\n      aiRating: 0,\n      userRating: undefined,\n      ratingCount: 0,\n      lastEvaluated: new Date(),\n      confidence: 0,\n      trend: 'stable',\n      feedbackHistory: []\n    };\n  }\n  \n  /**\n   * Generate a unique ID for the element based on its name and type.\n   * Format: type_name-slug_timestamp\n   */\n  protected generateId(name: string): string {\n    const typeSlug = this.type.toLowerCase();\n    const nameSlug = name\n      .toLowerCase()\n      .replace(/[^a-z0-9]+/g, '-')\n      .replace(/^-|-$/g, '');\n    const timestamp = Date.now();\n    \n    return `${typeSlug}_${nameSlug}_${timestamp}`;\n  }\n  \n  /**\n   * Core validation that all elements share.\n   * Subclasses should override and call super.validate() first.\n   */\n  public validate(): ElementValidationResult {\n    // Log security-relevant validation event\n    SecurityMonitor.logSecurityEvent({\n      type: 'YAML_PARSE_SUCCESS',\n      severity: 'LOW',\n      source: 'BaseElement.validate',\n      details: `Element validation performed for ${this.type}:${this.id}`,\n      additionalData: { elementType: this.type, elementId: this.id }\n    });\n    \n    const errors: ValidationError[] = [];\n    const warnings: ValidationWarning[] = [];\n    const suggestions: string[] = [];\n    \n    // Validate required fields\n    if (!this.id) {\n      errors.push({ field: 'id', message: 'Element ID is required' });\n    }\n    \n    if (!this.metadata.name || this.metadata.name.trim() === '') {\n      errors.push({ field: 'metadata.name', message: 'Element name is required' });\n    }\n    \n    if (!this.metadata.description || this.metadata.description.trim() === '') {\n      warnings.push({ \n        field: 'metadata.description', \n        message: 'Element description is recommended',\n        severity: 'medium'\n      });\n    }\n    \n    // Validate version format (semver)\n    const semverRegex = /^\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9.-]+)?(\\+[a-zA-Z0-9.-]+)?$/;\n    if (!semverRegex.test(this.version)) {\n      errors.push({ \n        field: 'version', \n        message: 'Version must follow semantic versioning (e.g., 1.0.0)',\n        code: 'INVALID_VERSION_FORMAT'\n      });\n    }\n    \n    // Validate references\n    if (this.references) {\n      this.references.forEach((ref, index) => {\n        if (!ref.uri || ref.uri.trim() === '') {\n          errors.push({ \n            field: `references[${index}].uri`, \n            message: 'Reference URI is required' \n          });\n        }\n        if (!ref.title || ref.title.trim() === '') {\n          warnings.push({ \n            field: `references[${index}].title`, \n            message: 'Reference title is recommended',\n            severity: 'low'\n          });\n        }\n      });\n    }\n    \n    // Validate ratings if present\n    if (this.ratings) {\n      if (this.ratings.aiRating < 0 || this.ratings.aiRating > 5) {\n        errors.push({ \n          field: 'ratings.aiRating', \n          message: 'AI rating must be between 0 and 5' \n        });\n      }\n      if (this.ratings.userRating !== undefined && \n          (this.ratings.userRating < 0 || this.ratings.userRating > 5)) {\n        errors.push({ \n          field: 'ratings.userRating', \n          message: 'User rating must be between 0 and 5' \n        });\n      }\n    }\n    \n    // Add suggestions\n    if (!this.metadata.tags || this.metadata.tags.length === 0) {\n      suggestions.push('Consider adding tags to improve discoverability');\n    }\n    \n    if (!this.metadata.author) {\n      suggestions.push('Consider adding author information');\n    }\n    \n    return {\n      valid: errors.length === 0,\n      errors: errors.length > 0 ? errors : undefined,\n      warnings: warnings.length > 0 ? warnings : undefined,\n      suggestions: suggestions.length > 0 ? suggestions : undefined\n    };\n  }\n  \n  /**\n   * Default serialization to JSON.\n   * Subclasses can override for custom formats.\n   */\n  public serialize(): string {\n    const data = {\n      id: this.id,\n      type: this.type,\n      version: this.version,\n      metadata: this.metadata,\n      references: this.references,\n      extensions: this.extensions,\n      ratings: this.ratings\n    };\n    \n    return JSON.stringify(data, null, 2);\n  }\n  \n  /**\n   * Default deserialization from JSON.\n   * Subclasses can override for custom formats.\n   */\n  public deserialize(data: string): void {\n    try {\n      // Normalize Unicode input before parsing\n      const validationResult = UnicodeValidator.normalize(data);\n      const parsed = JSON.parse(validationResult.normalizedContent);\n      \n      // Validate required fields\n      if (!parsed.id || !parsed.type || !parsed.metadata) {\n        throw new Error('Invalid element data: missing required fields');\n      }\n      \n      // Update properties\n      this.id = parsed.id;\n      this.type = parsed.type;\n      this.version = parsed.version || '1.0.0';\n      this.metadata = parsed.metadata;\n      this.references = parsed.references || [];\n      this.extensions = parsed.extensions || {};\n      this.ratings = parsed.ratings;\n      \n      this._isDirty = false;\n    } catch (error) {\n      logger.error('Failed to deserialize element', { error, data });\n      throw new Error(`Failed to deserialize element: ${error instanceof Error ? error.message : 'Unknown error'}`);\n    }\n  }\n  \n  /**\n   * Process user feedback and update ratings.\n   */\n  public receiveFeedback(feedback: string, context?: FeedbackContext): void {\n    // Normalize Unicode input to prevent security issues\n    const validationResult = UnicodeValidator.normalize(feedback);\n    const normalizedFeedback = validationResult.normalizedContent;\n    \n    // Log security event for feedback processing\n    SecurityMonitor.logSecurityEvent({\n      type: 'CONTENT_INJECTION_ATTEMPT',\n      severity: 'LOW',\n      source: 'BaseElement.receiveFeedback',\n      details: `Feedback processed for element ${this.type}:${this.id}`,\n      additionalData: { \n        elementType: this.type, \n        elementId: this.id,\n        feedbackLength: feedback.length,\n        hasUnicodeIssues: !validationResult.isValid\n      }\n    });\n    \n    if (!this.ratings) {\n      this.ratings = {\n        aiRating: 0,\n        userRating: undefined,\n        ratingCount: 0,\n        lastEvaluated: new Date(),\n        confidence: 0,\n        trend: 'stable',\n        feedbackHistory: []\n      };\n    }\n    \n    // Create feedback entry with normalized content\n    const userFeedback: UserFeedback = {\n      timestamp: new Date(),\n      feedback: normalizedFeedback,\n      sentiment: this.analyzeSentiment(normalizedFeedback),\n      inferredRating: this.inferRating(normalizedFeedback),\n      context,\n      elementVersion: this.version\n    };\n    \n    // Add to history with bounds checking\n    if (!this.ratings.feedbackHistory) {\n      this.ratings.feedbackHistory = [];\n    }\n    this.ratings.feedbackHistory.push(userFeedback);\n    \n    // Prevent unbounded growth\n    if (this.ratings.feedbackHistory.length > this.MAX_FEEDBACK_HISTORY) {\n      this.ratings.feedbackHistory = this.ratings.feedbackHistory.slice(-this.MAX_FEEDBACK_HISTORY);\n      logger.debug(`Feedback history trimmed to ${this.MAX_FEEDBACK_HISTORY} entries for element ${this.id}`);\n    }\n    \n    // Update user rating if we inferred one\n    if (userFeedback.inferredRating !== undefined) {\n      this.updateUserRating(userFeedback.inferredRating);\n    }\n    \n    this._isDirty = true;\n  }\n  \n  /**\n   * Simple sentiment analysis.\n   * Subclasses can override for more sophisticated analysis.\n   */\n  protected analyzeSentiment(feedback: string): 'positive' | 'negative' | 'neutral' {\n    const lower = feedback.toLowerCase();\n    \n    const positiveWords = ['excellent', 'great', 'good', 'helpful', 'useful', 'perfect', 'amazing', 'love'];\n    const negativeWords = ['bad', 'poor', 'terrible', 'useless', 'broken', 'hate', 'awful', 'disappointing'];\n    \n    const positiveCount = positiveWords.filter(word => lower.includes(word)).length;\n    const negativeCount = negativeWords.filter(word => lower.includes(word)).length;\n    \n    if (positiveCount > negativeCount) return 'positive';\n    if (negativeCount > positiveCount) return 'negative';\n    return 'neutral';\n  }\n  \n  /**\n   * Simple rating inference from feedback.\n   * Subclasses can override for more sophisticated inference.\n   */\n  protected inferRating(feedback: string): number | undefined {\n    const sentiment = this.analyzeSentiment(feedback);\n    const lower = feedback.toLowerCase();\n    \n    // Look for explicit ratings\n    const ratingMatch = lower.match(/(\\d+)\\s*(stars?|\\/5|out of 5)/);\n    if (ratingMatch) {\n      const rating = parseInt(ratingMatch[1]);\n      if (rating >= 1 && rating <= 5) return rating;\n    }\n    \n    // Infer from sentiment\n    if (sentiment === 'positive') {\n      if (lower.includes('perfect') || lower.includes('excellent')) return 5;\n      if (lower.includes('great') || lower.includes('very good')) return 4;\n      return 4;\n    } else if (sentiment === 'negative') {\n      if (lower.includes('terrible') || lower.includes('awful')) return 1;\n      if (lower.includes('poor') || lower.includes('bad')) return 2;\n      return 2;\n    }\n    \n    return 3; // Neutral\n  }\n  \n  /**\n   * Update user rating with a new value.\n   */\n  protected updateUserRating(newRating: number): void {\n    if (!this.ratings) return;\n    \n    if (this.ratings.userRating === undefined) {\n      this.ratings.userRating = newRating;\n      this.ratings.ratingCount = 1;\n    } else {\n      // Calculate running average\n      const totalRating = this.ratings.userRating * this.ratings.ratingCount + newRating;\n      this.ratings.ratingCount++;\n      this.ratings.userRating = totalRating / this.ratings.ratingCount;\n    }\n    \n    // Update delta and trend\n    this.ratings.ratingDelta = this.ratings.userRating - this.ratings.aiRating;\n    \n    // Simple trend calculation based on recent feedback\n    const recentFeedback = this.ratings.feedbackHistory?.slice(-5) || [];\n    const recentSentiments = recentFeedback.map(f => f.sentiment);\n    const positiveCount = recentSentiments.filter(s => s === 'positive').length;\n    const negativeCount = recentSentiments.filter(s => s === 'negative').length;\n    \n    if (positiveCount > negativeCount + 1) {\n      this.ratings.trend = 'improving';\n    } else if (negativeCount > positiveCount + 1) {\n      this.ratings.trend = 'declining';\n    } else {\n      this.ratings.trend = 'stable';\n    }\n  }\n  \n  /**\n   * Get current element status.\n   */\n  public getStatus(): ElementStatus {\n    return this._status;\n  }\n  \n  /**\n   * Default lifecycle methods - subclasses should override as needed.\n   */\n  public async beforeActivate(): Promise<void> {\n    logger.debug(`Preparing to activate ${this.type} element: ${this.metadata.name}`);\n    this._status = ElementStatus.ACTIVATING;\n  }\n  \n  public async activate(): Promise<void> {\n    logger.info(`Activating ${this.type} element: ${this.metadata.name}`);\n    this._status = ElementStatus.ACTIVE;\n  }\n  \n  public async afterActivate(): Promise<void> {\n    logger.debug(`Completed activation of ${this.type} element: ${this.metadata.name}`);\n  }\n  \n  public async deactivate(): Promise<void> {\n    logger.info(`Deactivating ${this.type} element: ${this.metadata.name}`);\n    this._status = ElementStatus.DEACTIVATING;\n    // Subclasses should implement cleanup logic\n    this._status = ElementStatus.INACTIVE;\n  }\n  \n  /**\n   * Mark element as modified.\n   */\n  protected markDirty(): void {\n    this._isDirty = true;\n    this.metadata.modified = new Date().toISOString();\n  }\n  \n  /**\n   * Check if element has unsaved changes.\n   */\n  public isDirty(): boolean {\n    return this._isDirty;\n  }\n  \n  /**\n   * Mark element as saved.\n   */\n  public markClean(): void {\n    this._isDirty = false;\n  }\n}"]}

package/dist/test/src/elements/FeedbackProcessor.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Natural language feedback processor for extracting ratings and insights from user feedback.
+ */
+import { IFeedbackProcessor, ProcessedFeedback } from '../types/elements/index.js';
+export declare class FeedbackProcessor implements IFeedbackProcessor {
+    private readonly MAX_FEEDBACK_LENGTH;
+    private readonly suggestionPatterns;
+    private readonly sentimentPatterns;
+    private readonly featureKeywords;
+    private readonly issueKeywords;
+    constructor();
+    /**
+     * Process natural language feedback into structured data.
+     */
+    process(feedback: string): Promise<ProcessedFeedback>;
+    /**
+     * Analyze sentiment from text.
+     */
+    analyzeSentiment(text: string): Promise<'positive' | 'negative' | 'neutral'>;
+    /**
+     * Infer numeric rating from text.
+     */
+    inferRating(text: string): Promise<number | null>;
+    /**
+     * Extract improvement suggestions from feedback.
+     */
+    extractSuggestions(text: string): Promise<string[]>;
+    /**
+     * Extract entities (features, issues, etc.) from feedback.
+     */
+    private extractEntities;
+    /**
+     * Extract meaningful keywords from feedback.
+     */
+    private extractKeywords;
+    /**
+     * Calculate pattern weight based on context.
+     */
+    private getPatternWeight;
+    /**
+     * Calculate relevance of a keyword in context.
+     */
+    private calculateRelevance;
+    /**
+     * Calculate confidence in the analysis.
+     */
+    private calculateConfidence;
+    /**
+     * Calculate how strongly sentiment is expressed.
+     */
+    private calculateSentimentStrength;
+    /**
+     * Capitalize first letter of sentence.
+     */
+    private capitalizeSentence;
+}
+//# sourceMappingURL=FeedbackProcessor.d.ts.map

package/dist/test/src/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"}