@yun520-1/heartflow 0.15.2

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

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

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

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