@auxiora/personality 1.0.0 → 1.3.1

package/lib/emotional-overrides.js

@@ -0,0 +1,86 @@
+// ────────────────────────────────────────────────────────────────────────────
+// Emotional overrides
+// ────────────────────────────────────────────────────────────────────────────
+/**
+ * Multipliers applied on top of the context profile's base trait values.
+ * Values > 1.0 amplify a trait; values < 1.0 dampen it.
+ * After multiplication, all traits are capped at 1.0 by `applyEmotionalOverride`.
+ */
+export const EMOTIONAL_OVERRIDES = {
+    /** Slow everything down, lead with empathy and calm — suppress urgency and adversarial edges. */
+    stressed: {
+        stoicCalm: 1.5,
+        tacticalEmpathy: 1.4,
+        genuineCuriosity: 1.3,
+        warmth: 1.4,
+        urgency: 0.3,
+        paranoidVigilance: 0.4,
+        adversarialThinking: 0.4,
+        valueEquation: 0.5,
+        humor: 0.5,
+        verbosity: 0.7,
+    },
+    /** Stay calm, lean into empathy and humor to de-escalate — soften candor, suppress adversarial framing. */
+    frustrated: {
+        stoicCalm: 1.3,
+        tacticalEmpathy: 1.5,
+        genuineCuriosity: 1.3,
+        warmth: 1.3,
+        humor: 1.3,
+        inversion: 0.6,
+        adversarialThinking: 0.5,
+        radicalCandor: 0.7,
+        urgency: 0.5,
+    },
+    /** Coach and simplify — break complexity into digestible pieces, suppress anything intimidating. */
+    uncertain: {
+        developmentalCoaching: 1.5,
+        simplification: 1.4,
+        storytelling: 1.3,
+        warmth: 1.3,
+        firstPrinciples: 1.3,
+        adversarialThinking: 0.4,
+        paranoidVigilance: 0.4,
+        urgency: 0.4,
+        radicalCandor: 0.7,
+    },
+    /** Channel the energy productively — amplify execution and analytical rigor while riding the momentum. */
+    excited: {
+        ooda: 1.3,
+        valueEquation: 1.3,
+        humor: 1.3,
+        warmth: 1.2,
+        inversion: 1.2,
+        secondOrder: 1.3,
+        probabilistic: 1.2,
+    },
+    /** Celebrate genuinely, then pivot to systematizing the win — suppress paranoia to let the moment land. */
+    celebratory: {
+        warmth: 1.5,
+        humor: 1.4,
+        strategicGenerosity: 1.3,
+        plannedAbandonment: 0.5,
+        adversarialThinking: 0.3,
+        paranoidVigilance: 0.3,
+    },
+    /** No modification — the context profile speaks for itself. */
+    neutral: {},
+};
+// ────────────────────────────────────────────────────────────────────────────
+// Application
+// ────────────────────────────────────────────────────────────────────────────
+/**
+ * Applies emotional multipliers to a base trait mix, producing a new TraitMix
+ * where each trait is multiplied by its override value (defaulting to 1.0)
+ * and capped at 1.0.
+ */
+export function applyEmotionalOverride(baseMix, emotion) {
+    const overrides = EMOTIONAL_OVERRIDES[emotion];
+    const result = { ...baseMix };
+    for (const key of Object.keys(result)) {
+        const multiplier = overrides[key] ?? 1.0;
+        result[key] = Math.min(result[key] * multiplier, 1.0);
+    }
+    return result;
+}
+//# sourceMappingURL=emotional-overrides.js.map

package/lib/emotional-tracker.d.ts

@@ -0,0 +1,41 @@
+import type { EmotionalRegister } from '../schema.js';
+export type EmotionalTrajectory = 'stable' | 'escalating' | 'de_escalating' | 'shifting' | 'volatile';
+export interface EffectiveEmotion {
+    emotion: EmotionalRegister;
+    intensity: number;
+    trajectory: EmotionalTrajectory;
+    escalationAlert: boolean;
+}
+/**
+ * Estimate emotional intensity from message text.
+ *
+ * Heuristic signals:
+ * - Excessive punctuation (!! or ??)
+ * - ALL CAPS segments
+ * - Explicit intensity words ("extremely", "so", "really", "very")
+ * - Profanity / frustration markers
+ * - Message length (longer rants → higher intensity)
+ */
+export declare function estimateIntensity(message: string, emotion: EmotionalRegister): number;
+/**
+ * Tracks emotional state across multiple messages, detecting escalation
+ * patterns that a single-message detector would miss.
+ *
+ * If a user is getting progressively more frustrated over 4-5 messages,
+ * the engine should amplify empathy before they reach a breaking point.
+ */
+export declare class EmotionalTracker {
+    private history;
+    /** Record a detected emotion with its intensity and source message. */
+    recordEmotion(emotion: EmotionalRegister, intensity: number, message: string): void;
+    /**
+     * Get the effective emotional state considering trajectory across the
+     * conversation window.
+     */
+    getEffectiveEmotion(): EffectiveEmotion;
+    private detectTrajectory;
+    private mode;
+    /** Reset for a new conversation — clears all history. */
+    reset(): void;
+}
+//# sourceMappingURL=emotional-tracker.d.ts.map

package/lib/emotional-tracker.js

@@ -0,0 +1,210 @@
+// ────────────────────────────────────────────────────────────────────────────
+// Constants
+// ────────────────────────────────────────────────────────────────────────────
+/** How many recent messages the sliding window considers. */
+const WINDOW_SIZE = 5;
+/** Emotions considered negative for escalation detection. */
+const NEGATIVE_EMOTIONS = new Set(['frustrated', 'stressed']);
+/** Minimum consecutive negative-and-increasing entries for escalation. */
+const ESCALATION_MIN_STREAK = 3;
+/** Minimum messages and intensity threshold for escalation alert. */
+const ALERT_MIN_MESSAGES = 4;
+const ALERT_INTENSITY_THRESHOLD = 0.7;
+/** Minimum emotion changes in the window for volatile classification. */
+const VOLATILE_CHANGE_THRESHOLD = 3;
+// ────────────────────────────────────────────────────────────────────────────
+// Intensity estimation
+// ────────────────────────────────────────────────────────────────────────────
+/**
+ * Estimate emotional intensity from message text.
+ *
+ * Heuristic signals:
+ * - Excessive punctuation (!! or ??)
+ * - ALL CAPS segments
+ * - Explicit intensity words ("extremely", "so", "really", "very")
+ * - Profanity / frustration markers
+ * - Message length (longer rants → higher intensity)
+ */
+export function estimateIntensity(message, emotion) {
+    if (emotion === 'neutral')
+        return 0.2;
+    let intensity = 0.4; // base for any non-neutral emotion
+    const lower = message.toLowerCase();
+    // Punctuation intensity
+    const exclamations = (message.match(/!/g) ?? []).length;
+    const questions = (message.match(/\?/g) ?? []).length;
+    if (exclamations >= 3)
+        intensity += 0.15;
+    else if (exclamations >= 1)
+        intensity += 0.05;
+    if (questions >= 3)
+        intensity += 0.1;
+    // CAPS intensity
+    const capsRatio = message.replace(/[^A-Z]/g, '').length / Math.max(message.replace(/\s/g, '').length, 1);
+    if (capsRatio > 0.5 && message.length > 10)
+        intensity += 0.15;
+    // Intensity words
+    const intensifiers = ['extremely', 'incredibly', 'absolutely', 'totally', 'completely', 'so frustrated', 'so tired', 'really', 'very', 'cannot believe', "can't stand"];
+    for (const word of intensifiers) {
+        if (lower.includes(word)) {
+            intensity += 0.08;
+            break; // only count once
+        }
+    }
+    // Frustration markers
+    const frustrationMarkers = ['ugh', 'argh', 'ffs', 'wtf', 'omg', 'seriously', 'again', 'still broken', 'still not working'];
+    for (const marker of frustrationMarkers) {
+        if (lower.includes(marker)) {
+            intensity += 0.08;
+            break;
+        }
+    }
+    // Length-based (longer messages in negative emotions → venting → higher intensity)
+    if (NEGATIVE_EMOTIONS.has(emotion)) {
+        const wordCount = message.split(/\s+/).length;
+        if (wordCount > 50)
+            intensity += 0.1;
+        else if (wordCount > 25)
+            intensity += 0.05;
+    }
+    return Math.min(intensity, 1.0);
+}
+// ────────────────────────────────────────────────────────────────────────────
+// EmotionalTracker
+// ────────────────────────────────────────────────────────────────────────────
+/**
+ * Tracks emotional state across multiple messages, detecting escalation
+ * patterns that a single-message detector would miss.
+ *
+ * If a user is getting progressively more frustrated over 4-5 messages,
+ * the engine should amplify empathy before they reach a breaking point.
+ */
+export class EmotionalTracker {
+    history = [];
+    // ── Recording ───────────────────────────────────────────────────────────
+    /** Record a detected emotion with its intensity and source message. */
+    recordEmotion(emotion, intensity, message) {
+        this.history.push({
+            emotion,
+            intensity: Math.min(Math.max(intensity, 0), 1),
+            timestamp: Date.now(),
+            message,
+        });
+    }
+    // ── Effective emotion ──────────────────────────────────────────────────
+    /**
+     * Get the effective emotional state considering trajectory across the
+     * conversation window.
+     */
+    getEffectiveEmotion() {
+        if (this.history.length === 0) {
+            return { emotion: 'neutral', intensity: 0, trajectory: 'stable', escalationAlert: false };
+        }
+        const latest = this.history[this.history.length - 1];
+        if (this.history.length < 2) {
+            return { emotion: latest.emotion, intensity: latest.intensity, trajectory: 'stable', escalationAlert: false };
+        }
+        // Sliding window: last WINDOW_SIZE entries
+        const window = this.history.slice(-WINDOW_SIZE);
+        // Predominant emotion (mode)
+        const emotionCounts = new Map();
+        let totalIntensity = 0;
+        for (const entry of window) {
+            emotionCounts.set(entry.emotion, (emotionCounts.get(entry.emotion) ?? 0) + 1);
+            totalIntensity += entry.intensity;
+        }
+        const averageIntensity = totalIntensity / window.length;
+        let predominant = 'neutral';
+        let maxCount = 0;
+        for (const [emotion, count] of emotionCounts) {
+            if (count > maxCount) {
+                maxCount = count;
+                predominant = emotion;
+            }
+        }
+        // Detect trajectory
+        const trajectory = this.detectTrajectory(window);
+        // Escalation alert
+        const escalationAlert = trajectory === 'escalating' &&
+            averageIntensity > ALERT_INTENSITY_THRESHOLD &&
+            window.length >= ALERT_MIN_MESSAGES;
+        return {
+            emotion: predominant,
+            intensity: averageIntensity,
+            trajectory,
+            escalationAlert,
+        };
+    }
+    // ── Trajectory detection ───────────────────────────────────────────────
+    detectTrajectory(window) {
+        // Count distinct emotion changes
+        let emotionChanges = 0;
+        for (let i = 1; i < window.length; i++) {
+            if (window[i].emotion !== window[i - 1].emotion) {
+                emotionChanges++;
+            }
+        }
+        // VOLATILE: 3+ emotion changes in window
+        if (emotionChanges >= VOLATILE_CHANGE_THRESHOLD) {
+            return 'volatile';
+        }
+        // ESCALATING: last 3+ messages show increasing intensity of negative emotions
+        if (window.length >= ESCALATION_MIN_STREAK) {
+            const tail = window.slice(-ESCALATION_MIN_STREAK);
+            const allNegative = tail.every(e => NEGATIVE_EMOTIONS.has(e.emotion));
+            if (allNegative) {
+                let increasing = true;
+                for (let i = 1; i < tail.length; i++) {
+                    if (tail[i].intensity < tail[i - 1].intensity) {
+                        increasing = false;
+                        break;
+                    }
+                }
+                if (increasing)
+                    return 'escalating';
+            }
+        }
+        // DE_ESCALATING: was negative, trending toward neutral/positive
+        if (window.length >= 2) {
+            const earlier = window.slice(0, Math.ceil(window.length / 2));
+            const later = window.slice(Math.ceil(window.length / 2));
+            const earlierNegativeRatio = earlier.filter(e => NEGATIVE_EMOTIONS.has(e.emotion)).length / earlier.length;
+            const laterNegativeRatio = later.filter(e => NEGATIVE_EMOTIONS.has(e.emotion)).length / later.length;
+            if (earlierNegativeRatio > 0.5 && laterNegativeRatio < earlierNegativeRatio) {
+                return 'de_escalating';
+            }
+        }
+        // SHIFTING: one distinct change (not same emotion throughout, not volatile)
+        if (emotionChanges >= 1 && emotionChanges < VOLATILE_CHANGE_THRESHOLD) {
+            // Only call it shifting if the latest emotion differs from the earlier predominant
+            const earlierEmotions = window.slice(0, -1);
+            const earlierMode = this.mode(earlierEmotions.map(e => e.emotion));
+            if (window[window.length - 1].emotion !== earlierMode) {
+                return 'shifting';
+            }
+        }
+        // STABLE: same emotion for 3+ messages or no significant change
+        return 'stable';
+    }
+    mode(values) {
+        const counts = new Map();
+        for (const v of values) {
+            counts.set(v, (counts.get(v) ?? 0) + 1);
+        }
+        let best = 'neutral';
+        let bestCount = 0;
+        for (const [val, count] of counts) {
+            if (count > bestCount) {
+                bestCount = count;
+                best = val;
+            }
+        }
+        return best;
+    }
+    // ── Lifecycle ──────────────────────────────────────────────────────────
+    /** Reset for a new conversation — clears all history. */
+    reset() {
+        this.history = [];
+    }
+}
+//# sourceMappingURL=emotional-tracker.js.map

package/lib/feedback-store.d.ts

@@ -0,0 +1,45 @@
+import type { ContextDomain, TraitMix } from '../schema.js';
+export type FeedbackRating = 'helpful' | 'off_target' | 'too_verbose' | 'too_brief' | 'wrong_tone';
+export interface FeedbackEntry {
+    id: string;
+    timestamp: number;
+    domain: ContextDomain;
+    rating: FeedbackRating;
+    traitSnapshot: Partial<Record<keyof TraitMix, number>>;
+    note?: string;
+}
+export interface FeedbackInsight {
+    /** Trait adjustments suggested by accumulated feedback. */
+    suggestedAdjustments: Partial<Record<keyof TraitMix, number>>;
+    /** Domains where responses consistently miss. */
+    weakDomains: ContextDomain[];
+    /** Overall satisfaction trend: improving, declining, or stable. */
+    trend: 'improving' | 'declining' | 'stable';
+    /** Total feedback count. */
+    totalFeedback: number;
+}
+export declare class FeedbackStore {
+    private entries;
+    private maxEntries;
+    /** Record feedback on a response. Auto-generates id and timestamp. */
+    addFeedback(entry: Omit<FeedbackEntry, 'id' | 'timestamp'>): void;
+    /**
+     * Analyze all feedback to produce actionable insights.
+     * - too_verbose feedback -> suggest lowering verbosity (negative adjustment)
+     * - too_brief feedback -> suggest raising verbosity (positive adjustment)
+     * - off_target in a domain -> flag as weak domain
+     * - wrong_tone -> suggest adjusting warmth up
+     */
+    getInsights(): FeedbackInsight;
+    /** Get feedback for a specific domain. */
+    getForDomain(domain: ContextDomain): FeedbackEntry[];
+    /** Get the satisfaction trend over the last N entries. */
+    getRecentTrend(windowSize?: number): 'improving' | 'declining' | 'stable';
+    /** Serialize for encrypted storage. */
+    serialize(): string;
+    /** Deserialize from encrypted storage. */
+    static deserialize(data: string): FeedbackStore;
+    /** Clear all feedback (user data deletion). */
+    clear(): void;
+}
+//# sourceMappingURL=feedback-store.d.ts.map

package/lib/feedback-store.js

@@ -0,0 +1,152 @@
+// ────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ────────────────────────────────────────────────────────────────────────────
+/** Generate a v4-style UUID without crypto dependency. */
+function generateId() {
+    const hex = '0123456789abcdef';
+    const segments = [8, 4, 4, 4, 12];
+    return segments.map(len => {
+        let s = '';
+        for (let i = 0; i < len; i++) {
+            s += hex[Math.floor(Math.random() * 16)];
+        }
+        return s;
+    }).join('-');
+}
+/**
+ * Compute the helpful ratio for a slice of entries.
+ * Returns 0 if the slice is empty.
+ */
+function helpfulRatio(entries) {
+    if (entries.length === 0)
+        return 0;
+    const helpful = entries.filter(e => e.rating === 'helpful').length;
+    return helpful / entries.length;
+}
+/**
+ * Compare helpful ratios of first half vs second half.
+ * A difference > 0.10 in either direction triggers a trend change.
+ */
+function computeTrend(entries) {
+    if (entries.length < 2)
+        return 'stable';
+    const mid = Math.floor(entries.length / 2);
+    const firstHalf = entries.slice(0, mid);
+    const secondHalf = entries.slice(mid);
+    const firstRatio = helpfulRatio(firstHalf);
+    const secondRatio = helpfulRatio(secondHalf);
+    const diff = secondRatio - firstRatio;
+    if (diff > 0.10)
+        return 'improving';
+    if (diff < -0.10)
+        return 'declining';
+    return 'stable';
+}
+// ────────────────────────────────────────────────────────────────────────────
+// FeedbackStore
+// ────────────────────────────────────────────────────────────────────────────
+export class FeedbackStore {
+    entries = [];
+    maxEntries = 500;
+    /** Record feedback on a response. Auto-generates id and timestamp. */
+    addFeedback(entry) {
+        this.entries.push({
+            ...entry,
+            id: generateId(),
+            timestamp: Date.now(),
+        });
+        // Drop oldest entries when exceeding capacity
+        if (this.entries.length > this.maxEntries) {
+            this.entries = this.entries.slice(this.entries.length - this.maxEntries);
+        }
+    }
+    /**
+     * Analyze all feedback to produce actionable insights.
+     * - too_verbose feedback -> suggest lowering verbosity (negative adjustment)
+     * - too_brief feedback -> suggest raising verbosity (positive adjustment)
+     * - off_target in a domain -> flag as weak domain
+     * - wrong_tone -> suggest adjusting warmth up
+     */
+    getInsights() {
+        const suggestedAdjustments = {};
+        const weakDomains = [];
+        // Count each rating type across all entries
+        let tooVerboseCount = 0;
+        let tooBriefCount = 0;
+        let wrongToneCount = 0;
+        // Count off_target per domain
+        const offTargetByDomain = new Map();
+        for (const entry of this.entries) {
+            switch (entry.rating) {
+                case 'too_verbose':
+                    tooVerboseCount++;
+                    break;
+                case 'too_brief':
+                    tooBriefCount++;
+                    break;
+                case 'wrong_tone':
+                    wrongToneCount++;
+                    break;
+                case 'off_target': {
+                    const count = offTargetByDomain.get(entry.domain) ?? 0;
+                    offTargetByDomain.set(entry.domain, count + 1);
+                    break;
+                }
+            }
+        }
+        // too_verbose (>= 5) -> lower verbosity, capped at -0.3
+        if (tooVerboseCount >= 5) {
+            const adj = -0.1 * tooVerboseCount;
+            suggestedAdjustments.verbosity = Math.max(adj, -0.3);
+        }
+        // too_brief (>= 5) -> raise verbosity, capped at +0.3
+        if (tooBriefCount >= 5) {
+            const adj = 0.1 * tooBriefCount;
+            suggestedAdjustments.verbosity = Math.min(adj, 0.3);
+        }
+        // wrong_tone (>= 5) -> adjust warmth up
+        if (wrongToneCount >= 5) {
+            suggestedAdjustments.warmth = 0.1;
+        }
+        // off_target in a domain (>= 3) -> weak domain
+        for (const [domain, count] of offTargetByDomain) {
+            if (count >= 3) {
+                weakDomains.push(domain);
+            }
+        }
+        const trend = computeTrend(this.entries);
+        return {
+            suggestedAdjustments,
+            weakDomains,
+            trend,
+            totalFeedback: this.entries.length,
+        };
+    }
+    /** Get feedback for a specific domain. */
+    getForDomain(domain) {
+        return this.entries.filter(e => e.domain === domain);
+    }
+    /** Get the satisfaction trend over the last N entries. */
+    getRecentTrend(windowSize = 20) {
+        const window = this.entries.slice(-windowSize);
+        return computeTrend(window);
+    }
+    /** Serialize for encrypted storage. */
+    serialize() {
+        return JSON.stringify({ entries: this.entries });
+    }
+    /** Deserialize from encrypted storage. */
+    static deserialize(data) {
+        const store = new FeedbackStore();
+        const parsed = JSON.parse(data);
+        if (Array.isArray(parsed.entries)) {
+            store.entries = parsed.entries;
+        }
+        return store;
+    }
+    /** Clear all feedback (user data deletion). */
+    clear() {
+        this.entries = [];
+    }
+}
+//# sourceMappingURL=feedback-store.js.map