principles-disciple 1.71.0 → 1.73.0

package/src/core/empathy-keyword-matcher.ts

@@ -1,101 +1,43 @@
-/**
- * Empathy Keyword Matcher
- * 
- * Fast keyword-based empathy detection that replaces the previous
- * LLM subagent-per-turn approach.
- * 
- * Flow:
- *   User message → keyword matching → weighted score → GFI penalty
- * 
- * The keyword store is periodically optimized by a subagent that analyzes
- * recent conversations and updates keyword weights, discovers new terms,
- * and removes false positives.
- */
-
 import * as fs from 'fs';
 import * as path from 'path';
 import { atomicWriteFileSync } from '../utils/io.js';
-import type {
+import { createDefaultKeywordStore } from '@principles/core/prompt-builder';
+import type { EmpathyKeywordStore } from '@principles/core/prompt-builder';
+
+export {
+  matchEmpathyKeywords,
+  createDefaultKeywordStore,
+  applyKeywordUpdates,
+  shouldTriggerOptimization,
+  getKeywordStoreSummary,
+} from '@principles/core/prompt-builder';
+
+export type {
   EmpathyKeywordStore,
   EmpathyKeywordEntry,
   EmpathyKeywordStats,
   EmpathyMatchResult,
-  EmpathyKeywordConfig} from './empathy-types.js';
-import {
-  EMPATHY_SEED_KEYWORDS,
-  DEFAULT_EMPATHY_KEYWORD_CONFIG,
-  scoreToSeverity,
-} from './empathy-types.js';
+  EmpathyKeywordConfig,
+} from '@principles/core/prompt-builder';
 
 const KEYWORD_STORE_FILE = 'empathy_keywords.json';
 
-// =========================================================================
-// Store Management
-// =========================================================================
-
-/**
- * Creates a default keyword store from seed keywords.
- * Supports both Chinese and English keywords.
- */
-export function createDefaultKeywordStore(language: 'zh' | 'en' = 'zh'): EmpathyKeywordStore {
-  const now = new Date().toISOString();
-  const terms: Record<string, EmpathyKeywordEntry> = {};
-
-  // Include all seed keywords (both zh and en)
-  for (const seed of EMPATHY_SEED_KEYWORDS) {
-    // For Chinese language, include all keywords
-    // For English language, include only English keywords
-    const isChinese = /[\u4e00-\u9fa5]/.test(seed.term);
-    if (language === 'zh' || !isChinese) {
-      terms[seed.term] = {
-        weight: seed.weight,
-        source: 'seed',
-        hitCount: 0,
-        falsePositiveRate: seed.initialFalsePositiveRate ?? 0.15, // Differentiated FPR (Finding #6)
-      };
-    }
-  }
-
-  const stats: EmpathyKeywordStats = {
-    totalHits: 0,
-    totalFalsePositives: 0,
-    optimizationCount: 0,
-  };
-
-  return {
-    version: 1,
-    lastUpdated: now,
-    lastOptimizedAt: now,
-    terms,
-    stats,
-  };
-}
-
-/**
- * Loads the keyword store from disk, or creates a default one if not found.
- * Respects the configured language setting.
- */
 export function loadKeywordStore(stateDir: string, language?: 'zh' | 'en'): EmpathyKeywordStore {
   const filePath = path.join(stateDir, KEYWORD_STORE_FILE);
-  
+
   try {
     if (!fs.existsSync(filePath)) {
       const store = createDefaultKeywordStore(language);
-       
-       
       saveKeywordStore(stateDir, store);
       return store;
     }
 
     const raw = fs.readFileSync(filePath, 'utf8');
     const parsed = JSON.parse(raw);
-    
-    // Validate structure
+
     if (!parsed.terms || !parsed.stats || !parsed.version) {
       console.warn('[PD:Empathy] Invalid keyword store format, creating default');
       const store = createDefaultKeywordStore(language);
-       
-       
       saveKeywordStore(stateDir, store);
       return store;
     }
@@ -104,21 +46,15 @@ export function loadKeywordStore(stateDir: string, language?: 'zh' | 'en'): Empa
   } catch (e) {
     console.warn(`[PD:Empathy] Failed to load keyword store: ${e}`);
     const store = createDefaultKeywordStore(language);
-     
-     
     saveKeywordStore(stateDir, store);
     return store;
   }
 }
 
-/**
- * Saves the keyword store to disk.
- */
- 
 export function saveKeywordStore(stateDir: string, store: EmpathyKeywordStore): void {
   const filePath = path.join(stateDir, KEYWORD_STORE_FILE);
   const dir = path.dirname(filePath);
-  
+
   if (!fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true });
   }
@@ -126,211 +62,3 @@ export function saveKeywordStore(stateDir: string, store: EmpathyKeywordStore):
   store.lastUpdated = new Date().toISOString();
   atomicWriteFileSync(filePath, JSON.stringify(store, null, 2));
 }
-
-// =========================================================================
-// Keyword Matching
-// =========================================================================
-
-/**
- * Matches text against the keyword store and returns a structured result.
- * 
- * This is the core function that replaces the previous LLM-based empathy detection.
- * It runs in < 1ms for typical keyword stores (50-200 terms).
- */
-export function matchEmpathyKeywords(
-  text: string,
-  store: EmpathyKeywordStore,
-  config: EmpathyKeywordConfig = DEFAULT_EMPATHY_KEYWORD_CONFIG,
-): EmpathyMatchResult {
-  if (!text || typeof text !== 'string' || text.trim().length === 0) {
-    return {
-      matched: false,
-      score: 0,
-      matchedTerms: [],
-      severity: 'mild',
-      confidence: 0,
-    };
-  }
-
-  const lowerText = text.toLowerCase();
-  let totalScore = 0;
-  const matchedTerms: string[] = [];
-
-  for (const [term, entry] of Object.entries(store.terms)) {
-    if (lowerText.includes(term.toLowerCase())) {
-      // Weight adjusted by false positive rate
-      const adjustedWeight = entry.weight * (1 - entry.falsePositiveRate);
-      totalScore += adjustedWeight;
-      matchedTerms.push(term);
-
-      // Update hit stats
-      entry.hitCount++;
-      entry.lastHitAt = new Date().toISOString();
-    }
-  }
-
-  // Cap score at 1.0
-  const cappedScore = Math.min(1, totalScore);
-
-  // Only consider matched if score exceeds threshold
-  const isMatched = cappedScore >= config.matchThreshold && matchedTerms.length > 0;
-
-  // Limit matched terms for performance
-  const limitedTerms = matchedTerms.slice(0, config.maxTermsPerMessage);
-
-  // Calculate confidence based on:
-  // - Number of matched terms (more terms = higher confidence)
-  // - Score relative to threshold (higher score = higher confidence)
-  const termConfidence = Math.min(1, limitedTerms.length / 3);
-  const scoreConfidence = Math.min(1, cappedScore / 0.8);
-  const confidence = Math.max(termConfidence, scoreConfidence);
-
-  const result: EmpathyMatchResult = {
-    matched: isMatched,
-    score: cappedScore,
-    matchedTerms: limitedTerms,
-    severity: scoreToSeverity(cappedScore),
-    confidence,
-  };
-
-  // Update store stats
-  if (isMatched) {
-    store.stats.totalHits += limitedTerms.length;
-  }
-
-  return result;
-}
-
-// =========================================================================
-// Keyword Store Updates
-// =========================================================================
-
-/**
- * Applies keyword updates from subagent optimization.
- * 
- * This is called when the empathy optimizer subagent completes its analysis
- * and returns suggested updates to the keyword store.
- */
-     
-export function applyKeywordUpdates(
-  store: EmpathyKeywordStore,
-  updates: Record<string, {
-    action: 'add' | 'update' | 'remove';
-    weight?: number;
-    falsePositiveRate?: number;
-    examples?: string[];
-    reasoning?: string;
-  }>,
-): { added: number; updated: number; removed: number } {
-  let added = 0;
-  let updated = 0;
-  let removed = 0;
-  const now = new Date().toISOString();
-
-  for (const [term, update] of Object.entries(updates)) {
-    switch (update.action) {
-      case 'add':
-        if (!store.terms[term]) {
-          store.terms[term] = {
-            weight: update.weight ?? 0.5,
-            source: 'llm_discovered',
-            hitCount: 0,
-            falsePositiveRate: update.falsePositiveRate ?? 0.2,
-            examples: update.examples,
-            discoveredAt: now,
-          };
-          added++;
-        }
-        break;
-
-      case 'update':
-        if (store.terms[term]) {
-          if (update.weight !== undefined) {
-            store.terms[term].weight = update.weight;
-          }
-          if (update.falsePositiveRate !== undefined) {
-            store.terms[term].falsePositiveRate = update.falsePositiveRate;
-          }
-          if (update.examples) {
-            store.terms[term].examples = update.examples;
-          }
-          updated++;
-        }
-        break;
-
-      case 'remove':
-        if (store.terms[term]) {
-          delete store.terms[term];
-          removed++;
-        }
-        break;
-    }
-  }
-
-  store.lastOptimizedAt = now;
-  store.stats.optimizationCount++;
-
-  return { added, updated, removed };
-}
-
-// =========================================================================
-// Optimization Trigger
-// =========================================================================
-
-/**
- * Checks if it's time to trigger subagent optimization.
- * 
- * Returns true if either:
- * - The number of turns since last optimization exceeds the interval
- * - The time since last optimization exceeds the interval
- */
-export function shouldTriggerOptimization(
-  store: EmpathyKeywordStore,
-  turnsSinceLastOptimization: number,
-  config: EmpathyKeywordConfig = DEFAULT_EMPATHY_KEYWORD_CONFIG,
-): boolean {
-  const turnsExceeded = turnsSinceLastOptimization >= config.optimizationIntervalTurns;
-  
-  const lastOpt = new Date(store.lastOptimizedAt).getTime();
-  const now = Date.now();
-  const timeExceeded = (now - lastOpt) >= config.optimizationIntervalMs;
-
-  return turnsExceeded || timeExceeded;
-}
-
-// =========================================================================
-// Store Inspection
-// =========================================================================
-
-/**
- * Returns a summary of the keyword store for debugging/monitoring.
- */
-export function getKeywordStoreSummary(store: EmpathyKeywordStore): {
-  totalTerms: number;
-  seedTerms: number;
-  discoveredTerms: number;
-  topHitTerms: { term: string; hitCount: number; weight: number }[];
-  highFalsePositiveTerms: { term: string; falsePositiveRate: number }[];
-} {
-  const terms = Object.entries(store.terms);
-  const seedTerms = terms.filter(([, e]) => e.source === 'seed');
-  const discoveredTerms = terms.filter(([, e]) => e.source === 'llm_discovered');
-
-  const topHitTerms = terms
-    .map(([term, entry]) => ({ term, hitCount: entry.hitCount, weight: entry.weight }))
-    .sort((a, b) => b.hitCount - a.hitCount)
-    .slice(0, 10);
-
-  const highFalsePositiveTerms = terms
-    .filter(([, e]) => e.falsePositiveRate > 0.3)
-    .map(([term, entry]) => ({ term, falsePositiveRate: entry.falsePositiveRate }))
-    .sort((a, b) => b.falsePositiveRate - a.falsePositiveRate);
-
-  return {
-    totalTerms: terms.length,
-    seedTerms: seedTerms.length,
-    discoveredTerms: discoveredTerms.length,
-    topHitTerms,
-    highFalsePositiveTerms,
-  };
-}

package/src/core/empathy-types.ts

@@ -1,229 +1,18 @@
-/**
- * Empathy Keyword Matching Types
- * 
- * Types for the dynamic keyword-based empathy detection system.
- * Replaces the previous LLM subagent-per-turn approach with fast keyword
- * matching + periodic subagent optimization of the keyword store.
- */
-
-// =========================================================================
-// Keyword Store
-// =========================================================================
-
-export interface EmpathyKeywordStore {
-  version: number;
-  lastUpdated: string;
-  lastOptimizedAt: string;
-  terms: Record<string, EmpathyKeywordEntry>;
-  stats: EmpathyKeywordStats;
-}
-
-export interface EmpathyKeywordEntry {
-  /** 0-1, contribution to GFI when matched */
-  weight: number;
-  
-  /** How this keyword was discovered */
-  source: 'seed' | 'llm_discovered' | 'user_reported';
-  
-  /** Total times this keyword has matched */
-  hitCount: number;
-  
-  /** Last time this keyword matched */
-  lastHitAt?: string;
-  
-  /** 0-1, false positive rate calculated from subagent validation */
-  falsePositiveRate: number;
-  
-  /** Example contexts where this keyword appeared */
-  examples?: string[];
-  
-  /** When LLM first discovered this keyword */
-  discoveredAt?: string;
-}
-
-export interface EmpathyKeywordStats {
-  totalHits: number;
-  totalFalsePositives: number;
-  optimizationCount: number;
-}
-
-// =========================================================================
-// Match Result
-// =========================================================================
-
-export interface EmpathyMatchResult {
-  /** Whether any keywords matched */
-  matched: boolean;
-  
-  /** Weighted total score (0-1) */
-  score: number;
-  
-  /** List of matched keyword terms */
-  matchedTerms: string[];
-  
-  /** Derived severity level */
-  severity: 'mild' | 'moderate' | 'severe';
-  
-  /** Confidence in the result (0-1) */
-  confidence: number;
-}
-
-// =========================================================================
-// Keyword Update (from subagent optimization)
-// =========================================================================
-
-export interface EmpathyKeywordUpdate {
-  action: 'add' | 'update' | 'remove';
-  weight?: number;
-  falsePositiveRate?: number;
-  examples?: string[];
-  reasoning?: string;
-}
-
-export interface EmpathyOptimizationResult {
-  updates: Record<string, EmpathyKeywordUpdate>;
-  reasoning: string;
-  analyzedTurns: number;
-  newPatternsDiscovered: number;
-}
-
-// =========================================================================
-// Seed Keywords (preset list)
-// =========================================================================
-
-export interface SeedKeywordEntry {
-  term: string;
-  weight: number;
-  category: 'negation' | 'anger' | 'disappointment' | 'escalation';
-  /** Initial false positive rate — higher for generic words, lower for specific anger signals */
-  initialFalsePositiveRate?: number;
-}
-
-/**
- * Preset seed keywords for empathy detection.
- * These are the initial keywords before the LLM starts discovering new ones.
- */
-export const EMPATHY_SEED_KEYWORDS: SeedKeywordEntry[] = [
-  // 否定词 (Negation) — generic, higher FPR
-  { term: '不对', weight: 0.5, category: 'negation', initialFalsePositiveRate: 0.3 },
-  { term: '错了', weight: 0.5, category: 'negation', initialFalsePositiveRate: 0.3 },
-  { term: '搞错了', weight: 0.5, category: 'negation', initialFalsePositiveRate: 0.25 },
-  { term: '不行', weight: 0.4, category: 'negation', initialFalsePositiveRate: 0.35 },
-  { term: '没用', weight: 0.4, category: 'negation', initialFalsePositiveRate: 0.3 },
-  { term: '重做', weight: 0.6, category: 'negation', initialFalsePositiveRate: 0.15 },
-  { term: '重写', weight: 0.6, category: 'negation', initialFalsePositiveRate: 0.15 },
-  { term: 'not right', weight: 0.5, category: 'negation', initialFalsePositiveRate: 0.3 },
-  { term: 'wrong', weight: 0.5, category: 'negation', initialFalsePositiveRate: 0.3 },
-  { term: 'redo', weight: 0.6, category: 'negation', initialFalsePositiveRate: 0.15 },
-  { term: 'start over', weight: 0.6, category: 'negation', initialFalsePositiveRate: 0.15 },
-
-  // 愤怒表达 (Anger) — specific, lower FPR
-  { term: '垃圾', weight: 0.9, category: 'anger', initialFalsePositiveRate: 0.05 },
-  { term: '蠢', weight: 0.8, category: 'anger', initialFalsePositiveRate: 0.1 },
-  { term: '废物', weight: 0.9, category: 'anger', initialFalsePositiveRate: 0.05 },
-  { term: '白做', weight: 0.7, category: 'anger', initialFalsePositiveRate: 0.15 },
-  { term: '浪费时间', weight: 0.8, category: 'anger', initialFalsePositiveRate: 0.1 },
-  { term: 'garbage', weight: 0.9, category: 'anger', initialFalsePositiveRate: 0.05 },
-  { term: 'stupid', weight: 0.8, category: 'anger', initialFalsePositiveRate: 0.1 },
-  { term: 'useless', weight: 0.7, category: 'anger', initialFalsePositiveRate: 0.15 },
-  { term: 'waste of time', weight: 0.8, category: 'anger', initialFalsePositiveRate: 0.1 },
-
-  // 失望信号 (Disappointment) — moderate FPR
-  { term: '不行啊', weight: 0.5, category: 'disappointment', initialFalsePositiveRate: 0.25 },
-  { term: '还是不对', weight: 0.6, category: 'disappointment', initialFalsePositiveRate: 0.2 },
-  { term: '没解决', weight: 0.5, category: 'disappointment', initialFalsePositiveRate: 0.25 },
-  { term: '没用上', weight: 0.5, category: 'disappointment', initialFalsePositiveRate: 0.25 },
-  { term: '不能用', weight: 0.5, category: 'disappointment', initialFalsePositiveRate: 0.25 },
-  { term: 'still not working', weight: 0.6, category: 'disappointment', initialFalsePositiveRate: 0.2 },
-  { term: "doesn't help", weight: 0.5, category: 'disappointment', initialFalsePositiveRate: 0.25 },
-  { term: 'not useful', weight: 0.5, category: 'disappointment', initialFalsePositiveRate: 0.25 },
-
-  // 升级信号 (Escalation) — specific context, lower FPR
-  { term: '你自己看', weight: 0.8, category: 'escalation', initialFalsePositiveRate: 0.1 },
-  { term: '你确定吗', weight: 0.7, category: 'escalation', initialFalsePositiveRate: 0.15 },
-  { term: '你是不是没理解', weight: 0.8, category: 'escalation', initialFalsePositiveRate: 0.1 },
-  { term: '你到底在干什么', weight: 0.9, category: 'escalation', initialFalsePositiveRate: 0.05 },
-  { term: 'are you sure', weight: 0.7, category: 'escalation', initialFalsePositiveRate: 0.15 },
-  { term: 'did you even read', weight: 0.8, category: 'escalation', initialFalsePositiveRate: 0.1 },
-  { term: 'what are you doing', weight: 0.8, category: 'escalation', initialFalsePositiveRate: 0.1 },
-];
-
-// =========================================================================
-// Configuration
-// =========================================================================
-
-export interface EmpathyKeywordConfig {
-  /** Minimum score to consider a match (0-1) */
-  matchThreshold: number;
-  
-  /** Maximum number of terms to match per message */
-  maxTermsPerMessage: number;
-  
-  /** How often to trigger subagent optimization (number of turns) */
-  optimizationIntervalTurns: number;
-  
-  /** How often to trigger subagent optimization (time-based, ms) */
-  optimizationIntervalMs: number;
-  
-  /** GFI penalty for mild severity */
-  penaltyMild: number;
-  
-  /** GFI penalty for moderate severity */
-  penaltyModerate: number;
-  
-  /** GFI penalty for severe severity */
-  penaltySevere: number;
-}
-
-export const DEFAULT_EMPATHY_KEYWORD_CONFIG: EmpathyKeywordConfig = {
-  matchThreshold: 0.3,
-  maxTermsPerMessage: 5,
-  optimizationIntervalTurns: 50,
-  optimizationIntervalMs: 6 * 60 * 60 * 1000, // 6 hours
-  penaltyMild: 10,
-  penaltyModerate: 25,
-  penaltySevere: 40,
-};
-
-// =========================================================================
-// Severity Mapping
-// =========================================================================
-
-/**
- * Maps a weighted score to a severity level.
- * 
- * Score ranges:
- * - 0.0 - 0.3: mild (single low-weight keyword)
- * - 0.3 - 0.6: moderate (multiple keywords or high-weight keyword)
- * - 0.6 - 1.0: severe (multiple high-weight keywords)
- */
-export function scoreToSeverity(score: number): 'mild' | 'moderate' | 'severe' {
-  if (score >= 0.6) return 'severe';
-  if (score >= 0.3) return 'moderate';
-  return 'mild';
-}
-
-/**
- * Maps severity to GFI penalty value.
- */
-export function severityToPenalty(
-  severity: 'mild' | 'moderate' | 'severe',
-  config: EmpathyKeywordConfig = DEFAULT_EMPATHY_KEYWORD_CONFIG
-): number {
-  switch (severity) {
-    case 'mild': return config.penaltyMild;
-    case 'moderate': return config.penaltyModerate;
-    case 'severe': return config.penaltySevere;
-  }
-}
-
-/**
- * Normalizes various severity string inputs to the canonical empathy severity type.
- * Handles common aliases: 'high' → 'severe', 'medium' → 'moderate'.
- */
-export function normalizeSeverity(input?: string): 'mild' | 'moderate' | 'severe' {
-  const normalized = (input || '').toLowerCase();
-  if (normalized === 'severe' || normalized === 'high') return 'severe';
-  if (normalized === 'moderate' || normalized === 'medium') return 'moderate';
-  return 'mild';
-}
+export type {
+  EmpathyKeywordStore,
+  EmpathyKeywordEntry,
+  EmpathyKeywordStats,
+  EmpathyMatchResult,
+  EmpathyKeywordUpdate,
+  EmpathyOptimizationResult,
+  SeedKeywordEntry,
+  EmpathyKeywordConfig,
+} from '@principles/core/prompt-builder';
+
+export {
+  EMPATHY_SEED_KEYWORDS,
+  DEFAULT_EMPATHY_KEYWORD_CONFIG,
+  scoreToSeverity,
+  severityToPenalty,
+  normalizeSeverity,
+} from '@principles/core/prompt-builder';