psyche-ai 5.0.0 → 7.1.0

package/dist/classify.js

@@ -3,7 +3,159 @@
 //
 // Closes the loop: instead of asking the LLM to self-classify,
 // we pre-classify the user's message and pre-compute chemistry.
+//
+// v2: Enhanced multi-signal scoring — weighted sentiment words,
+//     emoji analysis, structural features, and contextual priming.
+//     Pure computation, no LLM calls.
 // ============================================================
+// ── Sentiment word sets (loaded once at module parse) ────────
+const POSITIVE_WORDS = new Set([
+    "开心", "快乐", "幸福", "满意", "期待", "兴奋", "感动", "温暖", "喜欢", "棒", "厉害", "佩服", "优秀", "了不起",
+    "happy", "glad", "love", "wonderful", "enjoy", "grateful", "excited", "awesome", "great", "amazing", "beautiful",
+]);
+const NEGATIVE_WORDS = new Set([
+    "难过", "痛苦", "失望", "沮丧", "愤怒", "烦", "讨厌", "害怕", "无奈", "累", "焦虑", "压力", "崩溃", "绝望",
+    "sad", "angry", "frustrated", "disappointed", "hurt", "afraid", "worried", "tired", "stressed", "anxious",
+]);
+const INTIMATE_WORDS = new Set([
+    "想你", "陪", "在乎", "珍惜", "温柔", "拥抱", "信任", "安全感", "依赖",
+    "miss", "care", "feel", "heart", "close", "together", "trust", "comfort",
+]);
+/** Words that are ambiguous and context-dependent */
+const AMBIGUOUS_SARCASM_WORDS = new Set([
+    "呵呵", "嗯嗯", "哦", "好吧", "随便", "都行", "行吧",
+    "ok", "fine", "whatever", "sure",
+]);
+// ── Emoji sets ───────────────────────────────────────────────
+const POSITIVE_EMOJI = /😊|😄|❤️|👍|🎉|😃|🥰|💕|✨|🌟|💪|😁|🤗|💖|😍/;
+const NEGATIVE_EMOJI = /😢|😭|😡|💔|😰|😞|😔|🥺|😩|😣|😤|😨|😱|🤮|💀/;
+// ── Helpers ──────────────────────────────────────────────────
+/**
+ * Tokenize text by splitting on whitespace and extracting individual
+ * Chinese characters. Returns lowercase tokens for matching.
+ */
+function tokenize(text) {
+    const tokens = [];
+    // Split on whitespace first
+    const parts = text.toLowerCase().split(/\s+/).filter(Boolean);
+    for (const part of parts) {
+        // For each part, extract Chinese character runs and non-Chinese runs
+        const segments = part.match(/[\u4e00-\u9fff]+|[a-z]+/g);
+        if (!segments)
+            continue;
+        for (const seg of segments) {
+            if (/[\u4e00-\u9fff]/.test(seg)) {
+                // Chinese: check both individual chars and bigrams (for 2-char words)
+                for (let i = 0; i < seg.length; i++) {
+                    tokens.push(seg[i]);
+                    if (i + 1 < seg.length) {
+                        tokens.push(seg[i] + seg[i + 1]);
+                    }
+                }
+            }
+            else {
+                tokens.push(seg);
+            }
+        }
+    }
+    return tokens;
+}
+/**
+ * Score sentiment by counting hits in positive/negative/intimate word sets.
+ * Returns normalized counts (0-1 range).
+ */
+export function scoreSentiment(text) {
+    const tokens = tokenize(text);
+    if (tokens.length === 0)
+        return { positive: 0, negative: 0, intimate: 0 };
+    let positive = 0;
+    let negative = 0;
+    let intimate = 0;
+    for (const token of tokens) {
+        if (POSITIVE_WORDS.has(token))
+            positive++;
+        if (NEGATIVE_WORDS.has(token))
+            negative++;
+        if (INTIMATE_WORDS.has(token))
+            intimate++;
+    }
+    // Normalize: cap at 1.0, scale so 1 hit already gives a meaningful signal
+    const norm = (count) => Math.min(1, count / 3);
+    return { positive: norm(positive), negative: norm(negative), intimate: norm(intimate) };
+}
+/**
+ * Score emoji sentiment. Returns -1 (all negative) to +1 (all positive).
+ * Returns 0 if no emoji detected.
+ */
+export function scoreEmoji(text) {
+    const posMatches = text.match(new RegExp(POSITIVE_EMOJI.source, "g")) || [];
+    const negMatches = text.match(new RegExp(NEGATIVE_EMOJI.source, "g")) || [];
+    const total = posMatches.length + negMatches.length;
+    if (total === 0)
+        return 0;
+    return (posMatches.length - negMatches.length) / total;
+}
+/**
+ * Detect sarcasm signals: surface-positive words combined with contextual negativity.
+ * Returns a score 0-1 indicating sarcasm likelihood.
+ */
+export function detectSarcasmSignals(text, recentStimuli) {
+    if (text.length === 0)
+        return 0;
+    let score = 0;
+    const lower = text.toLowerCase();
+    // Chinese sarcasm patterns: surface praise + particles + short length
+    const zhSarcasmPatterns = [
+        /你真(行|棒|厉害|了不起|牛|强|能|可以)(啊|呀|哦|嘛|吧|呢)?/,
+        /厉害了/,
+        /好好好/,
+        /行行行/,
+        /是是是/,
+        /对对对/,
+        /了不起/,
+        /牛[啊逼]?$/,
+        /可以[的啊]?$/,
+        /哦[。？]?$/,
+        /呵呵/,
+        /嗯嗯[。]?$/,
+        /随[你便]/,
+        /爱[咋怎]咋[地的]?/,
+    ];
+    for (const pattern of zhSarcasmPatterns) {
+        if (pattern.test(lower)) {
+            score += 0.3;
+        }
+    }
+    // English sarcasm patterns
+    const enSarcasmPatterns = [
+        /oh really/i, /sure thing/i, /yeah right/i, /wow.{0,5}amazing/i,
+        /good for you/i, /how nice/i, /whatever you say/i,
+    ];
+    for (const pattern of enSarcasmPatterns) {
+        if (pattern.test(text)) {
+            score += 0.3;
+        }
+    }
+    // Short message + praise words = likely sarcasm
+    if (text.length < 15) {
+        const hasPraiseWord = /棒|厉害|了不起|牛|great|amazing|wonderful|brilliant/i.test(text);
+        if (hasPraiseWord)
+            score += 0.15;
+    }
+    // Context: if recent interactions were negative, surface praise is more likely sarcasm
+    if (recentStimuli && recentStimuli.length > 0) {
+        const negativeTypes = ["criticism", "conflict", "sarcasm", "authority"];
+        const recentNegative = recentStimuli.filter((s) => s && negativeTypes.includes(s)).length;
+        if (recentNegative >= 1) {
+            score += 0.2;
+        }
+    }
+    return Math.min(1, score);
+}
+/** Negative stimulus types for contextual priming */
+const NEGATIVE_TYPES = new Set([
+    "criticism", "conflict", "neglect", "vulnerability", "sarcasm",
+]);
 const RULES = [
     {
         type: "praise",
@@ -154,9 +306,17 @@ const RULES = [
  * Classify the stimulus type(s) of a user message.
  * Returns all detected types sorted by confidence, highest first.
  * Falls back to "casual" if nothing matches.
+ *
+ * v2: When keyword rules miss (confidence < 0.5), a weighted multi-signal
+ * scoring system combines sentiment words, emoji, structural features,
+ * and optional contextual priming to produce better classifications for
+ * everyday messages.
+ *
+ * @param text          The user's message text
+ * @param recentStimuli Optional recent stimulus history for contextual priming
  */
-export function classifyStimulus(text) {
-    const results = [];
+export function classifyStimulus(text, recentStimuli, recentMessages) {
+    let results = [];
     for (const rule of RULES) {
         let matchCount = 0;
         for (const pattern of rule.patterns) {
@@ -169,8 +329,9 @@ export function classifyStimulus(text) {
             results.push({ type: rule.type, confidence });
         }
     }
+    // If keyword rules produced a high-confidence match, boost with structural signals and return
+    const bestKeywordConfidence = results.length > 0 ? Math.max(...results.map(r => r.confidence)) : 0;
     // ── Structural signals (message-level features) ──
-    // When keywords miss, message shape still carries meaning.
     const len = text.length;
     const hasI = /我/.test(text) || /\bI\b/i.test(text);
     const hasYou = /你/.test(text) || /\byou\b/i.test(text);
@@ -180,70 +341,195 @@ export function classifyStimulus(text) {
     const hasLaughter = /[2]{3,}|hhh|www|哈{2,}/i.test(text);
     const hasSharing = /我[今昨前]天|我刚[才刚]|我最近/.test(text);
     const sentenceCount = text.split(/[。！？!?.…]+/).filter(Boolean).length;
-    if (results.length === 0) {
-        // No keyword matched — use structural fallback
-        if (len === 0) {
-            // Empty input — neutral
-            results.push({ type: "casual", confidence: 0.3 });
-        }
-        else if (hasLaughter) {
-            // Internet laughter not caught by keywords (e.g. 233333)
-            results.push({ type: "humor", confidence: 0.65 });
-        }
-        else if (exclamationCount >= 2) {
-            // Emphatic expression → surprise/excitement
-            results.push({ type: "surprise", confidence: 0.55 });
-        }
-        else if (len <= 4 && !hasQuestion) {
-            // Ultra-short non-question: "好" "行" "哦" — neglect-like
-            results.push({ type: "neglect", confidence: 0.45 });
+    if (bestKeywordConfidence >= 0.5) {
+        // Keywords matched with good confidence — structural features can boost
+        if (hasI && len > 30 && results[0].confidence < 0.8) {
+            results[0].confidence = Math.min(0.9, results[0].confidence + 0.1);
         }
-        else if (hasI && hasEllipsis) {
-            // Personal + trailing off: "我觉得...有点难" — vulnerability
-            results.push({ type: "vulnerability", confidence: 0.55 });
+        if (exclamationCount >= 2 && results[0].confidence < 0.85) {
+            results[0].confidence = Math.min(0.9, results[0].confidence + 0.05);
         }
-        else if (hasSharing && len > 20) {
-            // Sharing personal experience — higher engagement signal
-            results.push({ type: "casual", confidence: 0.65 });
+        results.sort((a, b) => b.confidence - a.confidence);
+        // Sarcasm reclassification: if primary looks like praise but sarcasm signals are strong
+        if (results.length > 0 && results[0].type === "praise") {
+            const sarcasmScore = detectSarcasmSignals(text, recentStimuli);
+            if (sarcasmScore >= 0.4) {
+                // Reclassify: replace praise with sarcasm
+                results = results.filter((r) => r.type !== "praise");
+                results.unshift({ type: "sarcasm", confidence: Math.min(0.9, sarcasmScore) });
+            }
         }
-        else if (hasI && len > 8) {
-            // Personal sharing (any meaningful length) — engagement signal
-            results.push({ type: "casual", confidence: 0.55 });
+        // Ambiguous words: default to sarcasm unless context is positive
+        const lowerText = text.trim().toLowerCase();
+        if (AMBIGUOUS_SARCASM_WORDS.has(lowerText) || AMBIGUOUS_SARCASM_WORDS.has(text.trim())) {
+            const hasPositiveContext = recentStimuli?.some((s) => s && ["praise", "validation", "humor", "intimacy", "casual"].includes(s));
+            if (!hasPositiveContext) {
+                // Default ambiguous to sarcasm/cold
+                results = [{ type: "sarcasm", confidence: 0.6 }];
+            }
         }
-        else if (hasQuestion && hasYou) {
-            // Asking about the agent specifically → intellectual curiosity
-            results.push({ type: "intellectual", confidence: 0.5 });
+        // Contextual contrast: if previous messages were negative and this one is surface-positive
+        if (recentMessages && recentMessages.length > 0 && results.length > 0 && results[0].type === "praise") {
+            const lastMsg = recentMessages[recentMessages.length - 1];
+            const lastSentiment = scoreSentiment(lastMsg);
+            if (lastSentiment.negative > 0.3) {
+                // Previous message was negative, current is praise → likely sarcasm
+                const sarcasmBoost = detectSarcasmSignals(text, recentStimuli);
+                if (sarcasmBoost > 0.2) {
+                    results = results.filter((r) => r.type !== "praise");
+                    results.unshift({ type: "sarcasm", confidence: 0.7 });
+                }
+            }
         }
-        else if (hasQuestion) {
-            // Any question — intellectual curiosity or casual
-            results.push({ type: "casual", confidence: 0.55 });
+        return results;
+    }
+    // ── Enhanced multi-signal scoring (fallback path) ─────────
+    // No keyword rule matched with confidence >= 0.5.
+    // Build a score map across all stimulus types using weighted signals.
+    if (len === 0) {
+        return [{ type: "casual", confidence: 0.3 }];
+    }
+    const scores = {};
+    const addScore = (type, delta) => {
+        scores[type] = (scores[type] ?? 0) + delta;
+    };
+    // ── Signal 1: Sentiment words (weight: up to ~0.65) ──
+    // A single word hit gives normalized ~0.33; multiplier must be high enough
+    // so one word + structural signals can cross the 0.35 threshold.
+    // Short messages get a density boost — when there are few words, each
+    // sentiment word carries proportionally more meaning.
+    const sentiment = scoreSentiment(text);
+    const densityBoost = len <= 15 ? 1.4 : 1.0;
+    if (sentiment.positive > 0) {
+        addScore("praise", sentiment.positive * 0.55 * densityBoost);
+        addScore("validation", sentiment.positive * 0.35 * densityBoost);
+    }
+    if (sentiment.negative > 0) {
+        addScore("vulnerability", sentiment.negative * 0.55 * densityBoost);
+        addScore("criticism", sentiment.negative * 0.25 * densityBoost);
+    }
+    if (sentiment.intimate > 0) {
+        addScore("intimacy", sentiment.intimate * 0.55 * densityBoost);
+        addScore("validation", sentiment.intimate * 0.15 * densityBoost);
+    }
+    // Personal pronoun + sentiment = stronger emotional expression
+    if (hasI && (sentiment.positive > 0 || sentiment.negative > 0 || sentiment.intimate > 0)) {
+        const maxSentiment = Math.max(sentiment.positive, sentiment.negative, sentiment.intimate);
+        if (sentiment.positive === maxSentiment)
+            addScore("praise", 0.10);
+        if (sentiment.negative === maxSentiment)
+            addScore("vulnerability", 0.10);
+        if (sentiment.intimate === maxSentiment)
+            addScore("intimacy", 0.10);
+    }
+    // ── Signal 2: Emoji sentiment (weight: up to 0.25) ──
+    const emojiScore = scoreEmoji(text);
+    if (emojiScore > 0) {
+        addScore("praise", emojiScore * 0.20);
+        addScore("humor", emojiScore * 0.15);
+    }
+    else if (emojiScore < 0) {
+        addScore("vulnerability", Math.abs(emojiScore) * 0.25);
+        addScore("neglect", Math.abs(emojiScore) * 0.15);
+    }
+    // Emoji-only messages: if text is entirely emoji (no alphanumeric/CJK), boost
+    const strippedText = text.replace(/[\s\p{Emoji_Presentation}\p{Emoji}\uFE0F\u200D]/gu, "").trim();
+    if (strippedText.length === 0 && len > 0) {
+        // Pure emoji message — amplify emoji signal
+        if (emojiScore < 0) {
+            addScore("vulnerability", 0.30);
+            addScore("neglect", 0.20);
         }
-        else if (len > 50 && sentenceCount >= 3) {
-            // Long multi-sentence without keywords → engaged storytelling
-            results.push({ type: "casual", confidence: 0.6 });
+        else if (emojiScore > 0) {
+            addScore("praise", 0.25);
+            addScore("humor", 0.20);
         }
-        else {
-            results.push({ type: "casual", confidence: 0.3 });
+    }
+    // ── Signal 3: Structural features (additive, weight: 0.05-0.20 each) ──
+    if (hasLaughter) {
+        addScore("humor", 0.35);
+    }
+    if (exclamationCount >= 2) {
+        addScore("surprise", 0.25);
+    }
+    else if (exclamationCount === 1) {
+        addScore("surprise", 0.08);
+    }
+    if (hasEllipsis) {
+        addScore("vulnerability", 0.12);
+        addScore("neglect", 0.05);
+    }
+    if (hasI && hasEllipsis) {
+        addScore("vulnerability", 0.15);
+    }
+    if (hasQuestion && hasYou) {
+        addScore("intellectual", 0.20);
+    }
+    else if (hasQuestion) {
+        addScore("intellectual", 0.12);
+        addScore("casual", 0.10);
+    }
+    if (hasSharing && len > 20) {
+        addScore("casual", 0.20);
+    }
+    if (hasI && len > 8) {
+        addScore("casual", 0.10);
+    }
+    if (len > 50 && sentenceCount >= 3) {
+        addScore("casual", 0.15);
+    }
+    // Ultra-short non-question messages (e.g. "嗯", "好", "行")
+    if (len <= 4 && !hasQuestion) {
+        addScore("neglect", 0.20);
+        addScore("casual", 0.10);
+    }
+    // ── Signal 4: Low-confidence keyword matches contribute to scores ──
+    // If keyword rules matched but below 0.5, fold their signal in
+    for (const r of results) {
+        addScore(r.type, r.confidence * 0.5);
+    }
+    // ── Signal 5: Contextual priming from recent stimuli ──
+    if (recentStimuli && recentStimuli.length > 0) {
+        const recentNonNull = recentStimuli.filter((s) => s !== null);
+        if (recentNonNull.length > 0) {
+            const negCount = recentNonNull.filter(s => NEGATIVE_TYPES.has(s)).length;
+            const negRatio = negCount / recentNonNull.length;
+            // If recent context is mostly negative (>= 50%), give a small bonus to negative types
+            if (negRatio >= 0.5) {
+                const bonus = 0.05 + negRatio * 0.05; // 0.075-0.1
+                addScore("vulnerability", bonus);
+                addScore("criticism", bonus * 0.6);
+                addScore("neglect", bonus * 0.5);
+            }
         }
     }
-    else {
-        // Keywords matched — structural features can boost confidence
-        if (hasI && len > 30 && results[0].confidence < 0.8) {
-            // Long personal message boosts the primary match slightly
-            results[0].confidence = Math.min(0.9, results[0].confidence + 0.1);
+    // ── Pick the best scoring type ──
+    const THRESHOLD = 0.35;
+    const scoredResults = [];
+    for (const [type, score] of Object.entries(scores)) {
+        if (score >= THRESHOLD) {
+            scoredResults.push({ type, confidence: Math.min(0.85, score) });
         }
-        if (exclamationCount >= 2 && results[0].confidence < 0.85) {
-            // Emphasis boosts conviction
-            results[0].confidence = Math.min(0.9, results[0].confidence + 0.05);
+    }
+    if (scoredResults.length > 0) {
+        scoredResults.sort((a, b) => b.confidence - a.confidence);
+        // Sarcasm reclassification: if primary looks like praise but sarcasm signals are strong
+        if (scoredResults[0].type === "praise") {
+            const sarcasmScore = detectSarcasmSignals(text, recentStimuli);
+            if (sarcasmScore >= 0.4) {
+                const filtered = scoredResults.filter((r) => r.type !== "praise");
+                filtered.unshift({ type: "sarcasm", confidence: Math.min(0.85, sarcasmScore) });
+                return filtered;
+            }
         }
+        return scoredResults;
     }
-    // Sort by confidence descending
-    results.sort((a, b) => b.confidence - a.confidence);
-    return results;
+    // Nothing scored above threshold — fall back to casual with 0.3
+    return [{ type: "casual", confidence: 0.3 }];
 }
 /**
  * Get the primary (highest confidence) stimulus type.
  */
-export function getPrimaryStimulus(text) {
-    return classifyStimulus(text)[0].type;
+export function getPrimaryStimulus(text, recentStimuli) {
+    return classifyStimulus(text, recentStimuli)[0].type;
 }