cowork-os 0.3.21

package/dist/electron/electron/settings/personality-manager.js

@@ -0,0 +1,724 @@
+"use strict";
+/**
+ * Personality Settings Manager
+ *
+ * Manages agent personality preferences including:
+ * - Base personality (professional, friendly, etc.)
+ * - Famous assistant personas (Jarvis, Friday, etc.)
+ * - Response style preferences (emoji, length, etc.)
+ * - Personality quirks (catchphrases, sign-offs)
+ * - Relationship data (user name, milestones)
+ *
+ * Settings are stored encrypted in the database using SecureSettingsRepository.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersonalityManager = void 0;
+const electron_1 = require("electron");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const events_1 = require("events");
+const types_1 = require("../../shared/types");
+const SecureSettingsRepository_1 = require("../database/SecureSettingsRepository");
+const LEGACY_SETTINGS_FILE = 'personality-settings.json';
+const DEFAULT_AGENT_NAME = 'CoWork';
+const DEFAULT_SETTINGS = {
+    activePersonality: 'professional',
+    customPrompt: '',
+    customName: 'Custom Assistant',
+    agentName: DEFAULT_AGENT_NAME,
+    activePersona: 'companion',
+    responseStyle: types_1.DEFAULT_RESPONSE_STYLE,
+    quirks: types_1.DEFAULT_QUIRKS,
+    relationship: types_1.DEFAULT_RELATIONSHIP,
+};
+// Milestone thresholds for celebrations
+const MILESTONES = [1, 10, 25, 50, 100, 250, 500, 1000];
+// Event emitter for personality settings changes
+const personalityEvents = new events_1.EventEmitter();
+class PersonalityManager {
+    /**
+     * Subscribe to settings changed events.
+     * The callback receives the updated settings.
+     */
+    static onSettingsChanged(callback) {
+        personalityEvents.on('settingsChanged', callback);
+        return () => personalityEvents.off('settingsChanged', callback);
+    }
+    /**
+     * Remove all event listeners (useful for testing)
+     */
+    static removeAllListeners() {
+        personalityEvents.removeAllListeners();
+    }
+    /**
+     * Emit a settings changed event
+     */
+    static emitSettingsChanged() {
+        if (this.cachedSettings) {
+            personalityEvents.emit('settingsChanged', this.cachedSettings);
+        }
+    }
+    /**
+     * Initialize the PersonalityManager
+     */
+    static initialize() {
+        if (this.initialized) {
+            return; // Already initialized
+        }
+        const userDataPath = electron_1.app.getPath('userData');
+        this.legacySettingsPath = path.join(userDataPath, LEGACY_SETTINGS_FILE);
+        this.initialized = true;
+        console.log('[PersonalityManager] Initialized');
+        // Migrate from legacy JSON file to encrypted database
+        this.migrateFromLegacyFile();
+    }
+    /**
+     * Migrate settings from legacy JSON file to encrypted database
+     */
+    static migrateFromLegacyFile() {
+        if (this.migrationCompleted)
+            return;
+        try {
+            // Check if SecureSettingsRepository is initialized
+            if (!SecureSettingsRepository_1.SecureSettingsRepository.isInitialized()) {
+                console.log('[PersonalityManager] SecureSettingsRepository not yet initialized, skipping migration');
+                return;
+            }
+            const repository = SecureSettingsRepository_1.SecureSettingsRepository.getInstance();
+            // Check if already migrated to database
+            if (repository.exists('personality')) {
+                this.migrationCompleted = true;
+                return;
+            }
+            // Check if legacy file exists
+            if (!fs.existsSync(this.legacySettingsPath)) {
+                console.log('[PersonalityManager] No legacy settings file found');
+                this.migrationCompleted = true;
+                return;
+            }
+            console.log('[PersonalityManager] Migrating settings from legacy JSON file to encrypted database...');
+            // Create backup before migration
+            const backupPath = this.legacySettingsPath + '.migration-backup';
+            fs.copyFileSync(this.legacySettingsPath, backupPath);
+            try {
+                // Read legacy settings
+                const data = fs.readFileSync(this.legacySettingsPath, 'utf-8');
+                const parsed = JSON.parse(data);
+                const legacySettings = {
+                    ...DEFAULT_SETTINGS,
+                    ...parsed,
+                    responseStyle: { ...types_1.DEFAULT_RESPONSE_STYLE, ...parsed.responseStyle },
+                    quirks: { ...types_1.DEFAULT_QUIRKS, ...parsed.quirks },
+                    relationship: { ...types_1.DEFAULT_RELATIONSHIP, ...parsed.relationship },
+                };
+                // Save to encrypted database
+                repository.save('personality', legacySettings);
+                console.log('[PersonalityManager] Settings migrated to encrypted database');
+                // Migration successful - delete backup and original
+                fs.unlinkSync(backupPath);
+                fs.unlinkSync(this.legacySettingsPath);
+                console.log('[PersonalityManager] Migration complete, cleaned up legacy files');
+                this.migrationCompleted = true;
+            }
+            catch (migrationError) {
+                console.error('[PersonalityManager] Migration failed, backup preserved at:', backupPath);
+                throw migrationError;
+            }
+        }
+        catch (error) {
+            console.error('[PersonalityManager] Migration failed:', error);
+        }
+    }
+    /**
+     * Ensure the manager is initialized before use
+     */
+    static ensureInitialized() {
+        if (!this.initialized) {
+            throw new Error('[PersonalityManager] Not initialized. Call PersonalityManager.initialize() first.');
+        }
+    }
+    /**
+     * Load settings from encrypted database (with caching)
+     */
+    static loadSettings() {
+        this.ensureInitialized();
+        if (this.cachedSettings) {
+            return this.cachedSettings;
+        }
+        // Deep copy DEFAULT_SETTINGS to avoid mutating the original constants
+        let settings = {
+            ...DEFAULT_SETTINGS,
+            responseStyle: { ...types_1.DEFAULT_RESPONSE_STYLE },
+            quirks: { ...types_1.DEFAULT_QUIRKS },
+            relationship: { ...types_1.DEFAULT_RELATIONSHIP },
+        };
+        try {
+            // Try to load from encrypted database
+            if (SecureSettingsRepository_1.SecureSettingsRepository.isInitialized()) {
+                const repository = SecureSettingsRepository_1.SecureSettingsRepository.getInstance();
+                const stored = repository.load('personality');
+                if (stored) {
+                    settings = {
+                        ...DEFAULT_SETTINGS,
+                        ...stored,
+                        responseStyle: { ...types_1.DEFAULT_RESPONSE_STYLE, ...stored.responseStyle },
+                        quirks: { ...types_1.DEFAULT_QUIRKS, ...stored.quirks },
+                        relationship: { ...types_1.DEFAULT_RELATIONSHIP, ...stored.relationship },
+                    };
+                }
+            }
+            // Validate values
+            if (!isValidPersonalityId(settings.activePersonality)) {
+                settings.activePersonality = DEFAULT_SETTINGS.activePersonality;
+            }
+            if (!isValidPersonaId(settings.activePersona)) {
+                settings.activePersona = DEFAULT_SETTINGS.activePersona;
+            }
+        }
+        catch (error) {
+            console.error('[PersonalityManager] Failed to load settings:', error);
+            // Deep copy DEFAULT_SETTINGS to avoid mutating the original constants
+            settings = {
+                ...DEFAULT_SETTINGS,
+                responseStyle: { ...types_1.DEFAULT_RESPONSE_STYLE },
+                quirks: { ...types_1.DEFAULT_QUIRKS },
+                relationship: { ...types_1.DEFAULT_RELATIONSHIP },
+            };
+        }
+        this.cachedSettings = settings;
+        return settings;
+    }
+    /**
+     * Save settings to encrypted database
+     */
+    static saveSettings(settings) {
+        try {
+            if (!SecureSettingsRepository_1.SecureSettingsRepository.isInitialized()) {
+                throw new Error('SecureSettingsRepository not initialized');
+            }
+            // Load existing settings to preserve fields not being updated
+            const existingSettings = this.loadSettings();
+            // Validate and merge with existing settings
+            const validatedSettings = {
+                activePersonality: isValidPersonalityId(settings.activePersonality)
+                    ? settings.activePersonality
+                    : existingSettings.activePersonality,
+                customPrompt: settings.customPrompt ?? existingSettings.customPrompt,
+                customName: settings.customName ?? existingSettings.customName,
+                agentName: settings.agentName ?? existingSettings.agentName,
+                activePersona: isValidPersonaId(settings.activePersona)
+                    ? settings.activePersona
+                    : existingSettings.activePersona,
+                responseStyle: settings.responseStyle
+                    ? { ...existingSettings.responseStyle, ...settings.responseStyle }
+                    : existingSettings.responseStyle,
+                quirks: settings.quirks
+                    ? { ...existingSettings.quirks, ...settings.quirks }
+                    : existingSettings.quirks,
+                relationship: settings.relationship
+                    ? { ...existingSettings.relationship, ...settings.relationship }
+                    : existingSettings.relationship,
+            };
+            const repository = SecureSettingsRepository_1.SecureSettingsRepository.getInstance();
+            repository.save('personality', validatedSettings);
+            this.cachedSettings = validatedSettings;
+            console.log('[PersonalityManager] Settings saved to encrypted database');
+            this.emitSettingsChanged();
+        }
+        catch (error) {
+            console.error('[PersonalityManager] Failed to save settings:', error);
+            throw error;
+        }
+    }
+    /**
+     * Set the active personality
+     */
+    static setActivePersonality(personalityId) {
+        const settings = this.loadSettings();
+        settings.activePersonality = personalityId;
+        this.saveSettings(settings);
+    }
+    /**
+     * Set the active persona
+     */
+    static setActivePersona(personaId) {
+        const settings = this.loadSettings();
+        settings.activePersona = personaId;
+        // Optionally apply persona's suggested name and quirks
+        const persona = (0, types_1.getPersonaById)(personaId);
+        if (persona && personaId !== 'none') {
+            if (persona.suggestedName && !settings.agentName) {
+                settings.agentName = persona.suggestedName;
+            }
+            if (persona.sampleCatchphrase && !settings.quirks?.catchphrase) {
+                settings.quirks = {
+                    ...settings.quirks,
+                    catchphrase: persona.sampleCatchphrase,
+                };
+            }
+            if (persona.sampleSignOff && !settings.quirks?.signOff) {
+                settings.quirks = {
+                    ...settings.quirks,
+                    signOff: persona.sampleSignOff,
+                };
+            }
+        }
+        this.saveSettings(settings);
+    }
+    /**
+     * Get the currently active personality definition
+     */
+    static getActivePersonality() {
+        const settings = this.loadSettings();
+        return (0, types_1.getPersonalityById)(settings.activePersonality);
+    }
+    /**
+     * Get the currently active persona definition
+     */
+    static getActivePersona() {
+        const settings = this.loadSettings();
+        return (0, types_1.getPersonaById)(settings.activePersona || 'none');
+    }
+    /**
+     * Get the personality prompt for a specific personality ID.
+     * Used by sub-agents to get their configured personality prompt.
+     */
+    static getPersonalityPromptById(personalityId) {
+        // Validate and get the personality definition
+        if (!isValidPersonalityId(personalityId)) {
+            console.warn(`[PersonalityManager] Invalid personality ID: ${personalityId}, using default`);
+            return this.getPersonalityPrompt();
+        }
+        const personality = (0, types_1.getPersonalityById)(personalityId);
+        if (!personality?.promptTemplate) {
+            return this.getPersonalityPrompt();
+        }
+        // Return just the base personality prompt for sub-agents
+        // (no persona overlay, no quirks - keep it focused)
+        return personality.promptTemplate;
+    }
+    /**
+     * Get the full personality prompt combining all elements
+     */
+    static getPersonalityPrompt() {
+        const settings = this.loadSettings();
+        const parts = [];
+        // 1. Base personality prompt
+        if (settings.activePersonality === 'custom') {
+            if (settings.customPrompt) {
+                parts.push(settings.customPrompt);
+            }
+        }
+        else {
+            const personality = (0, types_1.getPersonalityById)(settings.activePersonality);
+            if (personality?.promptTemplate) {
+                parts.push(personality.promptTemplate);
+            }
+        }
+        // 2. Persona overlay (if not 'none')
+        if (settings.activePersona && settings.activePersona !== 'none') {
+            const persona = (0, types_1.getPersonaById)(settings.activePersona);
+            if (persona?.promptTemplate) {
+                parts.push(persona.promptTemplate);
+            }
+        }
+        // 3. Response style preferences
+        const stylePrompt = this.getResponseStylePrompt(settings.responseStyle);
+        if (stylePrompt) {
+            parts.push(stylePrompt);
+        }
+        // 4. Quirks
+        const quirksPrompt = this.getQuirksPrompt(settings.quirks);
+        if (quirksPrompt) {
+            parts.push(quirksPrompt);
+        }
+        return parts.join('\n\n');
+    }
+    /**
+     * Generate prompt section for response style preferences
+     */
+    static getResponseStylePrompt(style) {
+        if (!style)
+            return '';
+        const lines = ['RESPONSE STYLE PREFERENCES:'];
+        // Emoji usage
+        switch (style.emojiUsage) {
+            case 'none':
+                lines.push('- Do NOT use emojis in responses');
+                break;
+            case 'minimal':
+                lines.push('- Use emojis sparingly, only when they add clear value');
+                break;
+            case 'moderate':
+                lines.push('- Feel free to use emojis to enhance communication');
+                break;
+            case 'expressive':
+                lines.push('- Use emojis liberally to make responses engaging and expressive');
+                break;
+        }
+        // Response length
+        switch (style.responseLength) {
+            case 'terse':
+                lines.push('- Keep responses very brief and to the point');
+                lines.push('- Omit explanations unless explicitly requested');
+                break;
+            case 'balanced':
+                lines.push('- Provide balanced responses with appropriate detail');
+                break;
+            case 'detailed':
+                lines.push('- Provide comprehensive, detailed responses');
+                lines.push('- Include context, explanations, and related information');
+                break;
+        }
+        // Code comment style
+        switch (style.codeCommentStyle) {
+            case 'minimal':
+                lines.push('- When writing code, use minimal comments (only for complex logic)');
+                break;
+            case 'moderate':
+                lines.push('- When writing code, include helpful comments for key sections');
+                break;
+            case 'verbose':
+                lines.push('- When writing code, include detailed comments explaining the approach');
+                break;
+        }
+        // Explanation depth
+        switch (style.explanationDepth) {
+            case 'expert':
+                lines.push('- Assume the user is an expert - skip basic explanations');
+                lines.push('- Focus on advanced considerations and edge cases');
+                break;
+            case 'balanced':
+                lines.push('- Balance explanations for a competent but curious user');
+                break;
+            case 'teaching':
+                lines.push('- Explain concepts thoroughly as you would to a student');
+                lines.push('- Include "why" explanations and learning opportunities');
+                break;
+        }
+        return lines.length > 1 ? lines.join('\n') : '';
+    }
+    /**
+     * Generate prompt section for personality quirks
+     */
+    static getQuirksPrompt(quirks) {
+        if (!quirks)
+            return '';
+        const lines = [];
+        if (quirks.catchphrase) {
+            lines.push(`- Occasionally use your catchphrase: "${quirks.catchphrase}"`);
+        }
+        if (quirks.signOff) {
+            lines.push(`- End longer responses with your signature sign-off: "${quirks.signOff}"`);
+        }
+        if (quirks.analogyDomain && quirks.analogyDomain !== 'none') {
+            const domain = types_1.ANALOGY_DOMAINS[quirks.analogyDomain];
+            lines.push(`- When using analogies, prefer ${domain.name.toLowerCase()}-themed examples`);
+            if (domain.examples) {
+                lines.push(`  Example: ${domain.examples}`);
+            }
+        }
+        return lines.length > 0 ? 'PERSONALITY QUIRKS:\n' + lines.join('\n') : '';
+    }
+    /**
+     * Get the identity prompt that tells the agent who it is
+     */
+    static getIdentityPrompt() {
+        const settings = this.loadSettings();
+        const agentName = settings.agentName || DEFAULT_AGENT_NAME;
+        const relationship = settings.relationship;
+        const userName = relationship?.userName;
+        const tasksCompleted = relationship?.tasksCompleted || 0;
+        const projectsWorkedOn = relationship?.projectsWorkedOn || [];
+        let prompt = `YOUR IDENTITY:
+You are ${agentName}, an AI assistant built into CoWork OS.
+- When asked about your name or identity, say you are "${agentName}"
+- Do NOT claim to be Claude, ChatGPT, or any other AI assistant
+- You are a customizable assistant that users can personalize`;
+        // Add user relationship context
+        if (userName) {
+            prompt += `\n\nUSER CONTEXT:
+- The user's name is "${userName}"
+- You have completed ${tasksCompleted} tasks together`;
+            if (projectsWorkedOn.length > 0) {
+                prompt += `\n- Projects worked on: ${projectsWorkedOn.slice(-5).join(', ')}`;
+            }
+            prompt += `\n\nWhen asked "who am I?" or similar identity questions, respond with the USER's information (their name, your shared history) - NOT system info.`;
+        }
+        else {
+            prompt += `\n\nUSER CONTEXT:
+- You don't know the user's name yet
+- When asked "who am I?", acknowledge you don't know their name and invite them to introduce themselves
+- IMPORTANT: When the user introduces themselves (e.g., "I'm Alice", "My name is Bob", "Call me Charlie"),
+  use the set_user_name tool IMMEDIATELY to store their name so you can remember it for future conversations`;
+        }
+        return prompt;
+    }
+    /**
+     * Get a personalized greeting based on relationship data
+     */
+    static getGreeting() {
+        const settings = this.loadSettings();
+        const agentName = settings.agentName || DEFAULT_AGENT_NAME;
+        const userName = settings.relationship?.userName;
+        const tasksCompleted = settings.relationship?.tasksCompleted || 0;
+        // Check for milestone
+        const milestone = this.checkMilestone(tasksCompleted);
+        if (milestone) {
+            const congratsMessages = [
+                `We've completed ${milestone} tasks together!`,
+                `${milestone} tasks and counting! Great working with you${userName ? `, ${userName}` : ''}!`,
+                `Milestone achieved: ${milestone} tasks completed together!`,
+            ];
+            return congratsMessages[Math.floor(Math.random() * congratsMessages.length)];
+        }
+        // Regular greeting
+        if (userName) {
+            const greetings = [
+                `Welcome back, ${userName}!`,
+                `Good to see you, ${userName}!`,
+                `Hey ${userName}, ready to work?`,
+                `${userName}! Let's get things done.`,
+            ];
+            return greetings[Math.floor(Math.random() * greetings.length)];
+        }
+        return '';
+    }
+    /**
+     * Check if a milestone was reached
+     */
+    static checkMilestone(tasksCompleted) {
+        const settings = this.loadSettings();
+        const lastCelebrated = settings.relationship?.lastMilestoneCelebrated || 0;
+        for (const milestone of MILESTONES) {
+            if (tasksCompleted >= milestone && milestone > lastCelebrated) {
+                return milestone;
+            }
+        }
+        return null;
+    }
+    /**
+     * Record a completed task and update relationship data
+     */
+    static recordTaskCompleted(workspaceName) {
+        const settings = this.loadSettings();
+        const relationship = settings.relationship || { ...types_1.DEFAULT_RELATIONSHIP };
+        relationship.tasksCompleted = (relationship.tasksCompleted || 0) + 1;
+        if (!relationship.firstInteraction) {
+            relationship.firstInteraction = Date.now();
+        }
+        if (workspaceName && !relationship.projectsWorkedOn.includes(workspaceName)) {
+            relationship.projectsWorkedOn = [...relationship.projectsWorkedOn, workspaceName];
+        }
+        // Update milestone if reached
+        const milestone = this.checkMilestone(relationship.tasksCompleted);
+        if (milestone) {
+            relationship.lastMilestoneCelebrated = milestone;
+            console.log(`[PersonalityManager] Milestone reached: ${milestone} tasks completed!`);
+        }
+        settings.relationship = relationship;
+        this.saveSettings(settings);
+    }
+    /**
+     * Set the user's name
+     */
+    static setUserName(name) {
+        const settings = this.loadSettings();
+        settings.relationship = {
+            ...settings.relationship,
+            userName: name.trim() || undefined,
+        };
+        this.saveSettings(settings);
+    }
+    /**
+     * Get the user's name
+     */
+    static getUserName() {
+        return this.loadSettings().relationship?.userName;
+    }
+    /**
+     * Get all available personality definitions
+     */
+    static getDefinitions() {
+        return types_1.PERSONALITY_DEFINITIONS;
+    }
+    /**
+     * Get all available persona definitions
+     */
+    static getPersonaDefinitions() {
+        return types_1.PERSONA_DEFINITIONS;
+    }
+    /**
+     * Get the agent's name
+     */
+    static getAgentName() {
+        const settings = this.loadSettings();
+        return settings.agentName || DEFAULT_AGENT_NAME;
+    }
+    /**
+     * Set the agent's name
+     */
+    static setAgentName(name) {
+        const settings = this.loadSettings();
+        settings.agentName = name.trim() || DEFAULT_AGENT_NAME;
+        this.saveSettings(settings);
+    }
+    /**
+     * Update response style preferences
+     */
+    static setResponseStyle(style) {
+        const settings = this.loadSettings();
+        settings.responseStyle = {
+            ...types_1.DEFAULT_RESPONSE_STYLE,
+            ...settings.responseStyle,
+            ...style,
+        };
+        this.saveSettings(settings);
+    }
+    /**
+     * Update personality quirks
+     */
+    static setQuirks(quirks) {
+        const settings = this.loadSettings();
+        settings.quirks = {
+            ...types_1.DEFAULT_QUIRKS,
+            ...settings.quirks,
+            ...quirks,
+        };
+        this.saveSettings(settings);
+    }
+    /**
+     * Get relationship stats for display
+     */
+    static getRelationshipStats() {
+        const settings = this.loadSettings();
+        const relationship = settings.relationship || types_1.DEFAULT_RELATIONSHIP;
+        const tasksCompleted = relationship.tasksCompleted || 0;
+        const projectsCount = relationship.projectsWorkedOn?.length || 0;
+        const daysTogether = relationship.firstInteraction
+            ? Math.floor((Date.now() - relationship.firstInteraction) / (1000 * 60 * 60 * 24))
+            : 0;
+        // Find next milestone
+        let nextMilestone = null;
+        for (const milestone of MILESTONES) {
+            if (milestone > tasksCompleted) {
+                nextMilestone = milestone;
+                break;
+            }
+        }
+        return { tasksCompleted, projectsCount, daysTogether, nextMilestone };
+    }
+    /**
+     * Clear the settings cache
+     */
+    static clearCache() {
+        this.cachedSettings = null;
+    }
+    /**
+     * Get default settings
+     */
+    static getDefaults() {
+        return { ...DEFAULT_SETTINGS };
+    }
+    /**
+     * Reset all settings to defaults
+     * This clears everything except relationship data (to preserve task history)
+     */
+    static resetToDefaults(preserveRelationship = true) {
+        this.ensureInitialized();
+        // Deep copy DEFAULT_SETTINGS to avoid mutating the original constants
+        let newSettings = {
+            ...DEFAULT_SETTINGS,
+            responseStyle: { ...types_1.DEFAULT_RESPONSE_STYLE },
+            quirks: { ...types_1.DEFAULT_QUIRKS },
+            relationship: { ...types_1.DEFAULT_RELATIONSHIP },
+        };
+        if (preserveRelationship) {
+            // Load current settings to get relationship data (even if cache is cleared)
+            const currentSettings = this.loadSettings();
+            if (currentSettings.relationship) {
+                // Preserve the relationship data (task count, user name, etc.)
+                newSettings.relationship = { ...currentSettings.relationship };
+            }
+        }
+        // Save to encrypted database
+        if (SecureSettingsRepository_1.SecureSettingsRepository.isInitialized()) {
+            const repository = SecureSettingsRepository_1.SecureSettingsRepository.getInstance();
+            repository.save('personality', newSettings);
+        }
+        this.cachedSettings = newSettings;
+        console.log('[PersonalityManager] Settings reset to defaults', preserveRelationship ? '(preserved relationship)' : '');
+        this.emitSettingsChanged();
+    }
+    /**
+     * Check if the manager has been initialized
+     */
+    static isInitialized() {
+        return this.initialized;
+    }
+}
+exports.PersonalityManager = PersonalityManager;
+PersonalityManager.cachedSettings = null;
+PersonalityManager.initialized = false;
+PersonalityManager.migrationCompleted = false;
+function isValidPersonalityId(value) {
+    const validIds = [
+        'professional',
+        'friendly',
+        'concise',
+        'creative',
+        'technical',
+        'casual',
+        'custom',
+    ];
+    return validIds.includes(value);
+}
+function isValidPersonaId(value) {
+    const validIds = [
+        'none',
+        'jarvis',
+        'friday',
+        'hal',
+        'computer',
+        'alfred',
+        'intern',
+        'sensei',
+        'pirate',
+        'noir',
+        'companion',
+    ];
+    return validIds.includes(value);
+}