@dollhousemcp/mcp-server 1.3.0 → 1.3.2

package/dist/test/src/elements/skills/Skill.d.ts

@@ -1,109 +0,0 @@
-/**
- * Skill element class implementing IElement interface.
- * Represents a discrete capability for specific tasks.
- *
- * SECURITY FIXES IMPLEMENTED (PR #319):
- * 1. CRITICAL: Added comprehensive input validation for all skill parameters
- * 2. MEDIUM: Implemented Unicode normalization to prevent homograph attacks
- * 3. MEDIUM: Added audit logging for security events via SecurityMonitor
- * 4. MEDIUM: Implemented memory management to prevent unbounded growth
- * 5. MEDIUM: Added XSS protection through input sanitization
- */
-import { BaseElement } from '../BaseElement.js';
-import { IElement, IElementMetadata, ElementValidationResult } from '../../types/elements/index.js';
-export interface SkillMetadata extends IElementMetadata {
-    languages?: string[];
-    complexity?: 'beginner' | 'intermediate' | 'advanced' | 'expert';
-    domains?: string[];
-    prerequisites?: string[];
-    parameters?: SkillParameter[];
-    examples?: SkillExample[];
-    certification?: string;
-    proficiency_level?: number;
-}
-export interface SkillParameter {
-    name: string;
-    type: 'string' | 'number' | 'boolean' | 'enum';
-    description: string;
-    required?: boolean;
-    default?: any;
-    options?: string[];
-    min?: number;
-    max?: number;
-}
-export interface SkillExample {
-    title: string;
-    description: string;
-    input?: any;
-    output?: any;
-    code?: string;
-}
-export declare class Skill extends BaseElement implements IElement {
-    metadata: SkillMetadata;
-    instructions: string;
-    parameters: Map<string, any>;
-    private readonly MAX_PARAMETER_COUNT;
-    private readonly MAX_PARAMETER_SIZE;
-    constructor(metadata: Partial<SkillMetadata>, instructions?: string);
-    /**
-     * Initialize parameters with default values
-     */
-    private initializeParameters;
-    /**
-     * Set a parameter value
-     * SECURITY FIX #1: Comprehensive input validation for all skill parameters
-     * Previously: Parameters were set without validation, creating security risks
-     * Now: Full validation pipeline including sanitization, type checking, and size limits
-     */
-    setParameter(name: string, value: any): void;
-    /**
-     * Get a parameter value
-     */
-    getParameter(name: string): any;
-    /**
-     * Get all parameters as object
-     */
-    getAllParameters(): Record<string, any>;
-    /**
-     * Validate parameter value against its definition
-     */
-    private validateParameterValue;
-    /**
-     * Execute the skill with current parameters
-     */
-    execute(input?: any): Promise<any>;
-    /**
-     * Skill-specific validation
-     */
-    validate(): ElementValidationResult;
-    /**
-     * Serialize skill to JSON format
-     */
-    serialize(): string;
-    /**
-     * Deserialize skill from JSON format
-     */
-    deserialize(data: string): void;
-    /**
-     * Skill activation lifecycle
-     */
-    activate(): Promise<void>;
-    /**
-     * Clone the skill with different parameters
-     */
-    clone(newParameters?: Record<string, any>): Skill;
-    /**
-     * Skill deactivation lifecycle
-     * SECURITY FIX #4: Automatically clears parameters on deactivation
-     * to prevent memory leaks in long-running processes
-     */
-    deactivate(): Promise<void>;
-    /**
-     * Clear all parameters (for memory management)
-     * SECURITY FIX #4: Added method to clear parameters and prevent memory leaks
-     * Previously: Parameters accumulated indefinitely in long-running processes
-     * Now: Provides explicit cleanup mechanism called during deactivation
-     */
-    clearParameters(): void;
-}
-//# sourceMappingURL=Skill.d.ts.map

package/dist/test/src/elements/skills/Skill.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Skill.d.ts","sourceRoot":"","sources":["../../../../../src/elements/skills/Skill.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAQpG,MAAM,WAAW,aAAc,SAAQ,gBAAgB;IACrD,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,UAAU,CAAC,EAAE,UAAU,GAAG,cAAc,GAAG,UAAU,GAAG,QAAQ,CAAC;IACjE,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,UAAU,CAAC,EAAE,cAAc,EAAE,CAAC;IAC9B,QAAQ,CAAC,EAAE,YAAY,EAAE,CAAC;IAC1B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,CAAC;IAC/C,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,GAAG,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,GAAG,CAAC;IACZ,MAAM,CAAC,EAAE,GAAG,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,qBAAa,KAAM,SAAQ,WAAY,YAAW,QAAQ;IACzC,QAAQ,EAAE,aAAa,CAAC;IAChC,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAa;IAKhD,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAO;IAC3C,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;gBAEhC,QAAQ,EAAE,OAAO,CAAC,aAAa,CAAC,EAAE,YAAY,GAAE,MAAW;IA0CvE;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAU5B;;;;;OAKG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,IAAI;IA0E5C;;OAEG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG;IAI/B;;OAEG;IACH,gBAAgB,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAIvC;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAmB9B;;OAEG;IACG,OAAO,CAAC,KAAK,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;IAwBxC;;OAEG;IACa,QAAQ,IAAI,uBAAuB;IAiFnD;;OAEG;IACa,SAAS,IAAI,MAAM;IAgBnC;;OAEG;IACa,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAkC/C;;OAEG;IACmB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAY/C;;OAEG;IACH,KAAK,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,KAAK;IAkBjD;;;;OAIG;IACmB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAUjD;;;;;OAKG;IACH,eAAe,IAAI,IAAI;CAIxB"}

package/dist/test/src/elements/skills/Skill.js

@@ -1,381 +0,0 @@
-/**
- * Skill element class implementing IElement interface.
- * Represents a discrete capability for specific tasks.
- *
- * SECURITY FIXES IMPLEMENTED (PR #319):
- * 1. CRITICAL: Added comprehensive input validation for all skill parameters
- * 2. MEDIUM: Implemented Unicode normalization to prevent homograph attacks
- * 3. MEDIUM: Added audit logging for security events via SecurityMonitor
- * 4. MEDIUM: Implemented memory management to prevent unbounded growth
- * 5. MEDIUM: Added XSS protection through input sanitization
- */
-import { BaseElement } from '../BaseElement.js';
-import { ElementType } from '../../portfolio/types.js';
-import { logger } from '../../utils/logger.js';
-import { sanitizeInput } from '../../security/InputValidator.js';
-import { UnicodeValidator } from '../../security/validators/unicodeValidator.js';
-import { SecurityMonitor } from '../../security/securityMonitor.js';
-export class Skill extends BaseElement {
-    instructions;
-    parameters = new Map();
-    // SECURITY FIX #4: Memory management constants to prevent unbounded growth
-    // Previously: No limits on parameter storage, could lead to memory exhaustion
-    // Now: Enforced limits on both count and size
-    MAX_PARAMETER_COUNT = 100;
-    MAX_PARAMETER_SIZE = 10000; // Max size per parameter value
-    constructor(metadata, instructions = '') {
-        // SECURITY FIX #2: Validate and sanitize ALL metadata fields
-        // Previously: metadata was used directly without validation
-        // Now: All string inputs are Unicode normalized and sanitized to prevent:
-        // - XSS attacks through malicious metadata
-        // - Unicode homograph attacks
-        // - Buffer overflow attempts
-        const sanitizedMetadata = {
-            ...metadata,
-            name: metadata.name ? sanitizeInput(UnicodeValidator.normalize(metadata.name).normalizedContent, 100) : undefined,
-            description: metadata.description ? sanitizeInput(UnicodeValidator.normalize(metadata.description).normalizedContent, 500) : undefined
-        };
-        super(ElementType.SKILL, sanitizedMetadata);
-        this.instructions = instructions ? sanitizeInput(UnicodeValidator.normalize(instructions).normalizedContent, 10000) : '';
-        // Ensure skill-specific metadata
-        this.metadata = {
-            ...this.metadata,
-            languages: metadata.languages || [],
-            complexity: metadata.complexity || 'beginner',
-            domains: metadata.domains || [],
-            prerequisites: metadata.prerequisites || [],
-            parameters: metadata.parameters || [],
-            examples: metadata.examples || [],
-            proficiency_level: metadata.proficiency_level || 0
-        };
-        // Validate parameter definitions
-        if (this.metadata.parameters) {
-            this.metadata.parameters = this.metadata.parameters.map(param => ({
-                ...param,
-                name: sanitizeInput(UnicodeValidator.normalize(param.name).normalizedContent, 50),
-                description: sanitizeInput(UnicodeValidator.normalize(param.description).normalizedContent, 200),
-                options: param.options?.map(opt => sanitizeInput(opt, 100))
-            }));
-        }
-        // Initialize parameter values with defaults
-        this.initializeParameters();
-    }
-    /**
-     * Initialize parameters with default values
-     */
-    initializeParameters() {
-        if (this.metadata.parameters) {
-            this.metadata.parameters.forEach(param => {
-                if (param.default !== undefined) {
-                    this.parameters.set(param.name, param.default);
-                }
-            });
-        }
-    }
-    /**
-     * Set a parameter value
-     * SECURITY FIX #1: Comprehensive input validation for all skill parameters
-     * Previously: Parameters were set without validation, creating security risks
-     * Now: Full validation pipeline including sanitization, type checking, and size limits
-     */
-    setParameter(name, value) {
-        // CRITICAL FIX: Sanitize parameter name to prevent injection attacks
-        const sanitizedName = sanitizeInput(name, 50);
-        const param = this.metadata.parameters?.find(p => p.name === sanitizedName);
-        if (!param) {
-            // SECURITY FIX #3: Log audit events for security monitoring
-            // This helps detect potential attack patterns or misconfigurations
-            SecurityMonitor.logSecurityEvent({
-                type: 'YAML_PARSING_WARNING',
-                severity: 'MEDIUM',
-                source: 'Skill.setParameter',
-                details: `Attempt to set unknown parameter: ${sanitizedName} for skill: ${this.metadata.name}`
-            });
-            throw new Error(`Parameter '${sanitizedName}' not found in skill definition`);
-        }
-        // CRITICAL FIX: Sanitize and validate the value based on type
-        let sanitizedValue = value;
-        if (param.type === 'string') {
-            // SECURITY FIX #2 & #5: Normalize Unicode and sanitize string values
-            // Previously: String values were used directly without validation
-            // Now: Full validation pipeline:
-            // 1. Unicode normalization prevents homograph attacks
-            // 2. sanitizeInput() strips dangerous HTML/JS content
-            // 3. Length limits prevent buffer overflow attacks
-            const normalized = UnicodeValidator.normalize(String(value));
-            sanitizedValue = sanitizeInput(normalized.normalizedContent, param.max || 1000);
-            // SECURITY FIX #5: Additional XSS protection
-            // Check for common XSS patterns even after sanitization
-            // This provides defense-in-depth against sophisticated attacks
-            if (sanitizedValue.includes('<script') || sanitizedValue.includes('javascript:')) {
-                // SECURITY FIX #3: Log high-severity security events
-                SecurityMonitor.logSecurityEvent({
-                    type: 'CONTENT_INJECTION_ATTEMPT',
-                    severity: 'HIGH',
-                    source: 'Skill.setParameter',
-                    details: `Potential XSS attempt in skill parameter: ${sanitizedName} for skill: ${this.metadata.name}`
-                });
-                throw new Error('Invalid characters in parameter value');
-            }
-        }
-        // Type validation
-        if (!this.validateParameterValue(param, sanitizedValue)) {
-            throw new Error(`Invalid value for parameter '${sanitizedName}': expected ${param.type}`);
-        }
-        // SECURITY FIX #4: Memory management - check parameter count
-        // Previously: No limits on parameter storage, could lead to memory exhaustion attacks
-        // Now: Enforced limits prevent attackers from consuming unlimited memory
-        if (this.parameters.size >= this.MAX_PARAMETER_COUNT && !this.parameters.has(sanitizedName)) {
-            // SECURITY FIX #3: Log rate limit violations for security monitoring
-            SecurityMonitor.logSecurityEvent({
-                type: 'RATE_LIMIT_EXCEEDED',
-                severity: 'MEDIUM',
-                source: 'Skill.setParameter',
-                details: `Parameter limit exceeded for skill: ${this.metadata.name}. Max: ${this.MAX_PARAMETER_COUNT}`
-            });
-            throw new Error(`Parameter limit exceeded. Maximum ${this.MAX_PARAMETER_COUNT} parameters allowed`);
-        }
-        // SECURITY FIX #4: Check parameter value size for strings
-        // This prevents attackers from storing massive strings that could exhaust memory
-        if (param.type === 'string' && sanitizedValue.length > this.MAX_PARAMETER_SIZE) {
-            throw new Error(`Parameter value too large. Maximum ${this.MAX_PARAMETER_SIZE} characters allowed`);
-        }
-        this.parameters.set(sanitizedName, sanitizedValue);
-        logger.debug(`Set parameter ${sanitizedName} = ${sanitizedValue} for skill ${this.metadata.name}`);
-    }
-    /**
-     * Get a parameter value
-     */
-    getParameter(name) {
-        return this.parameters.get(name);
-    }
-    /**
-     * Get all parameters as object
-     */
-    getAllParameters() {
-        return Object.fromEntries(this.parameters);
-    }
-    /**
-     * Validate parameter value against its definition
-     */
-    validateParameterValue(param, value) {
-        switch (param.type) {
-            case 'string':
-                return typeof value === 'string';
-            case 'number':
-                const num = Number(value);
-                if (isNaN(num))
-                    return false;
-                if (param.min !== undefined && num < param.min)
-                    return false;
-                if (param.max !== undefined && num > param.max)
-                    return false;
-                return true;
-            case 'boolean':
-                return typeof value === 'boolean';
-            case 'enum':
-                return param.options?.includes(String(value)) || false;
-            default:
-                return true;
-        }
-    }
-    /**
-     * Execute the skill with current parameters
-     */
-    async execute(input) {
-        logger.info(`Executing skill: ${this.metadata.name}`);
-        // Validate required parameters
-        const missingRequired = this.metadata.parameters
-            ?.filter(p => p.required && !this.parameters.has(p.name))
-            .map(p => p.name) || [];
-        if (missingRequired.length > 0) {
-            throw new Error(`Missing required parameters: ${missingRequired.join(', ')}`);
-        }
-        // Skills don't have built-in execution logic - this would be implemented
-        // by specific skill types or through a plugin system
-        logger.debug(`Skill ${this.metadata.name} executed with parameters:`, this.getAllParameters());
-        return {
-            skill: this.metadata.name,
-            parameters: this.getAllParameters(),
-            input,
-            executed_at: new Date().toISOString()
-        };
-    }
-    /**
-     * Skill-specific validation
-     */
-    validate() {
-        const result = super.validate();
-        // Initialize arrays if not present
-        if (!result.errors)
-            result.errors = [];
-        if (!result.warnings)
-            result.warnings = [];
-        // Instructions should not be empty
-        if (!this.instructions || this.instructions.trim().length === 0) {
-            result.errors.push({
-                field: 'instructions',
-                message: 'Skill instructions cannot be empty',
-                code: 'EMPTY_INSTRUCTIONS'
-            });
-        }
-        // Validate complexity level
-        const validComplexity = ['beginner', 'intermediate', 'advanced', 'expert'];
-        if (this.metadata.complexity && !validComplexity.includes(this.metadata.complexity)) {
-            result.errors.push({
-                field: 'complexity',
-                message: `Complexity must be one of: ${validComplexity.join(', ')}`,
-                code: 'INVALID_COMPLEXITY'
-            });
-        }
-        // Validate proficiency level
-        if (this.metadata.proficiency_level !== undefined) {
-            if (this.metadata.proficiency_level < 0 || this.metadata.proficiency_level > 100) {
-                result.errors.push({
-                    field: 'proficiency_level',
-                    message: 'Proficiency level must be between 0 and 100',
-                    code: 'INVALID_PROFICIENCY'
-                });
-            }
-        }
-        // Validate parameters
-        if (this.metadata.parameters) {
-            this.metadata.parameters.forEach((param, index) => {
-                if (!param.name || param.name.trim() === '') {
-                    result.errors.push({
-                        field: `parameters[${index}].name`,
-                        message: 'Parameter name is required',
-                        code: 'MISSING_PARAMETER_NAME'
-                    });
-                }
-                if (param.type === 'enum' && (!param.options || param.options.length === 0)) {
-                    result.errors.push({
-                        field: `parameters[${index}].options`,
-                        message: 'Enum parameter must have options defined',
-                        code: 'MISSING_ENUM_OPTIONS'
-                    });
-                }
-            });
-        }
-        // Warnings for best practices
-        if (!this.metadata.domains || this.metadata.domains.length === 0) {
-            result.warnings.push({
-                field: 'domains',
-                message: 'Consider adding domain categories for better organization',
-                severity: 'low'
-            });
-        }
-        if (!this.metadata.examples || this.metadata.examples.length === 0) {
-            result.warnings.push({
-                field: 'examples',
-                message: 'Adding usage examples improves skill usability',
-                severity: 'medium'
-            });
-        }
-        // Update the valid flag based on final errors
-        result.valid = (result.errors?.length || 0) === 0;
-        return result;
-    }
-    /**
-     * Serialize skill to JSON format
-     */
-    serialize() {
-        const data = {
-            id: this.id,
-            type: this.type,
-            version: this.version,
-            metadata: this.metadata,
-            instructions: this.instructions,
-            parameters: this.getAllParameters(),
-            references: this.references,
-            extensions: this.extensions,
-            ratings: this.ratings
-        };
-        return JSON.stringify(data, null, 2);
-    }
-    /**
-     * Deserialize skill from JSON format
-     */
-    deserialize(data) {
-        try {
-            const parsed = JSON.parse(data);
-            // Update metadata
-            this.metadata = { ...this.metadata, ...parsed.metadata };
-            // Update other properties
-            this.instructions = parsed.instructions || '';
-            this.references = parsed.references || [];
-            this.extensions = parsed.extensions || {};
-            this.ratings = parsed.ratings || this.ratings;
-            // Update ID and version if provided
-            if (parsed.id)
-                this.id = parsed.id;
-            if (parsed.version)
-                this.version = parsed.version;
-            // Restore parameters
-            if (parsed.parameters) {
-                this.parameters.clear();
-                Object.entries(parsed.parameters).forEach(([key, value]) => {
-                    this.parameters.set(key, value);
-                });
-            }
-            this._isDirty = true;
-            logger.debug(`Deserialized skill: ${this.metadata.name}`);
-        }
-        catch (error) {
-            logger.error(`Failed to deserialize skill: ${error}`);
-            throw new Error(`Deserialization failed: ${error}`);
-        }
-    }
-    /**
-     * Skill activation lifecycle
-     */
-    async activate() {
-        logger.info(`Activating skill: ${this.metadata.name} (${this.id})`);
-        // Validate that all required parameters are set
-        const validation = this.validate();
-        if (!validation.valid) {
-            throw new Error(`Cannot activate skill with validation errors: ${validation.errors?.map(e => e.message).join(', ')}`);
-        }
-        await super.activate?.();
-    }
-    /**
-     * Clone the skill with different parameters
-     */
-    clone(newParameters) {
-        const cloned = new Skill(this.metadata, this.instructions);
-        // Copy current parameters
-        this.parameters.forEach((value, key) => {
-            cloned.parameters.set(key, value);
-        });
-        // Override with new parameters if provided
-        if (newParameters) {
-            Object.entries(newParameters).forEach(([key, value]) => {
-                cloned.setParameter(key, value);
-            });
-        }
-        return cloned;
-    }
-    /**
-     * Skill deactivation lifecycle
-     * SECURITY FIX #4: Automatically clears parameters on deactivation
-     * to prevent memory leaks in long-running processes
-     */
-    async deactivate() {
-        logger.info(`Deactivating skill: ${this.metadata.name} (${this.id})`);
-        // SECURITY FIX #4: Clear parameters to free memory and prevent leaks
-        // This ensures skills don't retain data after deactivation
-        this.clearParameters();
-        await super.deactivate?.();
-    }
-    /**
-     * Clear all parameters (for memory management)
-     * SECURITY FIX #4: Added method to clear parameters and prevent memory leaks
-     * Previously: Parameters accumulated indefinitely in long-running processes
-     * Now: Provides explicit cleanup mechanism called during deactivation
-     */
-    clearParameters() {
-        this.parameters.clear();
-        logger.debug(`Cleared all parameters for skill: ${this.metadata.name}`);
-    }
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Skill.js","sourceRoot":"","sources":["../../../../../src/elements/skills/Skill.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Skill element class implementing IElement interface.\n * Represents a discrete capability for specific tasks.\n * \n * SECURITY FIXES IMPLEMENTED (PR #319):\n * 1. CRITICAL: Added comprehensive input validation for all skill parameters\n * 2. MEDIUM: Implemented Unicode normalization to prevent homograph attacks\n * 3. MEDIUM: Added audit logging for security events via SecurityMonitor\n * 4. MEDIUM: Implemented memory management to prevent unbounded growth\n * 5. MEDIUM: Added XSS protection through input sanitization\n */\n\nimport { BaseElement } from '../BaseElement.js';\nimport { IElement, IElementMetadata, ElementValidationResult } from '../../types/elements/index.js';\nimport { ElementType } from '../../portfolio/types.js';\nimport { logger } from '../../utils/logger.js';\nimport { sanitizeInput, validatePath } from '../../security/InputValidator.js';\nimport { UnicodeValidator } from '../../security/validators/unicodeValidator.js';\nimport { SecurityMonitor } from '../../security/securityMonitor.js';\n\n// Extend IElementMetadata with skill-specific fields\nexport interface SkillMetadata extends IElementMetadata {\n  languages?: string[];           // Programming/spoken languages this skill works with\n  complexity?: 'beginner' | 'intermediate' | 'advanced' | 'expert';\n  domains?: string[];             // Domain categories (e.g., web-dev, data-science, writing)\n  prerequisites?: string[];       // Required knowledge or other skills\n  parameters?: SkillParameter[];  // Configurable parameters\n  examples?: SkillExample[];      // Usage examples\n  certification?: string;         // External certification or validation\n  proficiency_level?: number;     // 1-100 proficiency level\n}\n\nexport interface SkillParameter {\n  name: string;\n  type: 'string' | 'number' | 'boolean' | 'enum';\n  description: string;\n  required?: boolean;\n  default?: any;\n  options?: string[];  // For enum type\n  min?: number;        // For number type\n  max?: number;        // For number type\n}\n\nexport interface SkillExample {\n  title: string;\n  description: string;\n  input?: any;\n  output?: any;\n  code?: string;\n}\n\nexport class Skill extends BaseElement implements IElement {\n  public declare metadata: SkillMetadata;\n  public instructions: string;\n  public parameters: Map<string, any> = new Map();\n  \n  // SECURITY FIX #4: Memory management constants to prevent unbounded growth\n  // Previously: No limits on parameter storage, could lead to memory exhaustion\n  // Now: Enforced limits on both count and size\n  private readonly MAX_PARAMETER_COUNT = 100;\n  private readonly MAX_PARAMETER_SIZE = 10000; // Max size per parameter value\n\n  constructor(metadata: Partial<SkillMetadata>, instructions: string = '') {\n    // SECURITY FIX #2: Validate and sanitize ALL metadata fields\n    // Previously: metadata was used directly without validation\n    // Now: All string inputs are Unicode normalized and sanitized to prevent:\n    // - XSS attacks through malicious metadata\n    // - Unicode homograph attacks\n    // - Buffer overflow attempts\n    const sanitizedMetadata = {\n      ...metadata,\n      name: metadata.name ? sanitizeInput(UnicodeValidator.normalize(metadata.name).normalizedContent, 100) : undefined,\n      description: metadata.description ? sanitizeInput(UnicodeValidator.normalize(metadata.description).normalizedContent, 500) : undefined\n    };\n    \n    super(ElementType.SKILL, sanitizedMetadata);\n    this.instructions = instructions ? sanitizeInput(UnicodeValidator.normalize(instructions).normalizedContent, 10000) : '';\n    \n    // Ensure skill-specific metadata\n    this.metadata = {\n      ...this.metadata,\n      languages: metadata.languages || [],\n      complexity: metadata.complexity || 'beginner',\n      domains: metadata.domains || [],\n      prerequisites: metadata.prerequisites || [],\n      parameters: metadata.parameters || [],\n      examples: metadata.examples || [],\n      proficiency_level: metadata.proficiency_level || 0\n    };\n\n    // Validate parameter definitions\n    if (this.metadata.parameters) {\n      this.metadata.parameters = this.metadata.parameters.map(param => ({\n        ...param,\n        name: sanitizeInput(UnicodeValidator.normalize(param.name).normalizedContent, 50),\n        description: sanitizeInput(UnicodeValidator.normalize(param.description).normalizedContent, 200),\n        options: param.options?.map(opt => sanitizeInput(opt, 100))\n      }));\n    }\n\n    // Initialize parameter values with defaults\n    this.initializeParameters();\n  }\n\n  /**\n   * Initialize parameters with default values\n   */\n  private initializeParameters(): void {\n    if (this.metadata.parameters) {\n      this.metadata.parameters.forEach(param => {\n        if (param.default !== undefined) {\n          this.parameters.set(param.name, param.default);\n        }\n      });\n    }\n  }\n\n  /**\n   * Set a parameter value\n   * SECURITY FIX #1: Comprehensive input validation for all skill parameters\n   * Previously: Parameters were set without validation, creating security risks\n   * Now: Full validation pipeline including sanitization, type checking, and size limits\n   */\n  setParameter(name: string, value: any): void {\n    // CRITICAL FIX: Sanitize parameter name to prevent injection attacks\n    const sanitizedName = sanitizeInput(name, 50);\n    \n    const param = this.metadata.parameters?.find(p => p.name === sanitizedName);\n    if (!param) {\n      // SECURITY FIX #3: Log audit events for security monitoring\n      // This helps detect potential attack patterns or misconfigurations\n      SecurityMonitor.logSecurityEvent({\n        type: 'YAML_PARSING_WARNING',\n        severity: 'MEDIUM',\n        source: 'Skill.setParameter',\n        details: `Attempt to set unknown parameter: ${sanitizedName} for skill: ${this.metadata.name}`\n      });\n      throw new Error(`Parameter '${sanitizedName}' not found in skill definition`);\n    }\n\n    // CRITICAL FIX: Sanitize and validate the value based on type\n    let sanitizedValue = value;\n    \n    if (param.type === 'string') {\n      // SECURITY FIX #2 & #5: Normalize Unicode and sanitize string values\n      // Previously: String values were used directly without validation\n      // Now: Full validation pipeline:\n      // 1. Unicode normalization prevents homograph attacks\n      // 2. sanitizeInput() strips dangerous HTML/JS content\n      // 3. Length limits prevent buffer overflow attacks\n      const normalized = UnicodeValidator.normalize(String(value));\n      sanitizedValue = sanitizeInput(normalized.normalizedContent, param.max || 1000);\n      \n      // SECURITY FIX #5: Additional XSS protection\n      // Check for common XSS patterns even after sanitization\n      // This provides defense-in-depth against sophisticated attacks\n      if (sanitizedValue.includes('<script') || sanitizedValue.includes('javascript:')) {\n        // SECURITY FIX #3: Log high-severity security events\n        SecurityMonitor.logSecurityEvent({\n          type: 'CONTENT_INJECTION_ATTEMPT',\n          severity: 'HIGH',\n          source: 'Skill.setParameter',\n          details: `Potential XSS attempt in skill parameter: ${sanitizedName} for skill: ${this.metadata.name}`\n        });\n        throw new Error('Invalid characters in parameter value');\n      }\n    }\n\n    // Type validation\n    if (!this.validateParameterValue(param, sanitizedValue)) {\n      throw new Error(`Invalid value for parameter '${sanitizedName}': expected ${param.type}`);\n    }\n\n    // SECURITY FIX #4: Memory management - check parameter count\n    // Previously: No limits on parameter storage, could lead to memory exhaustion attacks\n    // Now: Enforced limits prevent attackers from consuming unlimited memory\n    if (this.parameters.size >= this.MAX_PARAMETER_COUNT && !this.parameters.has(sanitizedName)) {\n      // SECURITY FIX #3: Log rate limit violations for security monitoring\n      SecurityMonitor.logSecurityEvent({\n        type: 'RATE_LIMIT_EXCEEDED',\n        severity: 'MEDIUM',\n        source: 'Skill.setParameter',\n        details: `Parameter limit exceeded for skill: ${this.metadata.name}. Max: ${this.MAX_PARAMETER_COUNT}`\n      });\n      throw new Error(`Parameter limit exceeded. Maximum ${this.MAX_PARAMETER_COUNT} parameters allowed`);\n    }\n    \n    // SECURITY FIX #4: Check parameter value size for strings\n    // This prevents attackers from storing massive strings that could exhaust memory\n    if (param.type === 'string' && sanitizedValue.length > this.MAX_PARAMETER_SIZE) {\n      throw new Error(`Parameter value too large. Maximum ${this.MAX_PARAMETER_SIZE} characters allowed`);\n    }\n\n    this.parameters.set(sanitizedName, sanitizedValue);\n    logger.debug(`Set parameter ${sanitizedName} = ${sanitizedValue} for skill ${this.metadata.name}`);\n  }\n\n  /**\n   * Get a parameter value\n   */\n  getParameter(name: string): any {\n    return this.parameters.get(name);\n  }\n\n  /**\n   * Get all parameters as object\n   */\n  getAllParameters(): Record<string, any> {\n    return Object.fromEntries(this.parameters);\n  }\n\n  /**\n   * Validate parameter value against its definition\n   */\n  private validateParameterValue(param: SkillParameter, value: any): boolean {\n    switch (param.type) {\n      case 'string':\n        return typeof value === 'string';\n      case 'number':\n        const num = Number(value);\n        if (isNaN(num)) return false;\n        if (param.min !== undefined && num < param.min) return false;\n        if (param.max !== undefined && num > param.max) return false;\n        return true;\n      case 'boolean':\n        return typeof value === 'boolean';\n      case 'enum':\n        return param.options?.includes(String(value)) || false;\n      default:\n        return true;\n    }\n  }\n\n  /**\n   * Execute the skill with current parameters\n   */\n  async execute(input?: any): Promise<any> {\n    logger.info(`Executing skill: ${this.metadata.name}`);\n    \n    // Validate required parameters\n    const missingRequired = this.metadata.parameters\n      ?.filter(p => p.required && !this.parameters.has(p.name))\n      .map(p => p.name) || [];\n    \n    if (missingRequired.length > 0) {\n      throw new Error(`Missing required parameters: ${missingRequired.join(', ')}`);\n    }\n\n    // Skills don't have built-in execution logic - this would be implemented\n    // by specific skill types or through a plugin system\n    logger.debug(`Skill ${this.metadata.name} executed with parameters:`, this.getAllParameters());\n    \n    return {\n      skill: this.metadata.name,\n      parameters: this.getAllParameters(),\n      input,\n      executed_at: new Date().toISOString()\n    };\n  }\n\n  /**\n   * Skill-specific validation\n   */\n  public override validate(): ElementValidationResult {\n    const result = super.validate();\n    \n    // Initialize arrays if not present\n    if (!result.errors) result.errors = [];\n    if (!result.warnings) result.warnings = [];\n    \n    // Instructions should not be empty\n    if (!this.instructions || this.instructions.trim().length === 0) {\n      result.errors.push({\n        field: 'instructions',\n        message: 'Skill instructions cannot be empty',\n        code: 'EMPTY_INSTRUCTIONS'\n      });\n    }\n\n    // Validate complexity level\n    const validComplexity = ['beginner', 'intermediate', 'advanced', 'expert'];\n    if (this.metadata.complexity && !validComplexity.includes(this.metadata.complexity)) {\n      result.errors.push({\n        field: 'complexity',\n        message: `Complexity must be one of: ${validComplexity.join(', ')}`,\n        code: 'INVALID_COMPLEXITY'\n      });\n    }\n\n    // Validate proficiency level\n    if (this.metadata.proficiency_level !== undefined) {\n      if (this.metadata.proficiency_level < 0 || this.metadata.proficiency_level > 100) {\n        result.errors.push({\n          field: 'proficiency_level',\n          message: 'Proficiency level must be between 0 and 100',\n          code: 'INVALID_PROFICIENCY'\n        });\n      }\n    }\n\n    // Validate parameters\n    if (this.metadata.parameters) {\n      this.metadata.parameters.forEach((param, index) => {\n        if (!param.name || param.name.trim() === '') {\n          result.errors!.push({\n            field: `parameters[${index}].name`,\n            message: 'Parameter name is required',\n            code: 'MISSING_PARAMETER_NAME'\n          });\n        }\n        \n        if (param.type === 'enum' && (!param.options || param.options.length === 0)) {\n          result.errors!.push({\n            field: `parameters[${index}].options`,\n            message: 'Enum parameter must have options defined',\n            code: 'MISSING_ENUM_OPTIONS'\n          });\n        }\n      });\n    }\n\n    // Warnings for best practices\n    if (!this.metadata.domains || this.metadata.domains.length === 0) {\n      result.warnings.push({\n        field: 'domains',\n        message: 'Consider adding domain categories for better organization',\n        severity: 'low'\n      });\n    }\n\n    if (!this.metadata.examples || this.metadata.examples.length === 0) {\n      result.warnings.push({\n        field: 'examples',\n        message: 'Adding usage examples improves skill usability',\n        severity: 'medium'\n      });\n    }\n\n    // Update the valid flag based on final errors\n    result.valid = (result.errors?.length || 0) === 0;\n\n    return result;\n  }\n\n  /**\n   * Serialize skill to JSON format\n   */\n  public override serialize(): string {\n    const data = {\n      id: this.id,\n      type: this.type,\n      version: this.version,\n      metadata: this.metadata,\n      instructions: this.instructions,\n      parameters: this.getAllParameters(),\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   * Deserialize skill from JSON format\n   */\n  public override deserialize(data: string): void {\n    try {\n      const parsed = JSON.parse(data);\n      \n      // Update metadata\n      this.metadata = { ...this.metadata, ...parsed.metadata };\n      \n      // Update other properties\n      this.instructions = parsed.instructions || '';\n      this.references = parsed.references || [];\n      this.extensions = parsed.extensions || {};\n      this.ratings = parsed.ratings || this.ratings;\n      \n      // Update ID and version if provided\n      if (parsed.id) this.id = parsed.id;\n      if (parsed.version) this.version = parsed.version;\n      \n      // Restore parameters\n      if (parsed.parameters) {\n        this.parameters.clear();\n        Object.entries(parsed.parameters).forEach(([key, value]) => {\n          this.parameters.set(key, value);\n        });\n      }\n      \n      this._isDirty = true;\n      logger.debug(`Deserialized skill: ${this.metadata.name}`);\n      \n    } catch (error) {\n      logger.error(`Failed to deserialize skill: ${error}`);\n      throw new Error(`Deserialization failed: ${error}`);\n    }\n  }\n\n  /**\n   * Skill activation lifecycle\n   */\n  public override async activate(): Promise<void> {\n    logger.info(`Activating skill: ${this.metadata.name} (${this.id})`);\n    \n    // Validate that all required parameters are set\n    const validation = this.validate();\n    if (!validation.valid) {\n      throw new Error(`Cannot activate skill with validation errors: ${validation.errors?.map(e => e.message).join(', ')}`);\n    }\n    \n    await super.activate?.();\n  }\n\n  /**\n   * Clone the skill with different parameters\n   */\n  clone(newParameters?: Record<string, any>): Skill {\n    const cloned = new Skill(this.metadata, this.instructions);\n    \n    // Copy current parameters\n    this.parameters.forEach((value, key) => {\n      cloned.parameters.set(key, value);\n    });\n    \n    // Override with new parameters if provided\n    if (newParameters) {\n      Object.entries(newParameters).forEach(([key, value]) => {\n        cloned.setParameter(key, value);\n      });\n    }\n    \n    return cloned;\n  }\n  \n  /**\n   * Skill deactivation lifecycle\n   * SECURITY FIX #4: Automatically clears parameters on deactivation\n   * to prevent memory leaks in long-running processes\n   */\n  public override async deactivate(): Promise<void> {\n    logger.info(`Deactivating skill: ${this.metadata.name} (${this.id})`);\n    \n    // SECURITY FIX #4: Clear parameters to free memory and prevent leaks\n    // This ensures skills don't retain data after deactivation\n    this.clearParameters();\n    \n    await super.deactivate?.();\n  }\n  \n  /**\n   * Clear all parameters (for memory management)\n   * SECURITY FIX #4: Added method to clear parameters and prevent memory leaks\n   * Previously: Parameters accumulated indefinitely in long-running processes\n   * Now: Provides explicit cleanup mechanism called during deactivation\n   */\n  clearParameters(): void {\n    this.parameters.clear();\n    logger.debug(`Cleared all parameters for skill: ${this.metadata.name}`);\n  }\n}"]}