@dollhousemcp/mcp-server 1.3.0

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

@@ -0,0 +1,112 @@
+/**
+ * Core persona management operations
+ */
+import { Persona } from '../types/persona.js';
+import { PersonaValidator } from './PersonaValidator.js';
+import { IndicatorConfig } from '../config/indicator-config.js';
+export declare class PersonaManager {
+    private personas;
+    private activePersona;
+    private currentUser;
+    private loader;
+    private validator;
+    private indicatorConfig;
+    constructor(personasDir: string, indicatorConfig: IndicatorConfig);
+    /**
+     * Initialize and load all personas
+     */
+    initialize(): Promise<void>;
+    /**
+     * Reload all personas from disk
+     */
+    reload(): Promise<void>;
+    /**
+     * Get all loaded personas
+     */
+    getAllPersonas(): Map<string, Persona>;
+    /**
+     * Find a persona by identifier (filename, name, or unique_id)
+     */
+    findPersona(identifier: string): Persona | undefined;
+    /**
+     * Activate a persona
+     */
+    activatePersona(identifier: string): {
+        success: boolean;
+        message: string;
+        persona?: Persona;
+    };
+    /**
+     * Deactivate the current persona
+     */
+    deactivatePersona(): {
+        success: boolean;
+        message: string;
+    };
+    /**
+     * Get the active persona
+     */
+    getActivePersona(): Persona | null;
+    /**
+     * Get persona indicator for responses
+     */
+    getPersonaIndicator(): string;
+    /**
+     * Create a new persona
+     */
+    createPersona(name: string, description: string, category: string, instructions: string): Promise<{
+        success: boolean;
+        message: string;
+        filename?: string;
+    }>;
+    /**
+     * Edit an existing persona
+     */
+    editPersona(personaName: string, field: string, value: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Validate a persona
+     */
+    validatePersona(identifier: string): {
+        found: boolean;
+        validation?: ReturnType<PersonaValidator['validatePersona']>;
+    };
+    /**
+     * Set current user identity
+     */
+    setUserIdentity(username: string | null, email?: string): void;
+    /**
+     * Get current user identity
+     */
+    getUserIdentity(): {
+        username: string | null;
+        email: string | null;
+    };
+    /**
+     * Clear user identity
+     */
+    clearUserIdentity(): void;
+    /**
+     * Update indicator configuration
+     */
+    updateIndicatorConfig(config: IndicatorConfig): void;
+    /**
+     * Get current indicator configuration
+     */
+    getIndicatorConfig(): IndicatorConfig;
+    /**
+     * Helper to get current user for attribution
+     */
+    private getCurrentUserForAttribution;
+    /**
+     * Generate trigger keywords from persona name
+     */
+    private generateTriggers;
+    /**
+     * Increment version number
+     */
+    private incrementVersion;
+}
+//# sourceMappingURL=PersonaManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PersonaManager.d.ts","sourceRoot":"","sources":["../../../../src/persona/PersonaManager.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,EAAE,OAAO,EAAmB,MAAM,qBAAqB,CAAC;AAE/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAGzD,OAAO,EAAE,eAAe,EAAmB,MAAM,+BAA+B,CAAC;AAEjF,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAmC;IACnD,OAAO,CAAC,aAAa,CAAuB;IAC5C,OAAO,CAAC,WAAW,CAAuB;IAC1C,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,SAAS,CAAmB;IACpC,OAAO,CAAC,eAAe,CAAkB;gBAE7B,WAAW,EAAE,MAAM,EAAE,eAAe,EAAE,eAAe;IAMjE;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAIjC;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAM7B;;OAEG;IACH,cAAc,IAAI,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC;IAItC;;OAEG;IACH,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IA0BpD;;OAEG;IACH,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE;IAmB7F;;OAEG;IACH,iBAAiB,IAAI;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;IAmB1D;;OAEG;IACH,gBAAgB,IAAI,OAAO,GAAG,IAAI;IAKlC;;OAEG;IACH,mBAAmB,IAAI,MAAM;IAa7B;;OAEG;IACG,aAAa,CACjB,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAsEpE;;OAEG;IACG,WAAW,CACf,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAqEjD;;OAEG;IACH,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,UAAU,CAAC,EAAE,UAAU,CAAC,gBAAgB,CAAC,iBAAiB,CAAC,CAAC,CAAA;KAAE;IAarH;;OAEG;IACH,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;IAc9D;;OAEG;IACH,eAAe,IAAI;QAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE;IAOpE;;OAEG;IACH,iBAAiB,IAAI,IAAI;IAIzB;;OAEG;IACH,qBAAqB,CAAC,MAAM,EAAE,eAAe,GAAG,IAAI;IAIpD;;OAEG;IACH,kBAAkB,IAAI,eAAe;IAIrC;;OAEG;IACH,OAAO,CAAC,4BAA4B;IAIpC;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAaxB;;OAEG;IACH,OAAO,CAAC,gBAAgB;CAczB"}

package/dist/test/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/test/src/persona/PersonaValidator.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Persona validation and quality checks
+ */
+import { Persona, PersonaMetadata } from '../types/persona.js';
+export interface PersonaValidationResult {
+    valid: boolean;
+    issues: string[];
+    warnings: string[];
+    report: string;
+}
+export declare class PersonaValidator {
+    /**
+     * Validate a persona's metadata and content
+     */
+    validatePersona(persona: Persona): PersonaValidationResult;
+    /**
+     * Validate persona metadata only
+     */
+    validateMetadata(metadata: PersonaMetadata): PersonaValidationResult;
+    /**
+     * 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/test/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,uBAAuB;IACtC,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,uBAAuB;IA4D1D;;OAEG;IACH,gBAAgB,CAAC,QAAQ,EAAE,eAAe,GAAG,uBAAuB;IAuBpE;;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"}