@dollhousemcp/mcp-server 1.3.0

package/dist/test/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 PersonaValidationResult {\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): PersonaValidationResult {\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): PersonaValidationResult {\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/test/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/test/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"}

package/dist/test/src/persona/export-import/PersonaExporter.js

@@ -0,0 +1,99 @@
+/**
+ * Persona export functionality
+ */
+import { isDefaultPersona } from '../../constants/defaultPersonas.js';
+import { MAX_PERSONA_SIZE } from '../../constants/limits.js';
+export class PersonaExporter {
+    currentUser;
+    constructor(currentUser) {
+        this.currentUser = currentUser;
+    }
+    /**
+     * Export a single persona to JSON format
+     */
+    exportPersona(persona) {
+        // Check size limit
+        const size = JSON.stringify(persona).length;
+        if (size > MAX_PERSONA_SIZE) {
+            throw new Error(`Persona too large (${Math.round(size / 1024)}KB). Maximum size is ${Math.round(MAX_PERSONA_SIZE / 1024)}KB`);
+        }
+        return {
+            metadata: persona.metadata,
+            content: persona.content,
+            filename: persona.filename,
+            exportedAt: new Date().toISOString(),
+            exportedBy: this.currentUser || undefined
+        };
+    }
+    /**
+     * Export multiple personas to a bundle
+     */
+    exportBundle(personas, includeDefaults = true) {
+        const filteredPersonas = includeDefaults
+            ? personas
+            : personas.filter(p => !isDefaultPersona(p.filename));
+        return {
+            version: '1.0.0',
+            exportedAt: new Date().toISOString(),
+            exportedBy: this.currentUser || undefined,
+            personaCount: filteredPersonas.length,
+            personas: filteredPersonas.map(p => this.exportPersona(p))
+        };
+    }
+    /**
+     * Convert export to base64 for easy sharing
+     */
+    toBase64(data) {
+        const json = JSON.stringify(data, null, 2);
+        return Buffer.from(json).toString('base64');
+    }
+    /**
+     * Format export result for display
+     */
+    formatExportResult(persona, base64) {
+        return `✅ Successfully exported "${persona.metadata.name}"
+
+📦 Export Details:
+- Filename: ${persona.filename}
+- Version: ${persona.metadata.version || '1.0'}
+- Author: ${persona.metadata.author || 'unknown'}
+- Size: ${base64.length} characters (base64)
+
+📋 Export Data (Copy this to share):
+\`\`\`
+${base64}
+\`\`\`
+
+💡 To import this persona:
+- Use: import_persona "<paste the base64 data here>"
+- Or save to a file and use: import_persona "/path/to/file.json"`;
+    }
+    /**
+     * Format bundle export result
+     */
+    formatBundleResult(bundle, base64) {
+        const personaList = bundle.personas
+            .map(p => `  - ${p.metadata.name} (${p.filename})`)
+            .join('\n');
+        return `✅ Successfully exported ${bundle.personaCount} personas
+
+📦 Bundle Details:
+- Export Version: ${bundle.version}
+- Exported At: ${new Date(bundle.exportedAt).toLocaleString()}
+- Exported By: ${bundle.exportedBy || 'anonymous'}
+- Total Size: ${base64.length} characters (base64)
+
+📋 Personas Included:
+${personaList}
+
+💾 Export Data (Copy this to share):
+\`\`\`
+${base64}
+\`\`\`
+
+💡 To import this bundle:
+- Use: import_persona "<paste the base64 data here>"
+- Or save to a file and use: import_persona "/path/to/bundle.json"`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/test/src/persona/export-import/PersonaImporter.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Persona import functionality with validation
+ */
+import { Persona } from '../../types/persona.js';
+export interface ImportResult {
+    success: boolean;
+    message: string;
+    persona?: Persona;
+    filename?: string;
+    conflicts?: string[];
+}
+export declare class PersonaImporter {
+    private personasDir;
+    private currentUser;
+    constructor(personasDir: string, currentUser: string | null);
+    /**
+     * Import a persona from various sources
+     */
+    importPersona(source: string, existingPersonas: Map<string, Persona>, overwrite?: boolean): Promise<ImportResult>;
+    /**
+     * Import from file path
+     */
+    private importFromFile;
+    /**
+     * Import from base64 string
+     */
+    private importFromBase64;
+    /**
+     * Import from raw markdown content
+     */
+    private importFromMarkdown;
+    /**
+     * Import a bundle of personas
+     */
+    private importBundle;
+    /**
+     * Create persona from exported data
+     */
+    private createPersonaFromExport;
+    /**
+     * Validate and enrich metadata
+     */
+    private validateAndEnrichMetadata;
+    /**
+     * Find conflicts with existing personas
+     */
+    private findConflicts;
+    /**
+     * Check if string is base64
+     */
+    private isBase64;
+    /**
+     * Type guard for ExportedPersona
+     */
+    private isExportedPersona;
+    /**
+     * Type guard for ExportBundle
+     */
+    private isExportBundle;
+    /**
+     * Format bundle import results
+     */
+    private formatBundleImportResult;
+}
+//# sourceMappingURL=PersonaImporter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PersonaImporter.d.ts","sourceRoot":"","sources":["../../../../../src/persona/export-import/PersonaImporter.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,OAAO,EAAE,OAAO,EAAmB,MAAM,wBAAwB,CAAC;AASlE,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,qBAAa,eAAe;IAExB,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,WAAW;gBADX,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GAAG,IAAI;IAGpC;;OAEG;IACG,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,SAAS,UAAQ,GAAG,OAAO,CAAC,YAAY,CAAC;IA+CrH;;OAEG;YACW,cAAc;IA+B5B;;OAEG;YACW,gBAAgB;IAgB9B;;OAEG;YACW,kBAAkB;IAmChC;;OAEG;YACW,YAAY;IA4B1B;;OAEG;YACW,uBAAuB;IA8DrC;;OAEG;YACW,yBAAyB;IAuBvC;;OAEG;IACH,OAAO,CAAC,aAAa;IAYrB;;OAEG;IACH,OAAO,CAAC,QAAQ;IAUhB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAOzB;;OAEG;IACH,OAAO,CAAC,cAAc;IAOtB;;OAEG;IACH,OAAO,CAAC,wBAAwB;CAejC"}