@yun520-1/heartflow 0.15.2 → 0.16.0

package/src/dream/engine.js

@@ -0,0 +1,99 @@
+/**
+ * DreamEngine — Memory consolidation during "sleep" cycles
+ * 
+ * Like biological sleep, the dream engine:
+ * 1. Consolidates frequently-accessed EPHEMERAL → LEARNED
+ * 2. Prunes forgotten or irrelevant memories
+ * 3. Generates insight synthesis from recent experiences
+ * 
+ * v0.16: Simple but functional.
+ */
+
+class DreamEngine {
+  constructor(memory, psychology) {
+    this.memory = memory;
+    this.psychology = psychology;
+  }
+
+  /**
+   * Run a dream consolidation cycle.
+   * 
+   * @param {object} options
+   * @param {boolean} options.consolidate - Run EPHEMERAL→LEARNED consolidation
+   * @param {boolean} options.prune - Remove stale memories
+   * @param {boolean} options.synthesize - Generate insight summary
+   * @returns {object} Dream results
+   */
+  dream({ consolidate = true, prune = true, synthesize = true } = {}) {
+    const results = {};
+    const startTime = Date.now();
+
+    // 1. Consolidate ephemeral memories
+    if (consolidate) {
+      results.consolidation = this.memory.consolidate();
+    }
+
+    // 2. Prune low-value memories
+    if (prune) {
+      results.pruning = this._prune();
+    }
+
+    // 3. Synthesize insights
+    if (synthesize) {
+      results.synthesis = this._synthesize();
+    }
+
+    results.duration_ms = Date.now() - startTime;
+    results.dream_complete = true;
+
+    return results;
+  }
+
+  _prune() {
+    const pruned = [];
+    const now = Date.now();
+    const PRUNE_THRESHOLD = 7 * 24 * 60 * 60 * 1000; // 7 days
+
+    // Prune learned memories not accessed in 7 days
+    for (const [key, entry] of Object.entries(this.memory.learned)) {
+      const lastAccessed = entry.lastAccessed || entry.createdAt;
+      if (now - lastAccessed > PRUNE_THRESHOLD) {
+        // Keep CORE-tier
+        if (entry.tags && entry.tags.includes('core')) continue;
+        this.memory.forget(key);
+        pruned.push(key);
+      }
+    }
+
+    return { pruned_count: pruned.length, pruned_keys: pruned.slice(0, 10) };
+  }
+
+  _synthesize() {
+    // Generate a brief summary of recent significant experiences
+    const recentLearned = this.memory.listLearned()
+      .sort((a, b) => (b.lastAccessed || 0) - (a.lastAccessed || 0))
+      .slice(0, 5);
+
+    if (recentLearned.length === 0) {
+      return { insight: 'No significant patterns to synthesize.', topics: [] };
+    }
+
+    const topics = recentLearned.map(l => l.key).filter(Boolean);
+    
+    // Very simple synthesis: just report the topics
+    return {
+      insight: `Recent focus areas: ${topics.join(', ')}.`,
+      topics,
+      summary_length: topics.length,
+    };
+  }
+
+  /**
+   * Quick dream: just consolidate.
+   */
+  dreamNow() {
+    return this.dream({ consolidate: true, prune: false, synthesize: false });
+  }
+}
+
+module.exports = { DreamEngine };

package/src/evolution/loop.js

@@ -0,0 +1,145 @@
+/**
+ * SelfEvolution — Reflexion-style self-improvement loop
+ * 
+ * Inspired by Shinn et al. "Reflexion: Language Agents with Verbal Reinforcement Learning"
+ * 
+ * Pattern:
+ * 1. Attempt a task
+ * 2. Evaluate outcome
+ * 3. If failure → generate self-reflection → store as lesson
+ * 4. On similar tasks, retrieve relevant lessons
+ * 
+ * v0.16: Minimal but functional.
+ */
+
+class SelfEvolution {
+  constructor(memory) {
+    this.memory = memory;
+    this.lessonPath = null; // Optional: persist lessons to file
+  }
+
+  /**
+   * Record an outcome and generate self-reflection if needed.
+   * 
+   * @param {object} params
+   * @param {string} params.task - What was attempted
+   * @param {string} params.outcome - 'success' | 'failure' | 'partial'
+   * @param {string} [params.evidence] - What happened (error message, output, etc.)
+   * @param {string} [params.expected] - What was expected
+   * @returns {object} Reflection result with lesson
+   */
+  recordOutcome({ task, outcome, evidence, expected }) {
+    const reflection = this._reflect(task, outcome, evidence, expected);
+    
+    // Store as ephemeral if failure (temporary lesson)
+    if (outcome === 'failure' || outcome === 'partial') {
+      this.memory.remember(`lesson:${task}:${Date.now()}`, reflection.lesson, 86400000); // 24hr TTL
+    }
+    
+    return {
+      outcome,
+      reflection,
+      lessonStored: outcome !== 'success',
+    };
+  }
+
+  /**
+   * Generate verbal self-reflection on failure.
+   */
+  _reflect(task, outcome, evidence, expected) {
+    const reflections = [];
+    
+    if (outcome === 'failure') {
+      reflections.push(`Task failed: ${task}`);
+      if (evidence) reflections.push(`Evidence: ${evidence.substring(0, 200)}`);
+      if (expected) reflections.push(`Expected: ${expected.substring(0, 200)}`);
+      
+      // Generate corrective insight
+      const corrections = [];
+      if (evidence && evidence.includes('not defined')) {
+        corrections.push('Check if all variables are defined before use.');
+      }
+      if (evidence && evidence.includes('Error')) {
+        corrections.push('Handle the error case explicitly.');
+      }
+      if (evidence && evidence.includes('timeout')) {
+        corrections.push('Consider increasing timeout or breaking into smaller steps.');
+      }
+      if (corrections.length === 0) {
+        corrections.push('Re-examine the problem from first principles.');
+        corrections.push('Break down the task into smaller, verifiable steps.');
+      }
+      
+      return {
+        lesson: reflections.concat(corrections).join(' | '),
+        corrections,
+        type: 'failure_reflection',
+      };
+    }
+    
+    if (outcome === 'partial') {
+      return {
+        lesson: `Partial success on "${task}": ${evidence || 'incomplete'}. Need to investigate remaining gap.`,
+        corrections: ['Identify what worked and what didn\'t.'],
+        type: 'partial_reflection',
+      };
+    }
+    
+    return {
+      lesson: `Success: ${task}`,
+      corrections: [],
+      type: 'success',
+    };
+  }
+
+  /**
+   * Retrieve relevant lessons for a task.
+   * 
+   * @param {string} task - Current task description
+   * @returns {string[]} Relevant lessons from past failures
+   */
+  retrieveLessons(task) {
+    const lower = task.toLowerCase();
+    const lessons = [];
+    
+    // Search ephemeral for lesson entries
+    // Stored as "lesson:${taskFragment}:${timestamp}"
+    for (const key of Object.keys(this.memory.ephemeral)) {
+      if (key.startsWith('lesson:')) {
+        const entry = this.memory.getWorking(key);
+        if (entry) {
+          const taskPart = key.split(':')[1];
+          if (lower.includes(taskPart) || taskPart.includes(lower)) {
+            lessons.push(entry.value);
+          }
+        }
+      }
+    }
+    
+    // Also search learned memories for past failures
+    const learnedResults = this.memory.listLearned('failure');
+    for (const entry of learnedResults.slice(0, 3)) {
+      lessons.push(entry.value);
+    }
+    
+    return [...new Set(lessons)];
+  }
+
+  /**
+   * Summarize current lesson state.
+   */
+  getLessonStats() {
+    const ephemeralLessons = Object.keys(this.memory.ephemeral)
+      .filter(k => k.startsWith('lesson:'));
+    
+    return {
+      activeLessons: ephemeralLessons.length,
+      lessons: ephemeralLessons.slice(0, 5).map(k => ({
+        key: k,
+        preview: this.memory.ephemeral[k]?.value?.substring(0, 80) || 'N/A'
+      })),
+    };
+  }
+}
+
+module.exports = { SelfEvolution };

package/src/psychology/engine.js

@@ -0,0 +1,268 @@
+/**
+ * PsychologyEngine — AI Psychological Perception
+ * 
+ * Perceives: intent, emotion, needs, defenses from user input.
+ * 
+ * v0.16: Clean, minimal implementation with measurable outputs.
+ * No over-claiming. Every output is traceable to code.
+ */
+
+class PsychologyEngine {
+  constructor(memory) {
+    this.memory = memory;
+    
+    // Psychological dimension weights (can be tuned)
+    this.weights = {
+      intent: 0.4,      // What user is trying to accomplish
+      emotion: 0.3,    // Emotional state signal
+      needs: 0.2,      // Unmet needs signal
+      defenses: 0.1,   // Resistance/defensiveness signal
+    };
+    
+    // Emotion keywords for quick categorization
+    this.emotionMap = this._buildEmotionMap();
+  }
+
+  _buildEmotionMap() {
+    return {
+      positive: {
+        high: ['happy', 'excited', 'thrilled', 'delighted', 'joyful', 'grateful', 'pleased', 'satisfied', 'optimistic', 'great', 'love', 'amazing', 'awesome', 'wonderful', 'fantastic'],
+        medium: ['content', 'comfortable', 'relaxed', 'calm', 'curious', 'interested', 'engaged', 'good', 'nice'],
+        low: ['okay', 'fine', 'neutral', 'mildly interested'],
+      },
+      negative: {
+        high: ['frustrated', 'angry', 'furious', 'devastated', 'overwhelmed', 'panicked', 'terrified'],
+        medium: ['annoyed', 'upset', 'disappointed', 'worried', 'anxious', 'sad', 'confused'],
+        low: ['uneasy', 'bored', 'tired', 'mildly frustrated'],
+      },
+      neutral: ['okay', 'fine', 'whatever', 'alright', 'so-so'],
+    };
+  }
+
+  /**
+   * Main entry point: perceive psychological signals from input
+   * 
+   * @param {string} input - Raw user input
+   * @returns {object} Psychological perception result
+   */
+  perceive(input) {
+    if (!input || typeof input !== 'string') {
+      return { intent: null, emotion: null, needs: [], defenses: [], confidence: 0 };
+    }
+
+    const lower = input.toLowerCase();
+    const words = lower.split(/\s+/);
+    
+    // 1. Detect emotion
+    const emotion = this._detectEmotion(lower, words, input);
+    
+    // 2. Infer intent
+    const intent = this._inferIntent(lower, words, input);
+    
+    // 3. Detect unmet needs
+    const needs = this._detectNeeds(lower, words);
+    
+    // 4. Detect defenses
+    const defenses = this._detectDefenses(lower, words);
+    
+    // 5. Compute overall confidence
+    const confidence = this._computeConfidence(emotion, intent, needs, defenses);
+    
+    return {
+      intent,
+      emotion,
+      needs,
+      defenses,
+      confidence,
+      raw_signals: { wordCount: words.length, charCount: input.length },
+    };
+  }
+
+  _detectEmotion(lower, words, rawInput) {
+    let maxIntensity = 0;
+    let category = 'neutral';
+    let intensity = 'low';
+    let detected = [];
+
+    // Check for emotional words
+    for (const [cat, intensities] of Object.entries(this.emotionMap)) {
+      for (const [level, keywords] of Object.entries(intensities)) {
+        for (const kw of keywords) {
+          if (lower.includes(kw)) {
+            detected.push({ keyword: kw, level });
+            if (cat === 'positive' && level === 'high') { maxIntensity = 3; category = cat; intensity = level; }
+            else if (cat === 'negative' && level === 'high') { maxIntensity = 3; category = cat; intensity = level; }
+            else if (maxIntensity < 2) { maxIntensity = 2; category = cat; intensity = level; }
+            else if (maxIntensity < 1) { maxIntensity = 1; category = cat; intensity = level; }
+          }
+        }
+      }
+    }
+
+    // Check for punctuation emotion signals
+    const exclamationCount = (lower.match(/!/g) || []).length;
+    const questionCount = (lower.match(/\?/g) || []).length;
+    const capsRatio = (rawInput.match(/[A-Z]/g) || []).length / Math.max(lower.length, 1);
+
+    let punctuationSignal = 'neutral';
+    if (exclamationCount >= 2) punctuationSignal = 'excited';
+    else if (questionCount >= 3) punctuationSignal = 'confused_or_seeking';
+    else if (capsRatio > 0.3 && lower.length < 50) punctuationSignal = 'intense';
+
+    return {
+      category,
+      intensity,
+      signals: detected.slice(0, 3),
+      punctuation: punctuationSignal,
+    };
+  }
+
+  _inferIntent(lower, words, raw) {
+    // Intent categories with keyword patterns
+    const intentPatterns = {
+      information_seeking: {
+        patterns: ['what is', 'how to', 'why does', 'when did', 'where is', 'who is', 'explain', 'tell me', 'find', 'search', 'how do i', 'what do i', 'can i', '?'],
+        confidence: 0.85,
+      },
+      task_execution: {
+        patterns: ['do it', 'make it', 'create', 'write', 'run', 'execute', 'build', 'build me', 'fix', 'solve', 'implement', 'make me', 'create me'],
+        confidence: 0.85,
+      },
+      troubleshooting: {
+        patterns: ['not working', 'error', 'bug', 'failed', 'broken', 'doesn\'t work', 'can\'t', 'unable to', 'issue'],
+        confidence: 0.8,
+      },
+      collaboration: {
+        patterns: ['we', 'together', 'let\'s', 'help me', 'work on', 'collaborate', 'share', 'discuss'],
+        confidence: 0.7,
+      },
+      reflection: {
+        patterns: ['think about', 'consider', 'reflect', 'analyze', 'evaluate', 'assess', 'review'],
+        confidence: 0.7,
+      },
+      emotional_support: {
+        patterns: ['feel', 'upset', 'frustrated', 'sad', 'stressed', 'worried', 'overwhelmed', 'i\'m feeling'],
+        confidence: 0.6,
+      },
+      opinion_seeking: {
+        patterns: ['what do you think', 'your opinion', 'should i', 'would you', 'is it better', 'which is'],
+        confidence: 0.7,
+      },
+    };
+
+    let bestIntent = 'unknown';
+    let bestScore = 0;
+
+    for (const [intentName, config] of Object.entries(intentPatterns)) {
+      let matchCount = 0;
+      for (const pattern of config.patterns) {
+        if (lower.includes(pattern)) matchCount++;
+      }
+      const score = (matchCount / config.patterns.length) * config.confidence;
+      if (score > bestScore) {
+        bestScore = score;
+        bestIntent = intentName;
+      }
+    }
+
+    return {
+      category: bestIntent,
+      confidence: Math.min(bestScore, 1),
+    };
+  }
+
+  _detectNeeds(lower, words) {
+    const needs = [];
+    
+    const needPatterns = [
+      { need: 'clarity', patterns: ['confused', 'unclear', 'don\'t understand', 'what do you mean', '?'], weight: 1.0 },
+      { need: 'efficiency', patterns: ['too slow', 'takes too long', 'quick', 'fast', 'efficient', 'automate'], weight: 0.8 },
+      { need: 'reliability', patterns: ['keeps breaking', 'unreliable', 'buggy', 'error', 'crash'], weight: 1.0 },
+      { need: 'understanding', patterns: ['explain', 'why', 'how', 'tell me', 'show me'], weight: 0.7 },
+      { need: 'autonomy', patterns: ['do it for me', 'just', 'automatically', 'without me'], weight: 0.6 },
+      { need: 'recognition', patterns: ['i want', 'i need', 'i\'ve been', 'finally', 'finally'], weight: 0.5 },
+    ];
+
+    for (const { need, patterns, weight } of needPatterns) {
+      let matchCount = 0;
+      for (const pattern of patterns) {
+        if (lower.includes(pattern)) matchCount++;
+      }
+      if (matchCount > 0) {
+        needs.push({ need, confidence: Math.min(matchCount / patterns.length * weight, 1) });
+      }
+    }
+
+    // Sort by confidence
+    needs.sort((a, b) => b.confidence - a.confidence);
+    return needs.slice(0, 4);
+  }
+
+  _detectDefenses(lower, words) {
+    const defenses = [];
+    
+    const defensePatterns = [
+      { defense: 'dismissal', patterns: ['whatever', 'i don\'t care', 'doesn\'t matter', 'not important'], weight: 1.0 },
+      { defense: 'deflection', patterns: ['you don\'t understand', 'that\'s not what i', 'nevermind', 'forget it'], weight: 0.9 },
+      { defense: 'hostility', patterns: ['stupid', 'useless', 'terrible', 'worst', 'hate'], weight: 1.0 },
+      { defense: 'evasion', patterns: ['i don\'t know', 'not sure', 'maybe', 'could be'], weight: 0.5 },
+      { defense: 'justification', patterns: ['but i', 'i was just', 'i thought', 'it\'s not my fault'], weight: 0.6 },
+    ];
+
+    for (const { defense, patterns, weight } of defensePatterns) {
+      let matchCount = 0;
+      for (const pattern of patterns) {
+        if (lower.includes(pattern)) matchCount++;
+      }
+      if (matchCount > 0) {
+        defenses.push({ defense, confidence: Math.min(matchCount / patterns.length * weight, 1) });
+      }
+    }
+
+    return defenses;
+  }
+
+  _computeConfidence(emotion, intent, needs, defenses) {
+    // Simple confidence: how many signals did we detect
+    const emotionSignals = emotion.signals.length + (emotion.punctuation !== 'neutral' ? 1 : 0);
+    const intentScore = intent.confidence;
+    const needSignals = needs.length;
+    const defenseSignals = defenses.length;
+    
+    const totalSignals = emotionSignals + (intentScore > 0 ? 1 : 0) + needSignals + defenseSignals;
+    
+    // Map to 0-1
+    return Math.min(totalSignals / 6, 1.0);
+  }
+
+  /**
+   * Convenience wrapper: analyze text and return perception
+   */
+  analyzePsychology(input) {
+    const result = this.perceive(input);
+    return result;
+  }
+
+  /**
+   * Classify input into broad categories
+   */
+  classify(input) {
+    const result = this.perceive(input);
+    
+    // Derive top-level category from intent
+    let category = result.intent.category;
+    if (!category || category === 'unknown') {
+      category = result.emotion.category === 'positive' ? 'positive_interaction'
+               : result.emotion.category === 'negative' ? 'negative_interaction'
+               : 'neutral';
+    }
+    
+    return {
+      category,
+      emotion: result.emotion.category,
+      confidence: result.confidence,
+    };
+  }
+}
+
+module.exports = { PsychologyEngine };