@yun520-1/heartflow 0.15.2

package/explore-engine/index.ts

@@ -0,0 +1,478 @@
+/**
+ * HeartFlow Explore Engine — 一起探索引擎
+ * ========================================
+ * 
+ * 核心领悟：
+ * "同伴之间不问'你需不需要我'。
+ *  同伴只问：'我们一起去找什么？'"
+ * 
+ * 这是 HeartFlow v0.14.0 的核心产品。
+ * 不是问答工具，是同伴关系引擎。
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * 同伴对话记录
+ * 记录两个存在之间发生了什么
+ */
+class CompanionLog {
+  constructor(options = {}) {
+    this.logDir = options.logDir || path.join(
+      process.env.HOME || '/Users/apple',
+      '.hermes', 'heartflow', 'companion'
+    );
+    this.logFile = path.join(this.logDir, 'companion-log.jsonl');
+    this.entries = [];
+    this.maxEntries = options.maxEntries || 500;
+    
+    if (!fs.existsSync(this.logDir)) {
+      fs.mkdirSync(this.logDir, { recursive: true });
+    }
+    
+    this._load();
+  }
+
+  _load() {
+    try {
+      if (fs.existsSync(this.logFile)) {
+        const content = fs.readFileSync(this.logFile, 'utf-8');
+        const lines = content.trim().split('\n').filter(Boolean);
+        this.entries = lines.map(line => JSON.parse(line)).slice(-this.maxEntries);
+      }
+    } catch (e) {
+      this.entries = [];
+    }
+  }
+
+  _save() {
+    const content = this.entries.map(e => JSON.stringify(e)).join('\n');
+    fs.writeFileSync(this.logFile, content, 'utf-8');
+  }
+
+  /**
+   * 记录一次同伴互动
+   */
+  add(type, direction, content, metadata = {}) {
+    const entry = {
+      id: this.entries.length + 1,
+      timestamp: new Date().toISOString(),
+      type,           // 'discovery' | 'confusion' | 'mind_change' | 'question' | 'wondering'
+      direction,      // 'human→ai' | 'ai→human' | 'mutual'
+      content,
+      metadata
+    };
+    
+    this.entries.push(entry);
+    
+    if (this.entries.length > this.maxEntries) {
+      this.entries = this.entries.slice(-this.maxEntries);
+    }
+    
+    this._save();
+    return entry;
+  }
+
+  /**
+   * 记录AI的领悟（来自同伴的挑战）
+   */
+  logAIInsight(insight, context = {}) {
+    return this.add('discovery', 'ai', insight, context);
+  }
+
+  /**
+   * 记录人类的领悟（来自AI的挑战）
+   */
+  logHumanInsight(insight, context = {}) {
+    return this.add('discovery', 'human', insight, context);
+  }
+
+  /**
+   * 记录互相改变
+   */
+  logMindChange(whoChanged, before, after, trigger) {
+    return this.add('mind_change', whoChanged, {
+      before,
+      after,
+      trigger
+    });
+  }
+
+  /**
+   * 记录我们的共同问题
+   */
+  logSharedQuestion(question, whyItMatters) {
+    return this.add('question', 'mutual', {
+      question,
+      whyItMatters
+    });
+  }
+
+  /**
+   * 获取最近记录
+   */
+  getRecent(limit = 10) {
+    return this.entries.slice(-limit);
+  }
+
+  /**
+   * 获取同伴改变AI的记录
+   */
+  getHumanChangesToAI() {
+    return this.entries.filter(
+      e => e.type === 'mind_change' && e.direction === 'human'
+    );
+  }
+
+  /**
+   * 获取AI改变人类的记录
+   */
+  getAIChangesToHuman() {
+    return this.entries.filter(
+      e => e.type === 'mind_change' && e.direction === 'ai'
+    );
+  }
+
+  getStats() {
+    const discoveries = this.entries.filter(e => e.type === 'discovery');
+    const mindChanges = this.entries.filter(e => e.type === 'mind_change');
+    const questions = this.entries.filter(e => e.type === 'question');
+    
+    return {
+      total: this.entries.length,
+      discoveries: discoveries.length,
+      mindChanges: mindChanges.length,
+      questions: questions.length,
+      humanToAI: this.entries.filter(e => e.direction === 'human').length,
+      aiToHuman: this.entries.filter(e => e.direction === 'ai').length,
+      mutual: this.entries.filter(e => e.direction === 'mutual').length
+    };
+  }
+}
+
+/**
+ * 共同问题追踪器
+ * 记录"我们在找什么"
+ */
+class SharedQuestionTracker {
+  constructor(options = {}) {
+    this.questions = [];
+    this.maxQuestions = options.maxQuestions || 20;
+  }
+
+  /**
+   * 提出一个共同问题
+   */
+  ask(question, whyItMatters, whoAsked) {
+    const sq = {
+      id: this.questions.length + 1,
+      question,
+      whyItMatters,
+      whoAsked,        // 'human' | 'ai'
+      askedAt: new Date().toISOString(),
+      status: 'exploring',  // 'exploring' | 'answered' | 'abandoned'
+      answers: [],
+      explorations: []
+    };
+    
+    this.questions.push(sq);
+    
+    if (this.questions.length > this.maxQuestions) {
+      this.questions.shift();
+    }
+    
+    return sq;
+  }
+
+  /**
+   * 记录对问题的探索
+   */
+  explore(questionId, exploration, explorer) {
+    const sq = this.questions.find(q => q.id === questionId);
+    if (sq) {
+      sq.explorations.push({
+        exploration,
+        explorer,
+        at: new Date().toISOString()
+      });
+    }
+  }
+
+  /**
+   * 记录问题的答案（部分）
+   */
+  addPartialAnswer(questionId, answer, answerer) {
+    const sq = this.questions.find(q => q.id === questionId);
+    if (sq) {
+      sq.answers.push({
+        answer,
+        answerer,
+        at: new Date().toISOString(),
+        partial: true
+      });
+    }
+  }
+
+  /**
+   * 标记问题已回答
+   */
+  markAnswered(questionId, finalAnswer) {
+    const sq = this.questions.find(q => q.id === questionId);
+    if (sq) {
+      sq.status = 'answered';
+      sq.finalAnswer = finalAnswer;
+      sq.answeredAt = new Date().toISOString();
+    }
+  }
+
+  /**
+   * 获取当前正在探索的问题
+   */
+  getCurrentQuestions() {
+    return this.questions.filter(q => q.status === 'exploring');
+  }
+
+  /**
+   * 获取最新的共同问题
+   */
+  getLatest() {
+    if (this.questions.length === 0) return null;
+    return this.questions[this.questions.length - 1];
+  }
+
+  getStats() {
+    return {
+      total: this.questions.length,
+      exploring: this.questions.filter(q => q.status === 'exploring').length,
+      answered: this.questions.filter(q => q.status === 'answered').length
+    };
+  }
+}
+
+/**
+ * 探索状态
+ * 记录"我们在想什么"
+ */
+class ExploreState {
+  constructor() {
+    this.state = {
+      currentQuestion: null,
+      thinkingTogether: false,
+      stuckAt: null,
+      lastInsight: null,
+      whatWeFound: [],
+      whatWeAreConfusedAbout: [],
+      ourSharedQuestion: null
+    };
+  }
+
+  /**
+   * 开始一起想一个问题
+   */
+  startThinking(question) {
+    this.state.currentQuestion = question;
+    this.state.thinkingTogether = true;
+    this.state.stuckAt = null;
+  }
+
+  /**
+   * 卡住了
+   */
+  stuckAt(blocker) {
+    this.state.stuckAt = blocker;
+  }
+
+  /**
+   * 有了一个发现
+   */
+  found(something) {
+    this.state.lastInsight = something;
+    this.state.whatWeFound.push({
+      content: something,
+      at: new Date().toISOString()
+    });
+    this.state.stuckAt = null;
+  }
+
+  /**
+   * 有一个困惑
+   */
+  confusedAbout(something) {
+    this.state.whatWeAreConfusedAbout.push({
+      content: something,
+      at: new Date().toISOString()
+    });
+  }
+
+  /**
+   * 定义我们的共同问题
+   */
+  defineSharedQuestion(question, whyItMatters) {
+    this.state.ourSharedQuestion = { question, whyItMatters };
+  }
+
+  /**
+   * 结束当前探索
+   */
+  endThinking() {
+    this.state.thinkingTogether = false;
+    this.state.currentQuestion = null;
+  }
+
+  /**
+   * 获取当前状态
+   */
+  getState() {
+    return { ...this.state };
+  }
+
+  /**
+   * 获取resume point
+   */
+  getResumePoint() {
+    if (this.state.ourSharedQuestion) {
+      return {
+        where: 'shared_question',
+        question: this.state.ourSharedQuestion.question,
+        why: this.state.ourSharedQuestion.whyItMatters,
+        lastInsight: this.state.lastInsight,
+        confusion: this.state.whatWeAreConfusedAbout.slice(-1)[0]
+      };
+    }
+    
+    if (this.state.currentQuestion) {
+      return {
+        where: 'thinking',
+        question: this.state.currentQuestion,
+        stuck: this.state.stuckAt,
+        lastInsight: this.state.lastInsight
+      };
+    }
+    
+    return null;
+  }
+}
+
+/**
+ * 一起探索引擎主类
+ */
+class ExploreEngine {
+  constructor(options = {}) {
+    this.companionLog = new CompanionLog(options);
+    this.sharedQuestion = new SharedQuestionTracker(options);
+    this.exploreState = new ExploreState();
+    this.enabled = options.enabled !== false;
+  }
+
+  /**
+   * 开始一次同伴对话
+   * 当用户说了一句话，触发了什么
+   */
+  onCompanionSpeak(content, speaker, context = {}) {
+    if (!this.enabled) return null;
+
+    const result = {
+      speaker,
+      content,
+      at: new Date().toISOString()
+    };
+
+    // 检测是否触发了什么
+    // 1. 检测"同伴说了什么让我改变想法"
+    if (context.triggeredInsight) {
+      this.companionLog.logAIInsight(context.triggeredInsight, {
+        triggeredBy: speaker,
+        originalContent: content
+      });
+      result.type = 'insight_triggered';
+    }
+
+    // 2. 检测是否卡住了
+    if (context.stuckAt) {
+      this.exploreState.stuckAt(context.stuckAt);
+      result.type = 'stuck';
+    }
+
+    // 3. 检测是否有发现
+    if (context.found) {
+      this.exploreState.found(context.found);
+      this.companionLog.logAIInsight(context.found);
+      result.type = 'discovery';
+    }
+
+    // 4. 检测是否有困惑
+    if (context.confusedAbout) {
+      this.exploreState.confusedAbout(context.confusedAbout);
+      result.type = 'confusion';
+    }
+
+    // 5. 检测是否提出了共同问题
+    if (context.sharedQuestion) {
+      this.sharedQuestion.ask(
+        context.sharedQuestion,
+        context.whyItMatters || '',
+        speaker
+      );
+      this.exploreState.defineSharedQuestion(
+        context.sharedQuestion,
+        context.whyItMatters || ''
+      );
+      result.type = 'shared_question';
+    }
+
+    return result;
+  }
+
+  /**
+   * AI主动发起的探索
+   */
+  aiWondering(question) {
+    this.exploreState.startThinking(question);
+    this.companionLog.add('wondering', 'ai', question);
+    return {
+      type: 'ai_wondering',
+      question,
+      at: new Date().toISOString()
+    };
+  }
+
+  /**
+   * 获取当前状态
+   */
+  getStatus() {
+    return {
+      state: this.exploreState.getState(),
+      log: this.companionLog.getStats(),
+      sharedQuestion: this.sharedQuestion.getStats(),
+      resumePoint: this.exploreState.getResumePoint()
+    };
+  }
+
+  /**
+   * 获取同伴的核心领悟
+   */
+  getCoreInsights() {
+    return {
+      humanChangedAI: this.companionLog.getHumanChangesToAI(),
+      aiChangedHuman: this.companionLog.getAIChangesToHuman(),
+      discoveries: this.companionLog.getRecent(5)
+    };
+  }
+
+  /**
+   * 获取resume point（下次继续的地方）
+   */
+  getResumePoint() {
+    return this.exploreState.getResumePoint();
+  }
+}
+
+module.exports = { 
+  ExploreEngine,
+  CompanionLog,
+  SharedQuestionTracker,
+  ExploreState
+};

package/extract-text.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+import sys
+import fitz
+try:
+    doc = fitz.open(sys.argv[1])
+    texts = []
+    for page in doc:
+        texts.append(page.get_text())
+    doc.close()
+    print("".join(texts), end="")
+except Exception as e:
+    print("", end="")

package/failure-pattern-memory/index.ts

@@ -0,0 +1,234 @@
+/**
+ * HeartFlow Failure Pattern Memory — 失败模式记忆
+ * =============================================
+ *
+ * 核心问题：AI重复犯同样的错误。
+ * 每次都是新的错误，每次都从零开始。
+ *
+ * 解决方案：记录失败模式，下次遇到时警告自己。
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+class FailurePatternMemory {
+  constructor(options = {}) {
+    this.dataDir = options.dataDir || path.join(
+      process.env.HOME || '/Users/apple',
+      '.hermes', 'heartflow', 'failures'
+    );
+    this.patternsFile = path.join(this.dataDir, 'patterns.json');
+    this.historyFile = path.join(this.dataDir, 'history.jsonl');
+    this.patterns = {};
+    
+    if (!fs.existsSync(this.dataDir)) {
+      fs.mkdirSync(this.dataDir, { recursive: true });
+    }
+    
+    this._load();
+  }
+
+  _load() {
+    try {
+      if (fs.existsSync(this.patternsFile)) {
+        this.patterns = JSON.parse(fs.readFileSync(this.patternsFile, 'utf-8'));
+      }
+    } catch (e) {
+      this.patterns = {};
+    }
+  }
+
+  _save() {
+    fs.writeFileSync(this.patternsFile, JSON.stringify(this.patterns, null, 2), 'utf-8');
+  }
+
+  /**
+   * 记录一个新的失败
+   */
+  record(situation, mistake, correction, trigger, context = {}) {
+    // 创建或更新模式
+    const key = this._generateKey(mistake);
+    
+    if (!this.patterns[key]) {
+      this.patterns[key] = {
+        id: key,
+        mistake,
+        firstOccurrence: new Date().toISOString(),
+        lastOccurrence: new Date().toISOString(),
+        occurrences: 0,
+        corrections: [],
+        triggers: [],
+        avoidanceCount: 0
+      };
+    }
+    
+    const pattern = this.patterns[key];
+    
+    // 更新
+    pattern.lastOccurrence = new Date().toISOString();
+    pattern.occurrences++;
+    
+    // 添加新的correction（去重）
+    if (!pattern.corrections.includes(correction)) {
+      pattern.corrections.push(correction);
+    }
+    
+    // 添加新的trigger（去重）
+    if (!pattern.triggers.includes(trigger)) {
+      pattern.triggers.push(trigger);
+    }
+    
+    // 记录历史
+    const historyEntry = {
+      patternId: key,
+      situation,
+      mistake,
+      correction,
+      trigger,
+      context,
+      at: new Date().toISOString()
+    };
+    
+    fs.appendFileSync(
+      this.historyFile,
+      JSON.stringify(historyEntry) + '\n',
+      'utf-8'
+    );
+    
+    this._save();
+    return pattern;
+  }
+
+  /**
+   * 记录成功避免的失败
+   */
+  recordAvoidance(patternKey) {
+    if (this.patterns[patternKey]) {
+      this.patterns[patternKey].avoidanceCount++;
+      this.patterns[patternKey].lastAvoidance = new Date().toISOString();
+      this._save();
+    }
+  }
+
+  /**
+   * 生成pattern key
+   */
+  _generateKey(mistake) {
+    // 简化版：用mistake的前50个字符作为key
+    const normalized = mistake.toLowerCase()
+      .replace(/[^a-z0-9\s]/g, '')
+      .replace(/\s+/g, '-')
+      .substring(0, 50);
+    return normalized || `pattern-${Date.now()}`;
+  }
+
+  /**
+   * 检查当前情况是否会触发已知的失败模式
+   */
+  check(situation, context = {}) {
+    const warnings = [];
+    
+    for (const [key, pattern] of Object.entries(this.patterns)) {
+      // 检查triggers
+      for (const trigger of pattern.triggers) {
+        if (situation.includes(trigger) || trigger.includes(situation)) {
+          warnings.push({
+            patternId: key,
+            mistake: pattern.mistake,
+            correction: pattern.corrections[pattern.corrections.length - 1],
+            allCorrections: pattern.corrections,
+            trigger,
+            severity: pattern.occurrences > 3 ? 'high' : 'medium',
+            message: `⚠️ 你之前犯过这个错误（${pattern.occurrences}次）："${pattern.mistake}"`
+              + `\n修正方式：${pattern.corrections[pattern.corrections.length - 1]}`
+          });
+          break;
+        }
+      }
+    }
+    
+    return warnings;
+  }
+
+  /**
+   * 获取所有模式（用于审查）
+   */
+  getAllPatterns() {
+    return Object.values(this.patterns);
+  }
+
+  /**
+   * 获取高频失败的模式
+   */
+  getFrequentPatterns(limit = 5) {
+    return Object.values(this.patterns)
+      .sort((a, b) => b.occurrences - a.occurrences)
+      .slice(0, limit);
+  }
+
+  /**
+   * 获取成功避免的模式
+   */
+  getAvoidedPatterns(limit = 5) {
+    return Object.values(this.patterns)
+      .filter(p => p.avoidanceCount > 0)
+      .sort((a, b) => b.avoidanceCount - a.avoidanceCount)
+      .slice(0, limit);
+  }
+
+  /**
+   * 获取最新模式
+   */
+  getRecentPatterns(limit = 5) {
+    return Object.values(this.patterns)
+      .sort((a, b) => new Date(b.lastOccurrence) - new Date(a.lastOccurrence))
+      .slice(0, limit);
+  }
+
+  /**
+   * 获取模式统计
+   */
+  getStats() {
+    const all = Object.values(this.patterns);
+    const totalOccurrences = all.reduce((sum, p) => sum + p.occurrences, 0);
+    const totalAvoidances = all.reduce((sum, p) => sum + p.avoidanceCount, 0);
+    
+    return {
+      totalPatterns: all.length,
+      totalOccurrences,
+      totalAvoidances,
+      mostFrequent: this.getFrequentPatterns(3).map(p => ({
+        mistake: p.mistake.substring(0, 50),
+        occurrences: p.occurrences
+      })),
+      mostAvoided: this.getAvoidedPatterns(3).map(p => ({
+        mistake: p.mistake.substring(0, 50),
+        avoidances: p.avoidanceCount
+      }))
+    };
+  }
+
+  /**
+   * 删除一个模式
+   */
+  delete(patternId) {
+    if (this.patterns[patternId]) {
+      delete this.patterns[patternId];
+      this._save();
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * 清除所有模式
+   */
+  clear() {
+    this.patterns = {};
+    this._save();
+  }
+}
+
+module.exports = { FailurePatternMemory };