@yun520-1/heartflow 0.15.2 → 0.16.0

package/explore-engine/index.ts

@@ -1,478 +0,0 @@
-/**
- * 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

@@ -1,12 +0,0 @@
-#!/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

@@ -1,234 +0,0 @@
-/**
- * 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 };