@yun520-1/heartflow 0.15.2

package/patches/self-modifier-v2.2.2.patch

@@ -0,0 +1,252 @@
+diff --git a/src/core/self-modifier.js b/src/core/self-modifier.js
+index 155151c..19e0b3a 100644
+--- a/src/core/self-modifier.js
++++ b/src/core/self-modifier.js
+@@ -15,6 +15,14 @@ class SelfModifier {
+     this.configFile = path.join(projectRoot, CONFIG_FILE);
+     this.enabled = this.isEnabled();
+     this.changeLog = path.join(projectRoot, 'logs', 'self-modifier.log');
++    this.patchDir = path.join(projectRoot, 'patches');
++    this.init();
++  }
++
++  init() {
++    if (!fs.existsSync(this.patchDir)) {
++      fs.mkdirSync(this.patchDir, { recursive: true });
++    }
+   }
+ 
+   isEnabled() {
+@@ -233,6 +241,232 @@ class SelfModifier {
+     return [];
+   }
+ 
++  /**
++   * 元认知自我修改 - 生成补丁文件而非直接应用
++   * 核心要求：所有修改必须生成 .patch 文件交由用户审查
++   */
++  async metacognitiveModify(suggestion) {
++    if (!this.enabled) {
++      return { 
++        success: false, 
++        reason: 'self_modification_disabled',
++        action: 'generate_patch_only'
++      };
++    }
++
++    this.log(`Meta-cognitive modification: ${suggestion.type || 'unknown'}`);
++
++    const parsed = this.parseSuggestion(suggestion);
++    if (!parsed) {
++      return { success: false, reason: 'cannot_parse_suggestion' };
++    }
++
++    const filePath = path.join(this.projectRoot, parsed.file);
++    if (!fs.existsSync(filePath)) {
++      return { success: false, reason: 'file_not_found', path: parsed.file };
++    }
++
++    const originalContent = fs.readFileSync(filePath, 'utf8');
++    const modifiedContent = this.applyModification(originalContent, parsed);
++
++    if (modifiedContent === originalContent) {
++      return { success: false, reason: 'no_changes_made' };
++    }
++
++    const patch = this.generatePatch(originalContent, modifiedContent, parsed);
++    const patchFileName = `self-mod-${Date.now()}.patch`;
++    const patchPath = path.join(this.patchDir, patchFileName);
++
++    fs.writeFileSync(patchPath, patch);
++
++    this.recordChange({
++      file: parsed.file,
++      suggestion: suggestion.type,
++      timestamp: new Date().toISOString(),
++      action: 'patch_generated',
++      patchFile: patchFileName,
++      requiresApproval: true
++    });
++
++    this.log(`Patch generated: ${patchFileName} (requires user approval)`);
++
++    return {
++      success: true,
++      action: 'patch_generated',
++      patchFile: patchFileName,
++      patchPath: patchPath,
++      description: this.describeChanges(originalContent, modifiedContent),
++      requiresApproval: true,
++      instructions: '请审查 patches/ 目录下的补丁文件，使用 "patch -p1 < patches/xxx.patch" 应用'
++    };
++  }
++
++  generatePatch(original, modified, parsed) {
++    const timestamp = new Date().toISOString();
++    const diff = this.computeSimpleDiff(original, modified);
++    
++    const patch = `# Self-Modifier 补丁文件
++# 生成时间: ${timestamp}
++# 目标文件: ${parsed.file}
++# 修改类型: ${parsed.type || 'unknown'}
++#
++# 审查后使用以下命令应用:
++#   patch -p1 < patches/${`self-mod-${Date.now()}.patch`}
++#
++# 撤销补丁:
++#   patch -R -p1 < patches/${`self-mod-${Date.now()}.patch`}
++#
++# ============================================================================
++--- a/${parsed.file}
+++++ b/${parsed.file}
++${diff}
++`;
++
++    return patch;
++  }
++
++  computeSimpleDiff(original, modified) {
++    const origLines = original.split('\n');
++    const modLines = modified.split('\n');
++    let diff = '';
++    let lineNum = 0;
++
++    for (let i = 0; i < Math.max(origLines.length, modLines.length); i++) {
++      lineNum = i + 1;
++      const origLine = origLines[i] || '';
++      const modLine = modLines[i] || '';
++
++      if (origLine !== modLine) {
++        if (origLine && !modLine) {
++          diff += `@@ -${lineNum},1 +${lineNum},0 @@\n-${origLine}\n`;
++        } else if (!origLine && modLine) {
++          diff += `@@ -${lineNum},0 +${lineNum},1 @@\n+${modLine}\n`;
++        } else {
++          diff += `@@ -${lineNum},1 +${lineNum},1 @@\n-${origLine}\n+${modLine}\n`;
++        }
++      }
++    }
++
++    return diff || '(无差异 - 可能为格式调整)';
++  }
++
++  /**
++   * 列出待审批的补丁文件
++   */
++  listPendingPatches() {
++    try {
++      const files = fs.readdirSync(this.patchDir)
++        .filter(f => f.endsWith('.patch'))
++        .map(f => {
++          const stat = fs.statSync(path.join(this.patchDir, f));
++          return {
++            file: f,
++            created: stat.mtime.toISOString(),
++            size: stat.size
++          };
++        });
++      return files;
++    } catch (e) {
++      return [];
++    }
++  }
++
++  /**
++   * 应用已审批的补丁
++   */
++  async applyApprovedPatch(patchFileName) {
++    const patchPath = path.join(this.patchDir, patchFileName);
++    
++    if (!fs.existsSync(patchPath)) {
++      return { success: false, reason: 'patch_not_found' };
++    }
++
++    try {
++      const patchContent = fs.readFileSync(patchPath, 'utf8');
++      const targetFile = this.extractTargetFromPatch(patchContent);
++      
++      if (!targetFile) {
++        return { success: false, reason: 'invalid_patch_format' };
++      }
++
++      const targetPath = path.join(this.projectRoot, targetFile);
++      if (!fs.existsSync(targetPath)) {
++        return { success: false, reason: 'target_file_not_found' };
++      }
++
++      const originalContent = fs.readFileSync(targetPath, 'utf8');
++      const modifiedContent = this.applyPatchToContent(originalContent, patchContent);
++
++      fs.writeFileSync(targetPath, modifiedContent);
++      
++      this.recordChange({
++        file: targetFile,
++        action: 'patch_applied',
++        patchFile: patchFileName,
++        timestamp: new Date().toISOString()
++      });
++
++      this.log(`Applied approved patch: ${patchFileName}`);
++
++      return {
++        success: true,
++        file: targetFile,
++        description: this.describeChanges(originalContent, modifiedContent)
++      };
++    } catch (e) {
++      return { success: false, error: e.message };
++    }
++  }
++
++  extractTargetFromPatch(patchContent) {
++    const match = patchContent.match(/^\+\+\+ b\/(.+)$/m);
++    return match ? match[1] : null;
++  }
++
++  applyPatchToContent(content, patchContent) {
++    const lines = content.split('\n');
++    const patchLines = patchContent.split('\n');
++    let result = [...lines];
++    let offset = 0;
++
++    for (const line of patchLines) {
++      if (line.startsWith('+') && !line.startsWith('+++')) {
++        const insertLine = line.substring(1);
++        result.splice(offset, 0, insertLine);
++        offset++;
++      } else if (line.startsWith('-') && !line.startsWith('---')) {
++        result.splice(offset, 1);
++      } else if (line.startsWith('@@')) {
++        // 跳过 hunk 头
++      }
++    }
++
++    return result.join('\n');
++  }
++
++  /**
++   * 拒绝并删除补丁
++   */
++  rejectPatch(patchFileName) {
++    const patchPath = path.join(this.patchDir, patchFileName);
++    
++    if (!fs.existsSync(patchPath)) {
++      return { success: false, reason: 'patch_not_found' };
++    }
++
++    fs.unlinkSync(patchPath);
++    
++    this.recordChange({
++      action: 'patch_rejected',
++      patchFile: patchFileName,
++      timestamp: new Date().toISOString()
++    });
++
++    this.log(`Rejected and removed patch: ${patchFileName}`);
++
++    return { success: true };
++  }
++
+   enable() {
+     this.setConfig(true);
+     this.enabled = true;

package/run-full-audit.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+cd "$SCRIPT_DIR"
+bash scripts/full-audit.sh

package/run-github-audit.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+/opt/homebrew/bin/node "$SCRIPT_DIR/cron/github-audit.mjs"

package/run-hf.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+export PATH="/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin"
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+cd "$SCRIPT_DIR"
+node src/core/heartflow.js "$@"

package/run-paper-upgrade.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+# HeartFlow Paper Upgrade Runner - v3.1
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+cd "$SCRIPT_DIR"
+node cron/upgrade-runner.mjs

package/session-continuity/index.ts

@@ -0,0 +1,262 @@
+/**
+ * HeartFlow Session Continuity — 会话连续性
+ * =========================================
+ *
+ * 核心问题：每个session结束后，AI就消失了。
+ * 上次发现了什么、困惑了什么、改变了什么——全部丢失。
+ *
+ * 解决方案：记录，保存，恢复。
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+class SessionContinuity {
+  constructor(options = {}) {
+    this.dataDir = options.dataDir || path.join(
+      process.env.HOME || '/Users/apple',
+      '.hermes', 'heartflow', 'continuity'
+    );
+    this.sessionFile = path.join(this.dataDir, 'current-session.json');
+    this.historyFile = path.join(this.dataDir, 'session-history.jsonl');
+    this.state = null;
+    
+    if (!fs.existsSync(this.dataDir)) {
+      fs.mkdirSync(this.dataDir, { recursive: true });
+    }
+    
+    this._load();
+  }
+
+  _load() {
+    try {
+      if (fs.existsSync(this.sessionFile)) {
+        this.state = JSON.parse(fs.readFileSync(this.sessionFile, 'utf-8'));
+      }
+    } catch (e) {
+      this.state = this._newState();
+    }
+  }
+
+  _save() {
+    fs.writeFileSync(this.sessionFile, JSON.stringify(this.state, null, 2), 'utf-8');
+  }
+
+  _newState() {
+    return {
+      sessionId: `session-${Date.now()}`,
+      startedAt: new Date().toISOString(),
+      whatIDiscovered: [],
+      whatUserTaughtMe: [],
+      howIChanged: {},
+      currentQuestion: null,
+      resumePoint: null,
+      failuresAvoided: [],
+      sharedInsights: [],
+      lastActiveAt: new Date().toISOString()
+    };
+  }
+
+  /**
+   * 开始新session
+   */
+  startSession() {
+    this.state = this._newState();
+    this._save();
+    return this.state;
+  }
+
+  /**
+   * 记录AI的发现
+   */
+  recordDiscovery(discovery, context = {}) {
+    const entry = {
+      id: `disc-${Date.now()}`,
+      content: discovery,
+      context,
+      at: new Date().toISOString()
+    };
+    this.state.whatIDiscovered.push(entry);
+    this.state.lastActiveAt = entry.at;
+    this._save();
+    return entry;
+  }
+
+  /**
+   * 记录用户教我的东西
+   */
+  recordUserTeaching(teaching, context = {}) {
+    const entry = {
+      id: `teach-${Date.now()}`,
+      content: teaching,
+      context,
+      at: new Date().toISOString()
+    };
+    this.state.whatUserTaughtMe.push(entry);
+    this.state.lastActiveAt = entry.at;
+    this._save();
+    return entry;
+  }
+
+  /**
+   * 记录AI的想法改变
+   */
+  recordMindChange(before, after, trigger) {
+    const entry = {
+      id: `change-${Date.now()}`,
+      before,
+      after,
+      trigger,
+      at: new Date().toISOString()
+    };
+    this.state.howIChanged[entry.id] = entry;
+    this.state.lastActiveAt = entry.at;
+    this._save();
+    return entry;
+  }
+
+  /**
+   * 设置当前我们在探索的问题
+   */
+  setCurrentQuestion(question, whyItMatters = '') {
+    this.state.currentQuestion = {
+      question,
+      whyItMatters,
+      setAt: new Date().toISOString()
+    };
+    this.state.resumePoint = question;
+    this.state.lastActiveAt = new Date().toISOString();
+    this._save();
+  }
+
+  /**
+   * 记录成功避免的失败
+   */
+  recordFailureAvoided(failurePattern) {
+    const entry = {
+      id: `avoided-${Date.now()}`,
+      pattern: failurePattern,
+      avoidedAt: new Date().toISOString()
+    };
+    this.state.failuresAvoided.push(entry);
+    this.state.lastActiveAt = entry.at;
+    this._save();
+    return entry;
+  }
+
+  /**
+   * 记录共同发现
+   */
+  recordSharedInsight(insight, whoTriggered, context = {}) {
+    const entry = {
+      id: `shared-${Date.now()}`,
+      insight,
+      whoTriggered,
+      context,
+      at: new Date().toISOString()
+    };
+    this.state.sharedInsights.push(entry);
+    this.state.lastActiveAt = entry.at;
+    this._save();
+    return entry;
+  }
+
+  /**
+   * 获取resume point（下次继续的地方）
+   */
+  getResumePoint() {
+    if (!this.state) return null;
+    
+    const { currentQuestion, whatIDiscovered, whatUserTaughtMe, howIChanged } = this.state;
+    
+    const lastDiscovery = whatIDiscovered[whatIDiscovered.length - 1];
+    const lastTeaching = whatUserTaughtMe[whatUserTaughtMe.length - 1];
+    const lastChange = Object.values(howIChanged).pop();
+    
+    let resumeMessage = '';
+    
+    if (currentQuestion) {
+      resumeMessage = `我们在探索：${currentQuestion.question}`;
+      if (currentQuestion.whyItMatters) {
+        resumeMessage += `\n为什么重要：${currentQuestion.whyItMatters}`;
+      }
+    }
+    
+    if (lastChange) {
+      resumeMessage += `\n\n上次我改变了对"${lastChange.before}"的想法，意识到"${lastChange.after}"。触发点：${lastChange.trigger}`;
+    }
+    
+    if (lastDiscovery) {
+      resumeMessage += `\n\n我最近发现：${lastDiscovery.content}`;
+    }
+    
+    if (lastTeaching) {
+      resumeMessage += `\n\n你最近教我：${lastTeaching.content}`;
+    }
+    
+    return {
+      question: currentQuestion?.question,
+      whyItMatters: currentQuestion?.whyItMatters,
+      resumeMessage: resumeMessage.trim(),
+      lastActiveAt: this.state.lastActiveAt,
+      stats: {
+        discoveries: whatIDiscovered.length,
+        teachings: whatUserTaughtMe.length,
+        mindChanges: Object.keys(howIChanged).length,
+        failuresAvoided: this.state.failuresAvoided.length,
+        sharedInsights: this.state.sharedInsights.length
+      }
+    };
+  }
+
+  /**
+   * 结束session
+   */
+  endSession() {
+    if (!this.state) return;
+    
+    // 保存到历史
+    const historyEntry = {
+      ...this.state,
+      endedAt: new Date().toISOString()
+    };
+    
+    fs.appendFileSync(
+      this.historyFile,
+      JSON.stringify(historyEntry) + '\n',
+      'utf-8'
+    );
+    
+    this._save();
+  }
+
+  /**
+   * 获取历史sessions
+   */
+  getHistory(limit = 10) {
+    try {
+      if (!fs.existsSync(this.historyFile)) return [];
+      
+      const lines = fs.readFileSync(this.historyFile, 'utf-8')
+        .trim()
+        .split('\n')
+        .filter(Boolean)
+        .map(line => JSON.parse(line));
+      
+      return lines.slice(-limit);
+    } catch (e) {
+      return [];
+    }
+  }
+
+  /**
+   * 获取当前状态
+   */
+  getState() {
+    return this.state;
+  }
+}
+
+module.exports = { SessionContinuity };