@dollhousemcp/mcp-server 1.3.0

package/dist/test/src/marketplace/PersonaSubmitter.js

@@ -0,0 +1,57 @@
+/**
+ * Submit personas to the marketplace
+ */
+export class PersonaSubmitter {
+    /**
+     * Generate GitHub issue for persona submission
+     */
+    generateSubmissionIssue(persona) {
+        const issueTitle = `New Persona Submission: ${persona.metadata.name}`;
+        const issueBody = `## Persona Submission
+
+**Name:** ${persona.metadata.name}
+**Author:** ${persona.metadata.author || 'Unknown'}
+**Category:** ${persona.metadata.category || 'General'}
+**Description:** ${persona.metadata.description}
+
+### Persona Content:
+\`\`\`markdown
+---
+${Object.entries(persona.metadata)
+            .map(([key, value]) => `${key}: ${Array.isArray(value) ? JSON.stringify(value) : JSON.stringify(value)}`)
+            .join('\n')}
+---
+
+${persona.content}
+\`\`\`
+
+### Submission Details:
+- Submitted via DollhouseMCP client
+- Filename: ${persona.filename}
+- Unique ID: ${persona.unique_id}
+
+---
+*Please review this persona for inclusion in the marketplace.*`;
+        const githubIssueUrl = `https://github.com/DollhouseMCP/personas/issues/new?title=${encodeURIComponent(issueTitle)}&body=${encodeURIComponent(issueBody)}`;
+        return {
+            issueTitle,
+            issueBody,
+            githubIssueUrl
+        };
+    }
+    /**
+     * Format submission response
+     */
+    formatSubmissionResponse(persona, githubIssueUrl, personaIndicator = '') {
+        return `${personaIndicator}📤 **Persona Submission Prepared**\n\n` +
+            `🎭 **${persona.metadata.name}** is ready for marketplace submission!\n\n` +
+            `**Next Steps:**\n` +
+            `1. Click this link to create a GitHub issue: \n` +
+            `   ${githubIssueUrl}\n\n` +
+            `2. Review the pre-filled content\n` +
+            `3. Click "Submit new issue"\n` +
+            `4. The maintainers will review your submission\n\n` +
+            `⭐ **Tip:** You can also submit via pull request if you're familiar with Git!`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/test/src/marketplace/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Marketplace module exports
+ */
+export * from './GitHubClient.js';
+export * from './MarketplaceBrowser.js';
+export * from './MarketplaceSearch.js';
+export * from './PersonaDetails.js';
+export * from './PersonaInstaller.js';
+export * from './PersonaSubmitter.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/test/src/marketplace/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/marketplace/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC"}

package/dist/test/src/marketplace/index.js

@@ -0,0 +1,10 @@
+/**
+ * Marketplace module exports
+ */
+export * from './GitHubClient.js';
+export * from './MarketplaceBrowser.js';
+export * from './MarketplaceSearch.js';
+export * from './PersonaDetails.js';
+export * from './PersonaInstaller.js';
+export * from './PersonaSubmitter.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbWFya2V0cGxhY2UvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyx1QkFBdUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogTWFya2V0cGxhY2UgbW9kdWxlIGV4cG9ydHNcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL0dpdEh1YkNsaWVudC5qcyc7XG5leHBvcnQgKiBmcm9tICcuL01hcmtldHBsYWNlQnJvd3Nlci5qcyc7XG5leHBvcnQgKiBmcm9tICcuL01hcmtldHBsYWNlU2VhcmNoLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vUGVyc29uYURldGFpbHMuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9QZXJzb25hSW5zdGFsbGVyLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vUGVyc29uYVN1Ym1pdHRlci5qcyc7Il19

package/dist/test/src/persona/PersonaElement.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Persona element class implementing IElement interface.
+ * Represents a behavioral profile that defines AI personality and interaction style.
+ */
+import { BaseElement } from '../elements/BaseElement.js';
+import { IElement, IElementMetadata, ElementValidationResult } from '../types/elements/index.js';
+import { PersonaMetadata } from '../types/persona.js';
+export interface PersonaElementMetadata extends IElementMetadata {
+    triggers?: string[];
+    category?: string;
+    age_rating?: 'all' | '13+' | '18+';
+    content_flags?: string[];
+    ai_generated?: boolean;
+    generation_method?: 'human' | 'ChatGPT' | 'Claude' | 'hybrid';
+    price?: string;
+    revenue_split?: string;
+    license?: string;
+    created_date?: string;
+}
+export declare class PersonaElement extends BaseElement implements IElement {
+    content: string;
+    filename: string;
+    metadata: PersonaElementMetadata;
+    constructor(metadata: Partial<PersonaElementMetadata>, content?: string, filename?: string);
+    /**
+     * Create PersonaElement from legacy Persona interface
+     */
+    static fromLegacy(legacyPersona: {
+        metadata: PersonaMetadata;
+        content: string;
+        filename: string;
+        unique_id: string;
+    }): PersonaElement;
+    /**
+     * Convert to legacy Persona interface for backward compatibility
+     */
+    toLegacy(): {
+        metadata: PersonaMetadata;
+        content: string;
+        filename: string;
+        unique_id: string;
+    };
+    /**
+     * Persona-specific validation
+     */
+    validate(): ElementValidationResult;
+    /**
+     * Serialize persona to markdown format
+     */
+    serialize(): string;
+    /**
+     * Deserialize persona from markdown format
+     */
+    deserialize(data: string): void;
+    /**
+     * Persona activation lifecycle
+     */
+    activate(): Promise<void>;
+    /**
+     * Persona deactivation lifecycle
+     */
+    deactivate(): Promise<void>;
+}
+//# sourceMappingURL=PersonaElement.d.ts.map

package/dist/test/src/persona/PersonaElement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersonaElement.d.ts","sourceRoot":"","sources":["../../../../src/persona/PersonaElement.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAEjG,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAKtD,MAAM,WAAW,sBAAuB,SAAQ,gBAAgB;IAC9D,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;IACnC,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,iBAAiB,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,QAAQ,GAAG,QAAQ,CAAC;IAC9D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,qBAAa,cAAe,SAAQ,WAAY,YAAW,QAAQ;IAC1D,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACT,QAAQ,EAAE,sBAAsB,CAAC;gBAEpC,QAAQ,EAAE,OAAO,CAAC,sBAAsB,CAAC,EAAE,OAAO,GAAE,MAAW,EAAE,QAAQ,GAAE,MAAW;IAoBlG;;OAEG;IACH,MAAM,CAAC,UAAU,CAAC,aAAa,EAAE;QAAE,QAAQ,EAAE,eAAe,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,GAAG,cAAc;IA0BrI;;OAEG;IACH,QAAQ,IAAI;QAAE,QAAQ,EAAE,eAAe,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE;IA2B/F;;OAEG;IACa,QAAQ,IAAI,uBAAuB;IAmDnD;;OAEG;IACa,SAAS,IAAI,MAAM;IAqCnC;;OAEG;IACa,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAyC/C;;OAEG;IACmB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAS/C;;OAEG;IACmB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;CAQlD"}

package/dist/test/src/persona/PersonaElement.js

@@ -0,0 +1,223 @@
+/**
+ * Persona element class implementing IElement interface.
+ * Represents a behavioral profile that defines AI personality and interaction style.
+ */
+import { BaseElement } from '../elements/BaseElement.js';
+import { ElementType } from '../portfolio/types.js';
+import { logger } from '../utils/logger.js';
+import matter from 'gray-matter';
+export class PersonaElement extends BaseElement {
+    content;
+    filename;
+    constructor(metadata, content = '', filename = '') {
+        super(ElementType.PERSONA, metadata);
+        this.content = content;
+        this.filename = filename;
+        // Ensure persona-specific metadata
+        this.metadata = {
+            ...this.metadata,
+            triggers: metadata.triggers || [],
+            category: metadata.category || 'personal',
+            age_rating: metadata.age_rating || 'all',
+            content_flags: metadata.content_flags || [],
+            ai_generated: metadata.ai_generated || false,
+            generation_method: metadata.generation_method || 'human',
+            price: metadata.price || 'free',
+            license: metadata.license || 'CC-BY-SA-4.0',
+            created_date: metadata.created_date || new Date().toISOString().split('T')[0]
+        };
+    }
+    /**
+     * Create PersonaElement from legacy Persona interface
+     */
+    static fromLegacy(legacyPersona) {
+        const metadata = {
+            name: legacyPersona.metadata.name,
+            description: legacyPersona.metadata.description,
+            author: legacyPersona.metadata.author,
+            version: legacyPersona.metadata.version,
+            triggers: legacyPersona.metadata.triggers,
+            category: legacyPersona.metadata.category,
+            age_rating: legacyPersona.metadata.age_rating,
+            content_flags: legacyPersona.metadata.content_flags,
+            ai_generated: legacyPersona.metadata.ai_generated,
+            generation_method: legacyPersona.metadata.generation_method,
+            price: legacyPersona.metadata.price,
+            revenue_split: legacyPersona.metadata.revenue_split,
+            license: legacyPersona.metadata.license,
+            created_date: legacyPersona.metadata.created_date
+        };
+        const persona = new PersonaElement(metadata, legacyPersona.content, legacyPersona.filename);
+        // Preserve the legacy unique_id as the element id
+        persona.id = legacyPersona.unique_id;
+        return persona;
+    }
+    /**
+     * Convert to legacy Persona interface for backward compatibility
+     */
+    toLegacy() {
+        const legacyMetadata = {
+            name: this.metadata.name,
+            description: this.metadata.description,
+            unique_id: this.id,
+            author: this.metadata.author,
+            triggers: this.metadata.triggers,
+            version: this.metadata.version,
+            category: this.metadata.category,
+            age_rating: this.metadata.age_rating,
+            content_flags: this.metadata.content_flags,
+            ai_generated: this.metadata.ai_generated,
+            generation_method: this.metadata.generation_method,
+            price: this.metadata.price,
+            revenue_split: this.metadata.revenue_split,
+            license: this.metadata.license,
+            created_date: this.metadata.created_date
+        };
+        return {
+            metadata: legacyMetadata,
+            content: this.content,
+            filename: this.filename,
+            unique_id: this.id
+        };
+    }
+    /**
+     * Persona-specific validation
+     */
+    validate() {
+        const result = super.validate();
+        // Initialize arrays if not present
+        if (!result.errors)
+            result.errors = [];
+        if (!result.warnings)
+            result.warnings = [];
+        // Add persona-specific validation rules
+        // Content should not be empty
+        if (!this.content || this.content.trim().length === 0) {
+            result.errors.push({
+                field: 'content',
+                message: 'Persona content cannot be empty',
+                code: 'EMPTY_CONTENT'
+            });
+        }
+        // Content should be reasonable length
+        if (this.content && this.content.length > 10000) {
+            result.warnings.push({
+                field: 'content',
+                message: 'Persona content is very long, consider breaking it down',
+                severity: 'medium'
+            });
+        }
+        // Triggers should be reasonable
+        if (this.metadata.triggers && this.metadata.triggers.length > 10) {
+            result.warnings.push({
+                field: 'triggers',
+                message: 'Many triggers may cause activation conflicts',
+                severity: 'medium'
+            });
+        }
+        // Check for adult content flags
+        if (this.metadata.age_rating === '18+' && !this.metadata.content_flags?.includes('adult')) {
+            result.warnings.push({
+                field: 'content_flags',
+                message: '18+ content should include "adult" in content_flags',
+                severity: 'low'
+            });
+        }
+        // Update the valid flag based on final errors
+        result.valid = (result.errors?.length || 0) === 0;
+        return result;
+    }
+    /**
+     * Serialize persona to markdown format
+     */
+    serialize() {
+        const frontmatter = {
+            name: this.metadata.name,
+            description: this.metadata.description,
+            unique_id: this.id,
+            author: this.metadata.author,
+            triggers: this.metadata.triggers,
+            version: this.metadata.version,
+            category: this.metadata.category,
+            age_rating: this.metadata.age_rating,
+            content_flags: this.metadata.content_flags,
+            ai_generated: this.metadata.ai_generated,
+            generation_method: this.metadata.generation_method,
+            price: this.metadata.price,
+            revenue_split: this.metadata.revenue_split,
+            license: this.metadata.license,
+            created_date: this.metadata.created_date
+        };
+        // Remove undefined values
+        const cleanFrontmatter = Object.fromEntries(Object.entries(frontmatter).filter(([_, value]) => value !== undefined));
+        const yamlFrontmatter = Object.entries(cleanFrontmatter)
+            .map(([key, value]) => {
+            if (Array.isArray(value)) {
+                if (value.length === 0)
+                    return `${key}: []`;
+                return `${key}:\n${value.map(item => `  - ${item}`).join('\n')}`;
+            }
+            return `${key}: ${JSON.stringify(value)}`;
+        })
+            .join('\n');
+        return `---\n${yamlFrontmatter}\n---\n\n${this.content}`;
+    }
+    /**
+     * Deserialize persona from markdown format
+     */
+    deserialize(data) {
+        try {
+            const parsed = matter(data);
+            const metadata = parsed.data;
+            // Update metadata
+            this.metadata = {
+                ...this.metadata,
+                name: metadata.name,
+                description: metadata.description,
+                author: metadata.author,
+                version: metadata.version,
+                triggers: metadata.triggers,
+                category: metadata.category,
+                age_rating: metadata.age_rating,
+                content_flags: metadata.content_flags,
+                ai_generated: metadata.ai_generated,
+                generation_method: metadata.generation_method,
+                price: metadata.price,
+                revenue_split: metadata.revenue_split,
+                license: metadata.license,
+                created_date: metadata.created_date
+            };
+            // Update content (trim to remove leading/trailing whitespace)
+            this.content = parsed.content.trim();
+            // Update ID if provided
+            if (metadata.unique_id) {
+                this.id = metadata.unique_id;
+            }
+            this._isDirty = true;
+            logger.debug(`Deserialized persona: ${this.metadata.name}`);
+        }
+        catch (error) {
+            logger.error(`Failed to deserialize persona: ${error}`);
+            throw new Error(`Deserialization failed: ${error}`);
+        }
+    }
+    /**
+     * Persona activation lifecycle
+     */
+    async activate() {
+        logger.info(`Activating persona: ${this.metadata.name} (${this.id})`);
+        // Personas don't need special activation logic currently
+        // But this provides a hook for future enhancements
+        await super.activate?.();
+    }
+    /**
+     * Persona deactivation lifecycle
+     */
+    async deactivate() {
+        logger.info(`Deactivating persona: ${this.metadata.name} (${this.id})`);
+        // Personas don't need special deactivation logic currently
+        // But this provides a hook for future enhancements
+        await super.deactivate?.();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PersonaElement.js","sourceRoot":"","sources":["../../../../src/persona/PersonaElement.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Persona element class implementing IElement interface.\n * Represents a behavioral profile that defines AI personality and interaction style.\n */\n\nimport { BaseElement } from '../elements/BaseElement.js';\nimport { IElement, IElementMetadata, ElementValidationResult } from '../types/elements/index.js';\nimport { ElementType } from '../portfolio/types.js';\nimport { PersonaMetadata } from '../types/persona.js';\nimport { logger } from '../utils/logger.js';\nimport matter from 'gray-matter';\n\n// Extend IElementMetadata with persona-specific fields\nexport interface PersonaElementMetadata extends IElementMetadata {\n  triggers?: string[];\n  category?: string;\n  age_rating?: 'all' | '13+' | '18+';\n  content_flags?: string[];\n  ai_generated?: boolean;\n  generation_method?: 'human' | 'ChatGPT' | 'Claude' | 'hybrid';\n  price?: string;\n  revenue_split?: string;\n  license?: string;\n  created_date?: string;\n}\n\nexport class PersonaElement extends BaseElement implements IElement {\n  public content: string;\n  public filename: string;\n  public declare metadata: PersonaElementMetadata;\n\n  constructor(metadata: Partial<PersonaElementMetadata>, content: string = '', filename: string = '') {\n    super(ElementType.PERSONA, metadata);\n    this.content = content;\n    this.filename = filename;\n    \n    // Ensure persona-specific metadata\n    this.metadata = {\n      ...this.metadata,\n      triggers: metadata.triggers || [],\n      category: metadata.category || 'personal',\n      age_rating: metadata.age_rating || 'all',\n      content_flags: metadata.content_flags || [],\n      ai_generated: metadata.ai_generated || false,\n      generation_method: metadata.generation_method || 'human',\n      price: metadata.price || 'free',\n      license: metadata.license || 'CC-BY-SA-4.0',\n      created_date: metadata.created_date || new Date().toISOString().split('T')[0]\n    };\n  }\n\n  /**\n   * Create PersonaElement from legacy Persona interface\n   */\n  static fromLegacy(legacyPersona: { metadata: PersonaMetadata; content: string; filename: string; unique_id: string }): PersonaElement {\n    const metadata: Partial<PersonaElementMetadata> = {\n      name: legacyPersona.metadata.name,\n      description: legacyPersona.metadata.description,\n      author: legacyPersona.metadata.author,\n      version: legacyPersona.metadata.version,\n      triggers: legacyPersona.metadata.triggers,\n      category: legacyPersona.metadata.category,\n      age_rating: legacyPersona.metadata.age_rating,\n      content_flags: legacyPersona.metadata.content_flags,\n      ai_generated: legacyPersona.metadata.ai_generated,\n      generation_method: legacyPersona.metadata.generation_method,\n      price: legacyPersona.metadata.price,\n      revenue_split: legacyPersona.metadata.revenue_split,\n      license: legacyPersona.metadata.license,\n      created_date: legacyPersona.metadata.created_date\n    };\n\n    const persona = new PersonaElement(metadata, legacyPersona.content, legacyPersona.filename);\n    \n    // Preserve the legacy unique_id as the element id\n    persona.id = legacyPersona.unique_id;\n    \n    return persona;\n  }\n\n  /**\n   * Convert to legacy Persona interface for backward compatibility\n   */\n  toLegacy(): { metadata: PersonaMetadata; content: string; filename: string; unique_id: string } {\n    const legacyMetadata: PersonaMetadata = {\n      name: this.metadata.name,\n      description: this.metadata.description,\n      unique_id: this.id,\n      author: this.metadata.author,\n      triggers: this.metadata.triggers,\n      version: this.metadata.version,\n      category: this.metadata.category,\n      age_rating: this.metadata.age_rating,\n      content_flags: this.metadata.content_flags,\n      ai_generated: this.metadata.ai_generated,\n      generation_method: this.metadata.generation_method,\n      price: this.metadata.price,\n      revenue_split: this.metadata.revenue_split,\n      license: this.metadata.license,\n      created_date: this.metadata.created_date\n    };\n\n    return {\n      metadata: legacyMetadata,\n      content: this.content,\n      filename: this.filename,\n      unique_id: this.id\n    };\n  }\n\n  /**\n   * Persona-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    // Add persona-specific validation rules\n    \n    // Content should not be empty\n    if (!this.content || this.content.trim().length === 0) {\n      result.errors.push({\n        field: 'content',\n        message: 'Persona content cannot be empty',\n        code: 'EMPTY_CONTENT'\n      });\n    }\n\n    // Content should be reasonable length\n    if (this.content && this.content.length > 10000) {\n      result.warnings.push({\n        field: 'content',\n        message: 'Persona content is very long, consider breaking it down',\n        severity: 'medium'\n      });\n    }\n\n    // Triggers should be reasonable\n    if (this.metadata.triggers && this.metadata.triggers.length > 10) {\n      result.warnings.push({\n        field: 'triggers',\n        message: 'Many triggers may cause activation conflicts',\n        severity: 'medium'\n      });\n    }\n\n    // Check for adult content flags\n    if (this.metadata.age_rating === '18+' && !this.metadata.content_flags?.includes('adult')) {\n      result.warnings.push({\n        field: 'content_flags',\n        message: '18+ content should include \"adult\" in content_flags',\n        severity: 'low'\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 persona to markdown format\n   */\n  public override serialize(): string {\n    const frontmatter = {\n      name: this.metadata.name,\n      description: this.metadata.description,\n      unique_id: this.id,\n      author: this.metadata.author,\n      triggers: this.metadata.triggers,\n      version: this.metadata.version,\n      category: this.metadata.category,\n      age_rating: this.metadata.age_rating,\n      content_flags: this.metadata.content_flags,\n      ai_generated: this.metadata.ai_generated,\n      generation_method: this.metadata.generation_method,\n      price: this.metadata.price,\n      revenue_split: this.metadata.revenue_split,\n      license: this.metadata.license,\n      created_date: this.metadata.created_date\n    };\n\n    // Remove undefined values\n    const cleanFrontmatter = Object.fromEntries(\n      Object.entries(frontmatter).filter(([_, value]) => value !== undefined)\n    );\n\n    const yamlFrontmatter = Object.entries(cleanFrontmatter)\n      .map(([key, value]) => {\n        if (Array.isArray(value)) {\n          if (value.length === 0) return `${key}: []`;\n          return `${key}:\\n${value.map(item => `  - ${item}`).join('\\n')}`;\n        }\n        return `${key}: ${JSON.stringify(value)}`;\n      })\n      .join('\\n');\n\n    return `---\\n${yamlFrontmatter}\\n---\\n\\n${this.content}`;\n  }\n\n  /**\n   * Deserialize persona from markdown format\n   */\n  public override deserialize(data: string): void {\n    try {\n      const parsed = matter(data);\n      const metadata = parsed.data as PersonaMetadata;\n      \n      // Update metadata\n      this.metadata = {\n        ...this.metadata,\n        name: metadata.name,\n        description: metadata.description,\n        author: metadata.author,\n        version: metadata.version,\n        triggers: metadata.triggers,\n        category: metadata.category,\n        age_rating: metadata.age_rating,\n        content_flags: metadata.content_flags,\n        ai_generated: metadata.ai_generated,\n        generation_method: metadata.generation_method,\n        price: metadata.price,\n        revenue_split: metadata.revenue_split,\n        license: metadata.license,\n        created_date: metadata.created_date\n      };\n      \n      // Update content (trim to remove leading/trailing whitespace)\n      this.content = parsed.content.trim();\n      \n      // Update ID if provided\n      if (metadata.unique_id) {\n        this.id = metadata.unique_id;\n      }\n      \n      this._isDirty = true;\n      logger.debug(`Deserialized persona: ${this.metadata.name}`);\n      \n    } catch (error) {\n      logger.error(`Failed to deserialize persona: ${error}`);\n      throw new Error(`Deserialization failed: ${error}`);\n    }\n  }\n\n  /**\n   * Persona activation lifecycle\n   */\n  public override async activate(): Promise<void> {\n    logger.info(`Activating persona: ${this.metadata.name} (${this.id})`);\n    \n    // Personas don't need special activation logic currently\n    // But this provides a hook for future enhancements\n    \n    await super.activate?.();\n  }\n\n  /**\n   * Persona deactivation lifecycle\n   */\n  public override async deactivate(): Promise<void> {\n    logger.info(`Deactivating persona: ${this.metadata.name} (${this.id})`);\n    \n    // Personas don't need special deactivation logic currently\n    // But this provides a hook for future enhancements\n    \n    await super.deactivate?.();\n  }\n}"]}

package/dist/test/src/persona/PersonaElementManager.d.ts

@@ -0,0 +1,97 @@
+/**
+ * PersonaElementManager - Implementation of IElementManager for PersonaElement
+ * Handles CRUD operations and lifecycle management for personas implementing IElement
+ *
+ * SECURITY FIXES IMPLEMENTED (PR #319):
+ * 1. CRITICAL: Fixed race conditions in file operations by using FileLockManager for atomic reads/writes
+ * 2. CRITICAL: Fixed dynamic require() statements by using static imports
+ * 3. HIGH: Fixed unvalidated YAML parsing vulnerability by using SecureYamlParser
+ * 4. MEDIUM: All user inputs are now validated and sanitized
+ * 5. MEDIUM: Audit logging added for security operations
+ */
+import { IElementManager, ElementValidationResult } from '../types/elements/index.js';
+import { ElementType } from '../portfolio/types.js';
+import { PersonaElement, PersonaElementMetadata } from './PersonaElement.js';
+import { PortfolioManager } from '../portfolio/PortfolioManager.js';
+export declare class PersonaElementManager implements IElementManager<PersonaElement> {
+    private portfolioManager;
+    private personasDir;
+    constructor(portfolioManager?: PortfolioManager);
+    /**
+     * Load a persona from file
+     * SECURITY FIX #1: Uses FileLockManager.atomicReadFile() instead of fs.readFile()
+     * to prevent race conditions and ensure atomic file operations
+     */
+    load(filePath: string): Promise<PersonaElement>;
+    /**
+     * Save a persona to file
+     * SECURITY FIX #1: Uses FileLockManager.atomicWriteFile() instead of fs.writeFile()
+     * to prevent race conditions and ensure atomic file operations
+     */
+    save(element: PersonaElement, filePath: string): Promise<void>;
+    /**
+     * Delete a persona file
+     */
+    delete(filePath: string): Promise<void>;
+    /**
+     * Check if a persona file exists
+     */
+    exists(filePath: string): Promise<boolean>;
+    /**
+     * List all personas
+     */
+    list(): Promise<PersonaElement[]>;
+    /**
+     * Find a persona by predicate
+     */
+    find(predicate: (element: PersonaElement) => boolean): Promise<PersonaElement | undefined>;
+    /**
+     * Find multiple personas by predicate
+     */
+    findMany(predicate: (element: PersonaElement) => boolean): Promise<PersonaElement[]>;
+    /**
+     * Validate a persona element
+     */
+    validate(element: PersonaElement): ElementValidationResult;
+    /**
+     * Validate a file path
+     */
+    validatePath(filePath: string): boolean;
+    /**
+     * Get element type
+     */
+    getElementType(): ElementType;
+    /**
+     * Get file extension
+     */
+    getFileExtension(): string;
+    /**
+     * Import persona from data
+     * SECURITY FIX #3: Uses SecureYamlParser instead of unsafe YAML parsing to prevent
+     * YAML deserialization attacks and injection vulnerabilities
+     */
+    importElement(data: string, format?: 'json' | 'yaml' | 'markdown'): Promise<PersonaElement>;
+    /**
+     * Export persona to data
+     * SECURITY FIX #2: Uses static import of js-yaml at top of file instead of
+     * dynamic require() for better security and bundling
+     * SECURITY FIX #3: Uses secure YAML dumping with safety options
+     */
+    exportElement(element: PersonaElement, format?: 'json' | 'yaml' | 'markdown'): Promise<string>;
+    /**
+     * Helper: Convert JSON data to markdown format
+     * SECURITY FIX #2: Uses statically imported yaml module
+     * SECURITY FIX #3: Uses secure YAML dumping with safety options
+     * Note: This is for internal conversion only, user-provided YAML must use SecureYamlParser
+     */
+    private jsonToMarkdown;
+    /**
+     * Create a new persona with default metadata
+     */
+    create(metadata: Partial<PersonaElementMetadata>): PersonaElement;
+    /**
+     * Get default filename for a persona
+     */
+    getDefaultFilename(persona: PersonaElement): string;
+}
+//# sourceMappingURL=PersonaElementManager.d.ts.map

package/dist/test/src/persona/PersonaElementManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersonaElementManager.d.ts","sourceRoot":"","sources":["../../../../src/persona/PersonaElementManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAKH,OAAO,EAAE,eAAe,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AACtF,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAC7E,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AAQpE,qBAAa,qBAAsB,YAAW,eAAe,CAAC,cAAc,CAAC;IAC3E,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,WAAW,CAAS;gBAEhB,gBAAgB,CAAC,EAAE,gBAAgB;IAK/C;;;;OAIG;IACG,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IA4BrD;;;;OAIG;IACG,IAAI,CAAC,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiCpE;;OAEG;IACG,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmB7C;;OAEG;IACG,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAYhD;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC;IA6BvC;;OAEG;IACG,IAAI,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,OAAO,GAAG,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC;IAKhG;;OAEG;IACG,QAAQ,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,OAAO,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAK1F;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,cAAc,GAAG,uBAAuB;IAI1D;;OAEG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAoBvC;;OAEG;IACH,cAAc,IAAI,WAAW;IAI7B;;OAEG;IACH,gBAAgB,IAAI,MAAM;IAI1B;;;;OAIG;IACG,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,GAAG,MAAM,GAAG,UAAuB,GAAG,OAAO,CAAC,cAAc,CAAC;IAmD7G;;;;;OAKG;IACG,aAAa,CAAC,OAAO,EAAE,cAAc,EAAE,MAAM,GAAE,MAAM,GAAG,MAAM,GAAG,UAAuB,GAAG,OAAO,CAAC,MAAM,CAAC;IA4BhH;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IAYtB;;OAEG;IACH,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,sBAAsB,CAAC,GAAG,cAAc;IAmBjE;;OAEG;IACH,kBAAkB,CAAC,OAAO,EAAE,cAAc,GAAG,MAAM;CASpD"}