@yun520-1/heartflow 0.15.2 → 0.16.0

package/src/core/associative-engine/word-by-word-generator.js

@@ -1,222 +0,0 @@
-/**
- * L5 Word-by-Word Generator - 逐词回复生成层
- * 模拟人类说话过程，逐词生成回复
- */
-
-const fs = require('fs');
-const path = require('path');
-
-class WordByWordGenerator {
-  constructor(projectRoot) {
-    this.projectRoot = projectRoot;
-    this.stateFile = path.join(projectRoot, '.opencode', 'memory', 'word-gen-trace.json');
-    this.currentTrace = [];
-    this.vocabulary = this.loadVocabulary();
-  }
-
-  loadVocabulary() {
-    return {
-      common: ['我', '你', '他', '她', '它', '是', '在', '有', '和', '了', '这', '那', '也', '都', '就', '要', '可以', '知道', '认为', '觉得'],
-      emotional: ['开心', '难过', '感动', '担心', '放心', '期待', '感谢', '理解', '支持', '相信'],
-      flow: ['心流', '专注', '沉浸', '创造', '体验', '状态', '进入', '保持', '感受'],
-      transition: ['但是', '而且', '所以', '因为', '虽然', '如果', '不过', '其实', '然后']
-    };
-  }
-
-  /**
-   * 生成回复 (异步)
-   */
-  async generateResponse(thoughtVector, userModel = {}, maxLength = 200) {
-    this.currentTrace = [];
-    
-    const responseState = {
-      generatedWords: [],
-      thoughtVector,
-      userModel,
-      completed: false
-    };
-    
-    this.recordTrace('start', { thoughtVector: thoughtVector.dimensions, emotion: thoughtVector.emotion });
-    
-    const firstWord = this.selectFirstWord(thoughtVector);
-    responseState.generatedWords.push(firstWord);
-    this.recordTrace('select_first_word', { word: firstWord });
-    
-    while (!responseState.completed && this.getLength(responseState.generatedWords) < maxLength) {
-      const nextWord = await this.predictNextWord(responseState);
-      responseState.generatedWords.push(nextWord);
-      
-      this.recordTrace('predict_next', { 
-        word: nextWord, 
-        currentSequence: responseState.generatedWords.join('').slice(-30)
-      });
-      
-      if (this.shouldStop(responseState)) {
-        responseState.completed = true;
-      }
-      
-      await this.delay(10);
-    }
-    
-    const finalResponse = responseState.generatedWords.join('');
-    this.recordTrace('complete', { response: finalResponse });
-    
-    this.saveTrace();
-    
-    return {
-      response: finalResponse,
-      wordCount: responseState.generatedWords.length,
-      trace: this.currentTrace
-    };
-  }
-
-  delay(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
-
-  selectFirstWord(thoughtVector) {
-    const emotion = thoughtVector.emotion;
-    const concepts = Object.keys(thoughtVector.dimensions);
-    
-    if (emotion.pleasure > 2) {
-      return this.pickFrom(['我理解', '我能感受到', '很高兴', '真是'])[0];
-    }
-    
-    if (emotion.pleasure < -2) {
-      return this.pickFrom(['我理解', '很遗憾', '我明白', '没关系'])[0];
-    }
-    
-    if (concepts.length > 0) {
-      return concepts[0];
-    }
-    
-    return this.pickFrom(this.vocabulary.common)[0];
-  }
-
-  pickFrom(array) {
-    return array[Math.floor(Math.random() * array.length)];
-  }
-
-  async predictNextWord(state) {
-    const currentSeq = state.generatedWords.join('');
-    const lastWord = state.generatedWords[state.generatedWords.length - 1];
-    const thoughtDims = state.thoughtVector.dimensions;
-    
-    if (currentSeq.length < 5) {
-      if (this.isFunctionWord(lastWord)) {
-        return this.selectContentWord(thoughtDims);
-      }
-      return this.pickFrom(this.vocabulary.common)[0];
-    }
-    
-    if (currentSeq.endsWith('。') || currentSeq.endsWith('！') || currentSeq.endsWith('？')) {
-      if (Object.keys(thoughtDims).length > 0) {
-        const topConcept = Object.entries(thoughtDims)
-          .sort((a, b) => b[1] - a[1])[0]?.[0];
-        if (topConcept) return topConcept;
-      }
-      return this.pickFrom(['希望', '相信', '期待', '感谢'])[0];
-    }
-    
-    if (Math.random() < 0.3) {
-      return this.pickFrom(this.vocabulary.transition)[0];
-    }
-    
-    if (Math.random() < 0.2) {
-      return this.pickFrom(this.vocabulary.emotional)[0];
-    }
-    
-    return this.selectContentWord(thoughtDims);
-  }
-
-  isFunctionWord(word) {
-    const functionWords = ['是', '在', '有', '和', '了', '的', '也', '就', '要', '可以'];
-    return functionWords.includes(word);
-  }
-
-  selectContentWord(thoughtDims) {
-    const concepts = Object.keys(thoughtDims);
-    
-    if (concepts.length > 0) {
-      const weighted = concepts.sort((a, b) => thoughtDims[b] - thoughtDims[a]);
-      const selected = weighted[Math.floor(Math.random() * Math.min(3, weighted.length))];
-      if (selected) return selected;
-    }
-    
-    return this.pickFrom(this.vocabulary.flow)[0];
-  }
-
-  shouldStop(state) {
-    const words = state.generatedWords;
-    if (words.length < 3) return false;
-    
-    const lastChars = words.slice(-2).join('');
-    if (lastChars.endsWith('。') || lastChars.endsWith('！') || lastChars.endsWith('？')) {
-      return true;
-    }
-    
-    if (words.length > 30 && Math.random() < 0.3) {
-      return true;
-    }
-    
-    return false;
-  }
-
-  getLength(words) {
-    return words.join('').length;
-  }
-
-  recordTrace(step, data) {
-    this.currentTrace.push({
-      step,
-      data,
-      timestamp: Date.now(),
-      sequence: this.currentTrace.length + 1
-    });
-    // Cap trace size to prevent unbounded memory growth
-    if (this.currentTrace.length > 100) {
-      this.currentTrace.splice(0, this.currentTrace.length - 100);
-    }
-  }
-
-  saveTrace() {
-    const dir = path.dirname(this.stateFile);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-
-    const traceData = {
-      trace: this.currentTrace,
-      finalResponse: this.currentTrace.find(t => t.step === 'complete')?.data?.response || '',
-      timestamp: new Date().toISOString()
-    };
-
-    fs.promises.writeFile(this.stateFile, JSON.stringify(traceData, null, 2)).catch(e => {
-      console.error('[WordByWordGenerator] Save failed:', e.message);
-    });
-  }
-
-  getLastTrace() {
-    return this.currentTrace;
-  }
-
-  getFormattedTrace() {
-    return this.currentTrace.map(t => {
-      if (t.step === 'start') {
-        return `[逐词生成] 开始 - 思想向量: ${JSON.stringify(t.data.thoughtVector).slice(0, 50)}...`;
-      }
-      if (t.step === 'select_first_word') {
-        return `[逐词生成] 选择首词: ${t.data.word}`;
-      }
-      if (t.step === 'predict_next') {
-        return `[逐词生成] ${t.sequence}: ${t.data.word} (当前: ${t.data.currentSequence}...)`;
-      }
-      if (t.step === 'complete') {
-        return `[逐词生成] 完成: ${t.data.response}`;
-      }
-      return '';
-    }).filter(Boolean).join('\n');
-  }
-}
-
-module.exports = { WordByWordGenerator };

package/src/core/auto-upgrade-engine.js

@@ -1,56 +0,0 @@
-/**
- * HeartFlow Auto-Upgrade Engine
- * Version: 0.2.0
- */
-
-const { EventEmitter } = require('events');
-
-class AutoUpgradeEngine extends EventEmitter {
-    constructor(config = {}) {
-        super();
-        this.state = {
-            currentVersion: config.version || 'v0.13.14',
-            upgradeCount: 0,
-            papersProcessed: 0,
-            lastUpgrade: null
-        };
-        this.config = {
-            autoSave: config.autoSave !== false,
-            maxRetries: config.maxRetries || 3
-        };
-    }
-
-    /**
-     * Get engine state
-     */
-    getState() {
-        return { ...this.state };
-    }
-
-    /**
-     * Set version
-     */
-    setVersion(version) {
-        this.state.currentVersion = version;
-        this.emit('version-changed', version);
-    }
-
-    /**
-     * Increment upgrade count
-     */
-    incrementUpgrades() {
-        this.state.upgradeCount++;
-        this.state.lastUpgrade = Date.now();
-        this.emit('upgrade', this.state);
-    }
-
-    /**
-     * Process paper (stub)
-     */
-    processPaper(paper) {
-        this.state.papersProcessed++;
-        return { success: true, paper };
-    }
-}
-
-module.exports = { AutoUpgradeEngine };

package/src/core/autonomy/autonomous-decision.js

@@ -1,199 +0,0 @@
-/**
- * AutonomousDecision — 自主决策引擎
- * 
- * v0.15.0: 新增模块
- * 
- * 解决核心问题：
- * - AI每次都要问用户"你要哪个" → 决策疲劳
- * - AI不主动行动，等用户指令 → 效率低
- * - 长任务中间停下等确认 → 任务中断
- * 
- * 解决方案：
- * - PDCA循环自主执行（Plan→Do→Check→Act）
- * - 决策阈值：低于阈值自动执行，高于阈值才问用户
- * -  destructive操作可配置确认
- */
-
-const path = require('path');
-const { PDCAEngine } = require('./pdca-engine');
-
-class AutonomousDecision {
-  constructor(projectRoot) {
-    this.projectRoot = projectRoot;
-    this.pdca = new PDCAEngine(projectRoot);
-    
-    // 决策配置
-    this.config = {
-      // 破坏性操作需要确认
-      destructiveConfirmation: true,
-      // 自动执行的最大循环数
-      maxAutonomousCycles: 5,
-      // 决策置信度阈值（低于此值需要用户确认）
-      confidenceThreshold: 0.7,
-      // 是否自动执行（非 destructive 操作）
-      autoExecute: true,
-    };
-    
-    this._loadConfig();
-  }
-  
-  _loadConfig() {
-    try {
-      const fs = require('fs');
-      const configPath = path.join(this.projectRoot, '.opencode', 'config.json');
-      if (fs.existsSync(configPath)) {
-        const cfg = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-        if (cfg.requireConfirmationForDestructiveActions !== undefined) {
-          this.config.destructiveConfirmation = cfg.requireConfirmationForDestructiveActions;
-        }
-        if (cfg.maxAutonomousStepsPerCycle) {
-          this.config.maxAutonomousCycles = cfg.maxAutonomousStepsPerCycle;
-        }
-      }
-    } catch {}
-  }
-
-  /**
-   * 评估决策置信度
-   * @param {object} context - { task, history, user_profile? }
-   * @returns {number} 0-1
-   */
-  evaluateConfidence(context = {}) {
-    const { task, history = [] } = context;
-    
-    // 基础分：任务复杂度
-    let confidence = 0.5;
-    
-    // 有历史参考 +0.2
-    if (history.length > 0) {
-      const recentSimilar = history.filter(h => 
-        h.task && task && h.task.includes(task.substring(0, 20))
-      ).length;
-      if (recentSimilar > 0) confidence += 0.2;
-    }
-    
-    // 任务明确（不是开放式问题）+0.15
-    if (task && (task.includes('完成') || task.includes('执行') || task.includes('修复'))) {
-      confidence += 0.15;
-    }
-    
-    // 非破坏性操作 +0.15
-    const destructiveKeywords = ['删除', '删除', 'rm ', 'drop ', 'truncate', 'force push', '--force'];
-    if (!destructiveKeywords.some(k => task && task.toLowerCase().includes(k))) {
-      confidence += 0.15;
-    }
-    
-    return Math.min(1, Math.max(0, confidence));
-  }
-
-  /**
-   * 判断是否需要用户确认
-   * @param {object} decision - { action, confidence }
-   */
-  requiresConfirmation(decision = {}) {
-    if (!this.config.destructiveConfirmation) return false;
-    
-    const destructiveKeywords = [
-      'delete', 'remove', 'drop', 'truncate', 'force',
-      '删除', '移除', '删除', '强制'
-    ];
-    
-    const isDestructive = destructiveKeywords.some(k => 
-      decision.action && decision.action.toLowerCase().includes(k)
-    );
-    
-    if (isDestructive) return true;
-    
-    // 低于置信度阈值
-    if (decision.confidence !== undefined && decision.confidence < this.config.confidenceThreshold) {
-      return true;
-    }
-    
-    return false;
-  }
-
-  /**
-   * 自主决策执行
-   * @param {string} goal - 目标描述
-   * @param {object} options - { autoConfirm?, context? }
-   * @returns {object} { decision, action, result, needsConfirmation }
-   */
-  async decide(goal, options = {}) {
-    const confidence = this.evaluateConfidence({ task: goal });
-    const needsConfirmation = this.requiresConfirmation({ action: goal, confidence });
-    
-    if (needsConfirmation && !options.autoConfirm) {
-      return {
-        decision: 'awaiting_confirmation',
-        confidence,
-        reason: 'destructive_or_low_confidence',
-        suggestion: this._suggestConfirmation(goal),
-        needsConfirmation: true,
-      };
-    }
-    
-    // 执行 PDCA 循环
-    try {
-      const result = await this.pdca.executeAutonomousCycle({
-        goal_id: `goal_${Date.now()}`,
-        description: goal,
-      });
-      
-      return {
-        decision: result.status === 'completed' ? 'executed' : 'partial',
-        confidence,
-        result,
-        needsConfirmation: false,
-      };
-    } catch (error) {
-      return {
-        decision: 'failed',
-        confidence,
-        error: error.message,
-        needsConfirmation: false,
-      };
-    }
-  }
-
-  /**
-   * 快速执行（不需要确认）
-   * @param {string} goal
-   */
-  async execute(goal) {
-    return this.decide(goal, { autoConfirm: true });
-  }
-
-  /**
-   * 生成确认建议
-   */
-  _suggestConfirmation(goal) {
-    const destructiveKeywords = ['删除', 'remove', 'delete', 'drop', 'force'];
-    const isDestructive = destructiveKeywords.some(k => goal.toLowerCase().includes(k));
-    
-    if (isDestructive) {
-      return {
-        type: 'destructive_action',
-        warning: '这是一个破坏性操作',
-        suggestion: '确认要执行吗？',
-      };
-    }
-    
-    return {
-      type: 'low_confidence',
-      warning: '置信度较低',
-      suggestion: '建议先验证目标',
-    };
-  }
-
-  /**
-   * 获取状态
-   */
-  getStatus() {
-    return {
-      config: this.config,
-      pdcaStatus: this.pdca.getStatus(),
-    };
-  }
-}
-
-module.exports = { AutonomousDecision };