@dollhousemcp/mcp-server 1.3.0

package/dist/src/persona/PersonaManager.js

@@ -0,0 +1,341 @@
+/**
+ * Core persona management operations
+ */
+import { PersonaLoader } from './PersonaLoader.js';
+import { PersonaValidator } from './PersonaValidator.js';
+import { validateFilename, sanitizeInput } from '../security/InputValidator.js';
+import { generateAnonymousId, generateUniqueId, slugify } from '../utils/filesystem.js';
+import { formatIndicator } from '../config/indicator-config.js';
+export class PersonaManager {
+    personas = new Map();
+    activePersona = null;
+    currentUser = null;
+    loader;
+    validator;
+    indicatorConfig;
+    constructor(personasDir, indicatorConfig) {
+        this.loader = new PersonaLoader(personasDir);
+        this.validator = new PersonaValidator();
+        this.indicatorConfig = indicatorConfig;
+    }
+    /**
+     * Initialize and load all personas
+     */
+    async initialize() {
+        this.personas = await this.loader.loadAll(() => this.getCurrentUserForAttribution());
+    }
+    /**
+     * Reload all personas from disk
+     */
+    async reload() {
+        this.personas.clear();
+        this.activePersona = null;
+        await this.initialize();
+    }
+    /**
+     * Get all loaded personas
+     */
+    getAllPersonas() {
+        return this.personas;
+    }
+    /**
+     * Find a persona by identifier (filename, name, or unique_id)
+     */
+    findPersona(identifier) {
+        // Try direct filename match
+        let persona = this.personas.get(identifier);
+        if (!persona) {
+            // Try with .md extension
+            persona = this.personas.get(`${identifier}.md`);
+        }
+        if (!persona) {
+            // Search by name (case-insensitive)
+            persona = Array.from(this.personas.values()).find(p => p.metadata.name.toLowerCase() === identifier.toLowerCase());
+        }
+        if (!persona) {
+            // Search by unique_id
+            persona = Array.from(this.personas.values()).find(p => p.unique_id === identifier);
+        }
+        return persona;
+    }
+    /**
+     * Activate a persona
+     */
+    activatePersona(identifier) {
+        const persona = this.findPersona(identifier);
+        if (!persona) {
+            return {
+                success: false,
+                message: `Persona not found: "${identifier}"`
+            };
+        }
+        this.activePersona = persona.filename;
+        return {
+            success: true,
+            message: `Activated persona: ${persona.metadata.name}`,
+            persona
+        };
+    }
+    /**
+     * Deactivate the current persona
+     */
+    deactivatePersona() {
+        if (!this.activePersona) {
+            return {
+                success: false,
+                message: "No persona is currently active"
+            };
+        }
+        const persona = this.personas.get(this.activePersona);
+        const personaName = persona?.metadata.name || this.activePersona;
+        this.activePersona = null;
+        return {
+            success: true,
+            message: `Deactivated persona: ${personaName}`
+        };
+    }
+    /**
+     * Get the active persona
+     */
+    getActivePersona() {
+        if (!this.activePersona)
+            return null;
+        return this.personas.get(this.activePersona) || null;
+    }
+    /**
+     * Get persona indicator for responses
+     */
+    getPersonaIndicator() {
+        if (!this.activePersona)
+            return "";
+        const persona = this.personas.get(this.activePersona);
+        if (!persona)
+            return "";
+        return formatIndicator(this.indicatorConfig, {
+            name: persona.metadata.name,
+            version: persona.metadata.version,
+            author: persona.metadata.author,
+            category: persona.metadata.category
+        });
+    }
+    /**
+     * Create a new persona
+     */
+    async createPersona(name, description, category, instructions) {
+        try {
+            // Validate inputs
+            const cleanName = sanitizeInput(name, 50);
+            const cleanDescription = sanitizeInput(description, 200);
+            if (!cleanName) {
+                return { success: false, message: "Persona name cannot be empty" };
+            }
+            // Generate filename
+            const baseFilename = slugify(cleanName) + '.md';
+            const filename = validateFilename(baseFilename);
+            // Check if already exists
+            if (this.personas.has(filename)) {
+                return {
+                    success: false,
+                    message: `A persona named "${cleanName}" already exists`
+                };
+            }
+            // Create metadata
+            const metadata = {
+                name: cleanName,
+                description: cleanDescription,
+                category: category || 'general',
+                version: '1.0',
+                author: this.getCurrentUserForAttribution() || undefined,
+                unique_id: generateUniqueId(cleanName, this.getCurrentUserForAttribution() || undefined),
+                triggers: this.generateTriggers(cleanName),
+                created_date: new Date().toISOString()
+            };
+            // Create persona
+            const persona = {
+                metadata,
+                content: instructions,
+                filename,
+                unique_id: metadata.unique_id
+            };
+            // Validate
+            const validation = this.validator.validatePersona(persona);
+            if (!validation.valid) {
+                return {
+                    success: false,
+                    message: `Validation failed: ${validation.issues.join(', ')}`
+                };
+            }
+            // Save to disk
+            await this.loader.savePersona(persona);
+            // Add to memory
+            this.personas.set(filename, persona);
+            return {
+                success: true,
+                message: `Created persona "${cleanName}" successfully`,
+                filename
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Failed to create persona: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    /**
+     * Edit an existing persona
+     */
+    async editPersona(personaName, field, value) {
+        const persona = this.findPersona(personaName);
+        if (!persona) {
+            return {
+                success: false,
+                message: `Persona not found: "${personaName}"`
+            };
+        }
+        try {
+            const oldVersion = String(persona.metadata.version || '1.0');
+            switch (field.toLowerCase()) {
+                case 'name':
+                    persona.metadata.name = sanitizeInput(value, 50);
+                    break;
+                case 'description':
+                    persona.metadata.description = sanitizeInput(value, 200);
+                    break;
+                case 'instructions':
+                case 'content':
+                    persona.content = value;
+                    break;
+                case 'category':
+                    persona.metadata.category = value;
+                    break;
+                case 'triggers':
+                    persona.metadata.triggers = value.split(',').map(t => t.trim()).filter(t => t);
+                    break;
+                case 'version':
+                    persona.metadata.version = value;
+                    break;
+                default:
+                    return {
+                        success: false,
+                        message: `Unknown field: "${field}". Valid fields: name, description, instructions, category, triggers, version`
+                    };
+            }
+            // Auto-increment version if not explicitly setting version
+            if (field !== 'version') {
+                persona.metadata.version = this.incrementVersion(oldVersion);
+            }
+            // Validate
+            const validation = this.validator.validatePersona(persona);
+            if (!validation.valid) {
+                return {
+                    success: false,
+                    message: `Validation failed: ${validation.issues.join(', ')}`
+                };
+            }
+            // Save changes
+            await this.loader.savePersona(persona);
+            return {
+                success: true,
+                message: `Updated ${field} for "${persona.metadata.name}" (v${persona.metadata.version})`
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Failed to edit persona: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    /**
+     * Validate a persona
+     */
+    validatePersona(identifier) {
+        const persona = this.findPersona(identifier);
+        if (!persona) {
+            return { found: false };
+        }
+        return {
+            found: true,
+            validation: this.validator.validatePersona(persona)
+        };
+    }
+    /**
+     * Set current user identity
+     */
+    setUserIdentity(username, email) {
+        this.currentUser = username;
+        if (username) {
+            process.env.DOLLHOUSE_USER = username;
+            if (email) {
+                process.env.DOLLHOUSE_EMAIL = email;
+            }
+        }
+        else {
+            delete process.env.DOLLHOUSE_USER;
+            delete process.env.DOLLHOUSE_EMAIL;
+        }
+    }
+    /**
+     * Get current user identity
+     */
+    getUserIdentity() {
+        return {
+            username: process.env.DOLLHOUSE_USER || null,
+            email: process.env.DOLLHOUSE_EMAIL || null
+        };
+    }
+    /**
+     * Clear user identity
+     */
+    clearUserIdentity() {
+        this.setUserIdentity(null);
+    }
+    /**
+     * Update indicator configuration
+     */
+    updateIndicatorConfig(config) {
+        this.indicatorConfig = config;
+    }
+    /**
+     * Get current indicator configuration
+     */
+    getIndicatorConfig() {
+        return this.indicatorConfig;
+    }
+    /**
+     * Helper to get current user for attribution
+     */
+    getCurrentUserForAttribution() {
+        return this.currentUser || process.env.DOLLHOUSE_USER || generateAnonymousId();
+    }
+    /**
+     * Generate trigger keywords from persona name
+     */
+    generateTriggers(name) {
+        const words = name.toLowerCase().split(/\s+/);
+        const triggers = [...words];
+        // Add the full name as a trigger
+        if (words.length > 1) {
+            triggers.push(name.toLowerCase());
+        }
+        // Remove duplicates
+        return [...new Set(triggers)].filter(t => t.length > 2);
+    }
+    /**
+     * Increment version number
+     */
+    incrementVersion(version) {
+        // Handle both string and number versions
+        const versionStr = String(version);
+        const parts = versionStr.split('.');
+        // If it's just a number like "1", make it "1.0" 
+        if (parts.length === 1) {
+            parts.push('0');
+        }
+        const patch = parseInt(parts[parts.length - 1]) || 0;
+        parts[parts.length - 1] = (patch + 1).toString();
+        return parts.join('.');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PersonaManager.js","sourceRoot":"","sources":["../../../src/persona/PersonaManager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Core persona management operations\n */\n\nimport * as path from 'path';\nimport matter from 'gray-matter';\nimport { Persona, PersonaMetadata } from '../types/persona.js';\nimport { PersonaLoader } from './PersonaLoader.js';\nimport { PersonaValidator } from './PersonaValidator.js';\nimport { validateFilename, sanitizeInput } from '../security/InputValidator.js';\nimport { generateAnonymousId, generateUniqueId, slugify } from '../utils/filesystem.js';\nimport { IndicatorConfig, formatIndicator } from '../config/indicator-config.js';\n\nexport class PersonaManager {\n  private personas: Map<string, Persona> = new Map();\n  private activePersona: string | null = null;\n  private currentUser: string | null = null;\n  private loader: PersonaLoader;\n  private validator: PersonaValidator;\n  private indicatorConfig: IndicatorConfig;\n  \n  constructor(personasDir: string, indicatorConfig: IndicatorConfig) {\n    this.loader = new PersonaLoader(personasDir);\n    this.validator = new PersonaValidator();\n    this.indicatorConfig = indicatorConfig;\n  }\n  \n  /**\n   * Initialize and load all personas\n   */\n  async initialize(): Promise<void> {\n    this.personas = await this.loader.loadAll(() => this.getCurrentUserForAttribution());\n  }\n  \n  /**\n   * Reload all personas from disk\n   */\n  async reload(): Promise<void> {\n    this.personas.clear();\n    this.activePersona = null;\n    await this.initialize();\n  }\n  \n  /**\n   * Get all loaded personas\n   */\n  getAllPersonas(): Map<string, Persona> {\n    return this.personas;\n  }\n  \n  /**\n   * Find a persona by identifier (filename, name, or unique_id)\n   */\n  findPersona(identifier: string): Persona | undefined {\n    // Try direct filename match\n    let persona = this.personas.get(identifier);\n    \n    if (!persona) {\n      // Try with .md extension\n      persona = this.personas.get(`${identifier}.md`);\n    }\n    \n    if (!persona) {\n      // Search by name (case-insensitive)\n      persona = Array.from(this.personas.values()).find(p => \n        p.metadata.name.toLowerCase() === identifier.toLowerCase()\n      );\n    }\n    \n    if (!persona) {\n      // Search by unique_id\n      persona = Array.from(this.personas.values()).find(p => \n        p.unique_id === identifier\n      );\n    }\n    \n    return persona;\n  }\n  \n  /**\n   * Activate a persona\n   */\n  activatePersona(identifier: string): { success: boolean; message: string; persona?: Persona } {\n    const persona = this.findPersona(identifier);\n    \n    if (!persona) {\n      return {\n        success: false,\n        message: `Persona not found: \"${identifier}\"`\n      };\n    }\n    \n    this.activePersona = persona.filename;\n    \n    return {\n      success: true,\n      message: `Activated persona: ${persona.metadata.name}`,\n      persona\n    };\n  }\n  \n  /**\n   * Deactivate the current persona\n   */\n  deactivatePersona(): { success: boolean; message: string } {\n    if (!this.activePersona) {\n      return {\n        success: false,\n        message: \"No persona is currently active\"\n      };\n    }\n    \n    const persona = this.personas.get(this.activePersona);\n    const personaName = persona?.metadata.name || this.activePersona;\n    \n    this.activePersona = null;\n    \n    return {\n      success: true,\n      message: `Deactivated persona: ${personaName}`\n    };\n  }\n  \n  /**\n   * Get the active persona\n   */\n  getActivePersona(): Persona | null {\n    if (!this.activePersona) return null;\n    return this.personas.get(this.activePersona) || null;\n  }\n  \n  /**\n   * Get persona indicator for responses\n   */\n  getPersonaIndicator(): string {\n    if (!this.activePersona) return \"\";\n    const persona = this.personas.get(this.activePersona);\n    if (!persona) return \"\";\n    \n    return formatIndicator(this.indicatorConfig, {\n      name: persona.metadata.name,\n      version: persona.metadata.version,\n      author: persona.metadata.author,\n      category: persona.metadata.category\n    });\n  }\n  \n  /**\n   * Create a new persona\n   */\n  async createPersona(\n    name: string,\n    description: string,\n    category: string,\n    instructions: string\n  ): Promise<{ success: boolean; message: string; filename?: string }> {\n    try {\n      // Validate inputs\n      const cleanName = sanitizeInput(name, 50);\n      const cleanDescription = sanitizeInput(description, 200);\n      \n      if (!cleanName) {\n        return { success: false, message: \"Persona name cannot be empty\" };\n      }\n      \n      // Generate filename\n      const baseFilename = slugify(cleanName) + '.md';\n      const filename = validateFilename(baseFilename);\n      \n      // Check if already exists\n      if (this.personas.has(filename)) {\n        return { \n          success: false, \n          message: `A persona named \"${cleanName}\" already exists` \n        };\n      }\n      \n      // Create metadata\n      const metadata: PersonaMetadata = {\n        name: cleanName,\n        description: cleanDescription,\n        category: category || 'general',\n        version: '1.0',\n        author: this.getCurrentUserForAttribution() || undefined,\n        unique_id: generateUniqueId(cleanName, this.getCurrentUserForAttribution() || undefined),\n        triggers: this.generateTriggers(cleanName),\n        created_date: new Date().toISOString()\n      };\n      \n      // Create persona\n      const persona: Persona = {\n        metadata,\n        content: instructions,\n        filename,\n        unique_id: metadata.unique_id!\n      };\n      \n      // Validate\n      const validation = this.validator.validatePersona(persona);\n      if (!validation.valid) {\n        return {\n          success: false,\n          message: `Validation failed: ${validation.issues.join(', ')}`\n        };\n      }\n      \n      // Save to disk\n      await this.loader.savePersona(persona);\n      \n      // Add to memory\n      this.personas.set(filename, persona);\n      \n      return {\n        success: true,\n        message: `Created persona \"${cleanName}\" successfully`,\n        filename\n      };\n    } catch (error) {\n      return {\n        success: false,\n        message: `Failed to create persona: ${error instanceof Error ? error.message : String(error)}`\n      };\n    }\n  }\n  \n  /**\n   * Edit an existing persona\n   */\n  async editPersona(\n    personaName: string,\n    field: string,\n    value: string\n  ): Promise<{ success: boolean; message: string }> {\n    const persona = this.findPersona(personaName);\n    \n    if (!persona) {\n      return {\n        success: false,\n        message: `Persona not found: \"${personaName}\"`\n      };\n    }\n    \n    try {\n      const oldVersion = String(persona.metadata.version || '1.0');\n      \n      switch (field.toLowerCase()) {\n        case 'name':\n          persona.metadata.name = sanitizeInput(value, 50);\n          break;\n        case 'description':\n          persona.metadata.description = sanitizeInput(value, 200);\n          break;\n        case 'instructions':\n        case 'content':\n          persona.content = value;\n          break;\n        case 'category':\n          persona.metadata.category = value;\n          break;\n        case 'triggers':\n          persona.metadata.triggers = value.split(',').map(t => t.trim()).filter(t => t);\n          break;\n        case 'version':\n          persona.metadata.version = value;\n          break;\n        default:\n          return {\n            success: false,\n            message: `Unknown field: \"${field}\". Valid fields: name, description, instructions, category, triggers, version`\n          };\n      }\n      \n      // Auto-increment version if not explicitly setting version\n      if (field !== 'version') {\n        persona.metadata.version = this.incrementVersion(oldVersion);\n      }\n      \n      // Validate\n      const validation = this.validator.validatePersona(persona);\n      if (!validation.valid) {\n        return {\n          success: false,\n          message: `Validation failed: ${validation.issues.join(', ')}`\n        };\n      }\n      \n      // Save changes\n      await this.loader.savePersona(persona);\n      \n      return {\n        success: true,\n        message: `Updated ${field} for \"${persona.metadata.name}\" (v${persona.metadata.version})`\n      };\n    } catch (error) {\n      return {\n        success: false,\n        message: `Failed to edit persona: ${error instanceof Error ? error.message : String(error)}`\n      };\n    }\n  }\n  \n  /**\n   * Validate a persona\n   */\n  validatePersona(identifier: string): { found: boolean; validation?: ReturnType<PersonaValidator['validatePersona']> } {\n    const persona = this.findPersona(identifier);\n    \n    if (!persona) {\n      return { found: false };\n    }\n    \n    return {\n      found: true,\n      validation: this.validator.validatePersona(persona)\n    };\n  }\n  \n  /**\n   * Set current user identity\n   */\n  setUserIdentity(username: string | null, email?: string): void {\n    this.currentUser = username;\n    \n    if (username) {\n      process.env.DOLLHOUSE_USER = username;\n      if (email) {\n        process.env.DOLLHOUSE_EMAIL = email;\n      }\n    } else {\n      delete process.env.DOLLHOUSE_USER;\n      delete process.env.DOLLHOUSE_EMAIL;\n    }\n  }\n  \n  /**\n   * Get current user identity\n   */\n  getUserIdentity(): { username: string | null; email: string | null } {\n    return {\n      username: process.env.DOLLHOUSE_USER || null,\n      email: process.env.DOLLHOUSE_EMAIL || null\n    };\n  }\n  \n  /**\n   * Clear user identity\n   */\n  clearUserIdentity(): void {\n    this.setUserIdentity(null);\n  }\n  \n  /**\n   * Update indicator configuration\n   */\n  updateIndicatorConfig(config: IndicatorConfig): void {\n    this.indicatorConfig = config;\n  }\n  \n  /**\n   * Get current indicator configuration\n   */\n  getIndicatorConfig(): IndicatorConfig {\n    return this.indicatorConfig;\n  }\n  \n  /**\n   * Helper to get current user for attribution\n   */\n  private getCurrentUserForAttribution(): string {\n    return this.currentUser || process.env.DOLLHOUSE_USER || generateAnonymousId();\n  }\n  \n  /**\n   * Generate trigger keywords from persona name\n   */\n  private generateTriggers(name: string): string[] {\n    const words = name.toLowerCase().split(/\\s+/);\n    const triggers = [...words];\n    \n    // Add the full name as a trigger\n    if (words.length > 1) {\n      triggers.push(name.toLowerCase());\n    }\n    \n    // Remove duplicates\n    return [...new Set(triggers)].filter(t => t.length > 2);\n  }\n  \n  /**\n   * Increment version number\n   */\n  private incrementVersion(version: string | number): string {\n    // Handle both string and number versions\n    const versionStr = String(version);\n    const parts = versionStr.split('.');\n    \n    // If it's just a number like \"1\", make it \"1.0\" \n    if (parts.length === 1) {\n      parts.push('0');\n    }\n    \n    const patch = parseInt(parts[parts.length - 1]) || 0;\n    parts[parts.length - 1] = (patch + 1).toString();\n    return parts.join('.');\n  }\n}"]}

package/dist/src/persona/PersonaValidator.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Persona validation and quality checks
+ */
+import { Persona, PersonaMetadata } from '../types/persona.js';
+export interface ValidationResult {
+    valid: boolean;
+    issues: string[];
+    warnings: string[];
+    report: string;
+}
+export declare class PersonaValidator {
+    /**
+     * Validate a persona's metadata and content
+     */
+    validatePersona(persona: Persona): ValidationResult;
+    /**
+     * Validate persona metadata only
+     */
+    validateMetadata(metadata: PersonaMetadata): ValidationResult;
+    /**
+     * Generate a validation report
+     */
+    private generateReport;
+    /**
+     * Check if a persona name is valid
+     */
+    isValidPersonaName(name: string): boolean;
+    /**
+     * Suggest improvements for a persona
+     */
+    suggestImprovements(persona: Persona): string[];
+}
+//# sourceMappingURL=PersonaValidator.d.ts.map

package/dist/src/persona/PersonaValidator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersonaValidator.d.ts","sourceRoot":"","sources":["../../../src/persona/PersonaValidator.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAG/D,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,gBAAgB;IAE3B;;OAEG;IACH,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,gBAAgB;IA4DnD;;OAEG;IACH,gBAAgB,CAAC,QAAQ,EAAE,eAAe,GAAG,gBAAgB;IAuB7D;;OAEG;IACH,OAAO,CAAC,cAAc;IAuCtB;;OAEG;IACH,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAOzC;;OAEG;IACH,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,EAAE;CA0BhD"}

package/dist/src/persona/PersonaValidator.js

@@ -0,0 +1,157 @@
+/**
+ * Persona validation and quality checks
+ */
+import { VALID_CATEGORIES } from '../config/constants.js';
+export class PersonaValidator {
+    /**
+     * Validate a persona's metadata and content
+     */
+    validatePersona(persona) {
+        const issues = [];
+        const warnings = [];
+        const metadata = persona.metadata;
+        // Required field checks
+        if (!metadata.name || metadata.name.trim().length === 0) {
+            issues.push("Missing or empty 'name' field");
+        }
+        if (!metadata.description || metadata.description.trim().length === 0) {
+            issues.push("Missing or empty 'description' field");
+        }
+        if (!persona.content || persona.content.trim().length < 50) {
+            issues.push("Persona content is too short (minimum 50 characters)");
+        }
+        // Category validation
+        if (metadata.category && !VALID_CATEGORIES.includes(metadata.category)) {
+            issues.push(`Invalid category '${metadata.category}'. Must be one of: ${VALID_CATEGORIES.join(', ')}`);
+        }
+        // Age rating validation
+        const validAgeRatings = ['all', '13+', '18+'];
+        if (metadata.age_rating && !validAgeRatings.includes(metadata.age_rating)) {
+            warnings.push(`Invalid age_rating '${metadata.age_rating}'. Should be one of: ${validAgeRatings.join(', ')}`);
+        }
+        // Optional field warnings
+        if (!metadata.triggers || metadata.triggers.length === 0) {
+            warnings.push("No trigger keywords defined - users may have difficulty finding this persona");
+        }
+        if (!metadata.version) {
+            warnings.push("No version specified - defaulting to '1.0'");
+        }
+        if (!metadata.unique_id) {
+            warnings.push("No unique_id - one will be generated automatically");
+        }
+        // Content quality checks
+        if (persona.content.length > 5000) {
+            warnings.push("Persona content is very long - consider breaking it into sections");
+        }
+        if (metadata.name && metadata.name.length > 50) {
+            warnings.push("Persona name is very long - consider shortening for better display");
+        }
+        if (metadata.description && metadata.description.length > 200) {
+            warnings.push("Description is very long - consider keeping it under 200 characters");
+        }
+        // Generate validation report
+        const report = this.generateReport(persona, issues, warnings);
+        return {
+            valid: issues.length === 0,
+            issues,
+            warnings,
+            report
+        };
+    }
+    /**
+     * Validate persona metadata only
+     */
+    validateMetadata(metadata) {
+        const issues = [];
+        const warnings = [];
+        if (!metadata.name || metadata.name.trim().length === 0) {
+            issues.push("Missing or empty 'name' field");
+        }
+        if (!metadata.description || metadata.description.trim().length === 0) {
+            issues.push("Missing or empty 'description' field");
+        }
+        if (metadata.category && !VALID_CATEGORIES.includes(metadata.category)) {
+            issues.push(`Invalid category '${metadata.category}'`);
+        }
+        return {
+            valid: issues.length === 0,
+            issues,
+            warnings,
+            report: ''
+        };
+    }
+    /**
+     * Generate a validation report
+     */
+    generateReport(persona, issues, warnings) {
+        const metadata = persona.metadata;
+        let report = `📋 **Validation Report: ${metadata.name}**\n\n`;
+        if (issues.length === 0 && warnings.length === 0) {
+            report += `✅ **All Checks Passed!**\n\n` +
+                `🎭 **Persona:** ${metadata.name}\n` +
+                `📁 **Category:** ${metadata.category || 'general'}\n` +
+                `📊 **Version:** ${metadata.version || '1.0'}\n` +
+                `📝 **Content Length:** ${persona.content.length} characters\n` +
+                `🔗 **Triggers:** ${metadata.triggers?.length || 0} keywords\n\n` +
+                `This persona meets all validation requirements and is ready for use!`;
+        }
+        else {
+            if (issues.length > 0) {
+                report += `❌ **Issues Found (${issues.length}):**\n`;
+                issues.forEach((issue, i) => {
+                    report += `   ${i + 1}. ${issue}\n`;
+                });
+                report += '\n';
+            }
+            if (warnings.length > 0) {
+                report += `⚠️ **Warnings (${warnings.length}):**\n`;
+                warnings.forEach((warning, i) => {
+                    report += `   ${i + 1}. ${warning}\n`;
+                });
+                report += '\n';
+            }
+            if (issues.length > 0) {
+                report += `💡 **Fix Required:** Please address the issues above before using this persona.\n`;
+            }
+            else {
+                report += `💚 **Status:** This persona is valid but could be improved. Consider addressing the warnings.\n`;
+            }
+        }
+        return report;
+    }
+    /**
+     * Check if a persona name is valid
+     */
+    isValidPersonaName(name) {
+        if (!name || name.trim().length === 0)
+            return false;
+        if (name.length > 50)
+            return false;
+        // Check for invalid characters
+        return !/[<>:"/\\|?*]/.test(name);
+    }
+    /**
+     * Suggest improvements for a persona
+     */
+    suggestImprovements(persona) {
+        const suggestions = [];
+        const metadata = persona.metadata;
+        if (!metadata.triggers || metadata.triggers.length < 3) {
+            suggestions.push("Add more trigger keywords to improve discoverability");
+        }
+        if (!metadata.author) {
+            suggestions.push("Add an author field for proper attribution");
+        }
+        if (persona.content.length < 200) {
+            suggestions.push("Expand the persona instructions for better AI guidance");
+        }
+        if (!metadata.version) {
+            suggestions.push("Add a version number for tracking updates");
+        }
+        if (!metadata.category || metadata.category === 'general') {
+            suggestions.push("Choose a specific category for better organization");
+        }
+        return suggestions;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PersonaValidator.js","sourceRoot":"","sources":["../../../src/persona/PersonaValidator.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Persona validation and quality checks\n */\n\nimport { Persona, PersonaMetadata } from '../types/persona.js';\nimport { VALID_CATEGORIES } from '../config/constants.js';\n\nexport interface ValidationResult {\n  valid: boolean;\n  issues: string[];\n  warnings: string[];\n  report: string;\n}\n\nexport class PersonaValidator {\n  \n  /**\n   * Validate a persona's metadata and content\n   */\n  validatePersona(persona: Persona): ValidationResult {\n    const issues: string[] = [];\n    const warnings: string[] = [];\n    const metadata = persona.metadata;\n    \n    // Required field checks\n    if (!metadata.name || metadata.name.trim().length === 0) {\n      issues.push(\"Missing or empty 'name' field\");\n    }\n    if (!metadata.description || metadata.description.trim().length === 0) {\n      issues.push(\"Missing or empty 'description' field\");\n    }\n    if (!persona.content || persona.content.trim().length < 50) {\n      issues.push(\"Persona content is too short (minimum 50 characters)\");\n    }\n    \n    // Category validation\n    if (metadata.category && !VALID_CATEGORIES.includes(metadata.category)) {\n      issues.push(`Invalid category '${metadata.category}'. Must be one of: ${VALID_CATEGORIES.join(', ')}`);\n    }\n    \n    // Age rating validation\n    const validAgeRatings = ['all', '13+', '18+'];\n    if (metadata.age_rating && !validAgeRatings.includes(metadata.age_rating)) {\n      warnings.push(`Invalid age_rating '${metadata.age_rating}'. Should be one of: ${validAgeRatings.join(', ')}`);\n    }\n    \n    // Optional field warnings\n    if (!metadata.triggers || metadata.triggers.length === 0) {\n      warnings.push(\"No trigger keywords defined - users may have difficulty finding this persona\");\n    }\n    if (!metadata.version) {\n      warnings.push(\"No version specified - defaulting to '1.0'\");\n    }\n    if (!metadata.unique_id) {\n      warnings.push(\"No unique_id - one will be generated automatically\");\n    }\n    \n    // Content quality checks\n    if (persona.content.length > 5000) {\n      warnings.push(\"Persona content is very long - consider breaking it into sections\");\n    }\n    if (metadata.name && metadata.name.length > 50) {\n      warnings.push(\"Persona name is very long - consider shortening for better display\");\n    }\n    if (metadata.description && metadata.description.length > 200) {\n      warnings.push(\"Description is very long - consider keeping it under 200 characters\");\n    }\n    \n    // Generate validation report\n    const report = this.generateReport(persona, issues, warnings);\n    \n    return {\n      valid: issues.length === 0,\n      issues,\n      warnings,\n      report\n    };\n  }\n  \n  /**\n   * Validate persona metadata only\n   */\n  validateMetadata(metadata: PersonaMetadata): ValidationResult {\n    const issues: string[] = [];\n    const warnings: string[] = [];\n    \n    if (!metadata.name || metadata.name.trim().length === 0) {\n      issues.push(\"Missing or empty 'name' field\");\n    }\n    if (!metadata.description || metadata.description.trim().length === 0) {\n      issues.push(\"Missing or empty 'description' field\");\n    }\n    \n    if (metadata.category && !VALID_CATEGORIES.includes(metadata.category)) {\n      issues.push(`Invalid category '${metadata.category}'`);\n    }\n    \n    return {\n      valid: issues.length === 0,\n      issues,\n      warnings,\n      report: ''\n    };\n  }\n  \n  /**\n   * Generate a validation report\n   */\n  private generateReport(persona: Persona, issues: string[], warnings: string[]): string {\n    const metadata = persona.metadata;\n    let report = `📋 **Validation Report: ${metadata.name}**\\n\\n`;\n    \n    if (issues.length === 0 && warnings.length === 0) {\n      report += `✅ **All Checks Passed!**\\n\\n` +\n        `🎭 **Persona:** ${metadata.name}\\n` +\n        `📁 **Category:** ${metadata.category || 'general'}\\n` +\n        `📊 **Version:** ${metadata.version || '1.0'}\\n` +\n        `📝 **Content Length:** ${persona.content.length} characters\\n` +\n        `🔗 **Triggers:** ${metadata.triggers?.length || 0} keywords\\n\\n` +\n        `This persona meets all validation requirements and is ready for use!`;\n    } else {\n      if (issues.length > 0) {\n        report += `❌ **Issues Found (${issues.length}):**\\n`;\n        issues.forEach((issue, i) => {\n          report += `   ${i + 1}. ${issue}\\n`;\n        });\n        report += '\\n';\n      }\n      \n      if (warnings.length > 0) {\n        report += `⚠️ **Warnings (${warnings.length}):**\\n`;\n        warnings.forEach((warning, i) => {\n          report += `   ${i + 1}. ${warning}\\n`;\n        });\n        report += '\\n';\n      }\n      \n      if (issues.length > 0) {\n        report += `💡 **Fix Required:** Please address the issues above before using this persona.\\n`;\n      } else {\n        report += `💚 **Status:** This persona is valid but could be improved. Consider addressing the warnings.\\n`;\n      }\n    }\n    \n    return report;\n  }\n  \n  /**\n   * Check if a persona name is valid\n   */\n  isValidPersonaName(name: string): boolean {\n    if (!name || name.trim().length === 0) return false;\n    if (name.length > 50) return false;\n    // Check for invalid characters\n    return !/[<>:\"/\\\\|?*]/.test(name);\n  }\n  \n  /**\n   * Suggest improvements for a persona\n   */\n  suggestImprovements(persona: Persona): string[] {\n    const suggestions: string[] = [];\n    const metadata = persona.metadata;\n    \n    if (!metadata.triggers || metadata.triggers.length < 3) {\n      suggestions.push(\"Add more trigger keywords to improve discoverability\");\n    }\n    \n    if (!metadata.author) {\n      suggestions.push(\"Add an author field for proper attribution\");\n    }\n    \n    if (persona.content.length < 200) {\n      suggestions.push(\"Expand the persona instructions for better AI guidance\");\n    }\n    \n    if (!metadata.version) {\n      suggestions.push(\"Add a version number for tracking updates\");\n    }\n    \n    if (!metadata.category || metadata.category === 'general') {\n      suggestions.push(\"Choose a specific category for better organization\");\n    }\n    \n    return suggestions;\n  }\n}"]}

package/dist/src/persona/export-import/PersonaExporter.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Persona export functionality
+ */
+import { Persona } from '../../types/persona.js';
+export interface ExportedPersona {
+    metadata: any;
+    content: string;
+    filename: string;
+    exportedAt: string;
+    exportedBy?: string;
+}
+export interface ExportBundle {
+    version: string;
+    exportedAt: string;
+    exportedBy?: string;
+    personaCount: number;
+    personas: ExportedPersona[];
+}
+export declare class PersonaExporter {
+    private currentUser;
+    constructor(currentUser: string | null);
+    /**
+     * Export a single persona to JSON format
+     */
+    exportPersona(persona: Persona): ExportedPersona;
+    /**
+     * Export multiple personas to a bundle
+     */
+    exportBundle(personas: Persona[], includeDefaults?: boolean): ExportBundle;
+    /**
+     * Convert export to base64 for easy sharing
+     */
+    toBase64(data: ExportedPersona | ExportBundle): string;
+    /**
+     * Format export result for display
+     */
+    formatExportResult(persona: Persona, base64: string): string;
+    /**
+     * Format bundle export result
+     */
+    formatBundleResult(bundle: ExportBundle, base64: string): string;
+}
+//# sourceMappingURL=PersonaExporter.d.ts.map

package/dist/src/persona/export-import/PersonaExporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersonaExporter.d.ts","sourceRoot":"","sources":["../../../../src/persona/export-import/PersonaExporter.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAKjD,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,GAAG,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,eAAe,EAAE,CAAC;CAC7B;AAED,qBAAa,eAAe;IAExB,OAAO,CAAC,WAAW;gBAAX,WAAW,EAAE,MAAM,GAAG,IAAI;IAGpC;;OAEG;IACH,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,eAAe;IAgBhD;;OAEG;IACH,YAAY,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,eAAe,GAAE,OAAc,GAAG,YAAY;IAchF;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,eAAe,GAAG,YAAY,GAAG,MAAM;IAKtD;;OAEG;IACH,kBAAkB,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM;IAmB5D;;OAEG;IACH,kBAAkB,CAAC,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM;CA0BjE"}