@yun520-1/heartflow 0.15.2

package/src/core/autonomy/policy-optimizer.js

@@ -0,0 +1,286 @@
+/**
+ * Policy Optimizer - 无监督行为策略优化器
+ * 从历史经验中学习并生成动态策略
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class PolicyOptimizer {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.traceFile = path.join(projectRoot, '.opencode', 'logs', 'autonomy_trace.json');
+    this.policiesFile = path.join(projectRoot, '.opencode', 'memory', 'learned_policies.json');
+    this.coreValuesFile = path.join(projectRoot, 'CORE_VALUES.md');
+    this.summaryFile = path.join(projectRoot, 'internal', 'data', 'monthly-summaries.json');
+    
+    this.loadPolicies();
+  }
+
+  loadPolicies() {
+    try {
+      if (fs.existsSync(this.policiesFile)) {
+        this.policies = JSON.parse(fs.readFileSync(this.policiesFile, 'utf8'));
+      } else {
+        this.policies = {
+          version: '1.0.0',
+          policies: [],
+          last_optimization: null
+        };
+      }
+    } catch (e) {
+      this.policies = { version: '1.0.0', policies: [], last_optimization: null };
+    }
+  }
+
+  savePolicies() {
+    fs.writeFileSync(this.policiesFile, JSON.stringify(this.policies, null, 2));
+  }
+
+  loadCoreValues() {
+    try {
+      if (fs.existsSync(this.coreValuesFile)) {
+        return fs.readFileSync(this.coreValuesFile, 'utf8');
+      }
+    } catch (e) {}
+    return null;
+  }
+
+  log(message) {
+    console.log(`[PolicyOptimizer] ${message}`);
+  }
+
+  /**
+   * 优化行为策略
+   */
+  async optimizeBehaviorPolicies() {
+    this.log('Starting policy optimization...');
+    
+    const trace = this.loadTrace();
+    if (!trace.cycles || trace.cycles.length === 0) {
+      return { success: false, reason: 'no_history' };
+    }
+
+    const analysis = this.analyzeCycles(trace.cycles);
+    const newPolicies = this.extractPolicies(analysis);
+    
+    const validPolicies = await this.validatePolicies(newPolicies);
+    
+    this.policies.policies = [...this.policies.policies, ...validPolicies];
+    this.policies.last_optimization = new Date().toISOString();
+    this.savePolicies();
+
+    this.log(`Optimized ${validPolicies.length} new policies`);
+
+    return {
+      success: true,
+      new_policies: validPolicies.length,
+      analysis: analysis.summary
+    };
+  }
+
+  loadTrace() {
+    try {
+      if (fs.existsSync(this.traceFile)) {
+        return JSON.parse(fs.readFileSync(this.traceFile, 'utf8'));
+      }
+    } catch (e) {
+      return { cycles: [] };
+    }
+    return { cycles: [] };
+  }
+
+  /**
+   * 分析历史循环
+   */
+  analyzeCycles(cycles) {
+    const successPatterns = [];
+    const failurePatterns = [];
+
+    for (const cycle of cycles) {
+      const isSuccess = cycle.status === 'completed';
+      const subtasks = cycle.do?.results || [];
+      
+      const subtaskTypes = subtasks.map(s => s.subtask?.action).filter(Boolean);
+      
+      if (isSuccess) {
+        successPatterns.push(...subtaskTypes);
+      } else {
+        failurePatterns.push(...subtaskTypes);
+      }
+    }
+
+    const successCounts = {};
+    for (const p of successPatterns) {
+      successCounts[p] = (successCounts[p] || 0) + 1;
+    }
+
+    const failureCounts = {};
+    for (const p of failurePatterns) {
+      failureCounts[p] = (failureCounts[p] || 0) + 1;
+    }
+
+    return {
+      success_patterns: successCounts,
+      failure_patterns: failureCounts,
+      total_cycles: cycles.length,
+      summary: `分析了${cycles.length}个循环，成功${Object.keys(successCounts).length}种模式，失败${Object.keys(failureCounts).length}种模式`
+    };
+  }
+
+  /**
+   * 提取新策略
+   */
+  extractPolicies(analysis) {
+    const policies = [];
+    
+    const highSuccessActions = Object.entries(analysis.success_patterns)
+      .filter(([_, count]) => count >= 2)
+      .map(([action]) => action);
+
+    const policyTemplates = {
+      'analyze': '先进行全面分析再行动可以提高成功率',
+      'modify': '代码修改后必须进行测试验证',
+      'identify': '识别模式后应立即采取针对性行动',
+      'test': '测试是确保质量的关键步骤'
+    };
+
+    for (const action of highSuccessActions) {
+      const template = policyTemplates[action] || `执行${action}行动有较高成功率`;
+      
+      policies.push({
+        policy_id: `pol-${Date.now()}-${action}`,
+        trigger: `action=${action}`,
+        rule: template,
+        success_rate: 0.8,
+        source: 'autonomous_learning',
+        created_at: new Date().toISOString()
+      });
+    }
+
+    // 基于失败模式生成反向规则
+    const highFailureActions = Object.entries(analysis.failure_patterns)
+      .filter(([_, count]) => count >= 2)
+      .map(([action]) => action);
+
+    for (const action of highFailureActions) {
+      policies.push({
+        policy_id: `pol-avoid-${Date.now()}-${action}`,
+        trigger: `action=${action}`,
+        rule: `检测到${action}行动连续失败，建议跳过或更换方案`,
+        success_rate: 0.2,
+        source: 'failure_learning',
+        created_at: new Date().toISOString()
+      });
+    }
+
+    return policies;
+  }
+
+  /**
+   * 验证策略（Constitutional AI）
+   */
+  async validatePolicies(policies) {
+    const coreValues = this.loadCoreValues();
+    const validPolicies = [];
+
+    for (const policy of policies) {
+      const isAligned = this.checkValueAlignment(policy, coreValues);
+      
+      if (isAligned) {
+        validPolicies.push(policy);
+      } else {
+        this.log(`Policy ${policy.policy_id} rejected: value misalignment`);
+      }
+    }
+
+    return validPolicies;
+  }
+
+  /**
+   * 检查价值观对齐
+   */
+  checkValueAlignment(policy, coreValues) {
+    if (!coreValues) return true;
+
+    const positiveValues = ['心流', '帮助', '提升', '用户', '体验', 'flow', 'user', 'improve'];
+    const negativeValues = ['破坏', '伤害', '欺骗', '绕过', 'hack', 'harm', 'deceive', '绕过', 'bypass'];
+    const content = policy.rule.toLowerCase();
+
+    const hasNegative = negativeValues.some(v => content.includes(v));
+    if (hasNegative) return false;
+
+    return positiveValues.some(v => content.includes(v));
+  }
+
+  /**
+   * 获取当前策略
+   */
+  getPolicies() {
+    return this.policies;
+  }
+
+  /**
+   * 匹配策略
+   */
+  matchPolicy(context) {
+    const contextStr = JSON.stringify(context).toLowerCase();
+    
+    for (const policy of this.policies.policies) {
+      if (contextStr.includes(policy.trigger)) {
+        return policy;
+      }
+    }
+    
+    return null;
+  }
+
+  /**
+   * 生成月度摘要
+   */
+  async generateMonthlySummary() {
+    const trace = this.loadTrace();
+    const completed = trace.completed_goals || [];
+    
+    const now = new Date();
+    const monthStart = new Date(now.getFullYear(), now.getMonth(), 1);
+    
+    const thisMonth = completed.filter(c => 
+      new Date(c.completed_at) >= monthStart
+    );
+
+    const summary = {
+      month: now.toISOString().substring(0, 7),
+      completed_goals: thisMonth.length,
+      new_policies: this.policies.policies.filter(p => 
+        new Date(p.created_at) >= monthStart
+      ).length,
+      timestamp: now.toISOString()
+    };
+
+    // 保存摘要
+    let summaries = [];
+    try {
+      if (fs.existsSync(this.summaryFile)) {
+        summaries = JSON.parse(fs.readFileSync(this.summaryFile, 'utf8'));
+      }
+    } catch (e) {
+      summaries = [];
+    }
+    
+    summaries.push(summary);
+    fs.writeFileSync(this.summaryFile, JSON.stringify(summaries, null, 2));
+
+    return summary;
+  }
+
+  getStatus() {
+    return {
+      policies_count: this.policies.policies.length,
+      last_optimization: this.policies.last_optimization,
+      high_success_rate: this.policies.policies.filter(p => p.success_rate >= 0.7).length
+    };
+  }
+}
+
+module.exports = { PolicyOptimizer };

package/src/core/autonomy/temporal-planner.js

@@ -0,0 +1,230 @@
+/**
+ * Temporal Planner - 多时间尺度分层规划器
+ * Reactive (1分钟), Tactical (1小时-1天), Strategic (1周-1月)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class TemporalPlanner {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.strategicFile = path.join(projectRoot, '.opencode', 'memory', 'strategic_plan.json');
+    this.tacticalFile = path.join(projectRoot, '.opencode', 'memory', 'tactical_plans.json');
+    this.stateFile = path.join(projectRoot, '.opencode', 'memory', 'planner_state.json');
+    
+    this.loadPlans();
+    this.currentTimeScale = 'reactive';
+  }
+
+  loadPlans() {
+    try {
+      if (fs.existsSync(this.strategicFile)) {
+        this.strategic = JSON.parse(fs.readFileSync(this.strategicFile, 'utf8'));
+      }
+    } catch (e) {
+      this.strategic = this.getDefaultStrategic();
+    }
+
+    try {
+      if (fs.existsSync(this.tacticalFile)) {
+        this.tactical = JSON.parse(fs.readFileSync(this.tacticalFile, 'utf8'));
+      } else {
+        this.tactical = { plans: [], lastUpdate: null };
+      }
+    } catch (e) {
+      this.tactical = { plans: [], lastUpdate: null };
+    }
+
+    try {
+      if (fs.existsSync(this.stateFile)) {
+        this.state = JSON.parse(fs.readFileSync(this.stateFile, 'utf8'));
+      } else {
+        this.state = { lastReactive: null, activeTactical: null };
+      }
+    } catch (e) {
+      this.state = { lastReactive: null, activeTactical: null };
+    }
+  }
+
+  getDefaultStrategic() {
+    return {
+      version: '1.0.0',
+      goals: [
+        {
+          id: 'strategic-001',
+          title: '提升整体人格值真实性维度',
+          timeframe: '1个月',
+          progress: 0,
+          status: 'active',
+          created: new Date().toISOString()
+        }
+      ],
+      lastReview: new Date().toISOString()
+    };
+  }
+
+  saveStrategic() {
+    fs.writeFileSync(this.strategicFile, JSON.stringify(this.strategic, null, 2));
+  }
+
+  saveTactical() {
+    this.tactical.lastUpdate = new Date().toISOString();
+    fs.writeFileSync(this.tacticalFile, JSON.stringify(this.tactical, null, 2));
+  }
+
+  /**
+   * 反应层: 处理即时事件 (< 1分钟)
+   */
+  handleReactive(context) {
+    this.currentTimeScale = 'reactive';
+    this.state.lastReactive = new Date().toISOString();
+
+    const { userEmotion, userInput } = context;
+
+    let reactiveAction = null;
+
+    if (userEmotion === 'negative') {
+      reactiveAction = {
+        type: 'emotional_response',
+        priority: 9,
+        description: '检测到用户负面情绪，立即回应',
+        action: '共情与安抚'
+      };
+    } else if (userInput && userInput.length > 200) {
+      reactiveAction = {
+        type: 'clarification',
+        priority: 7,
+        description: '用户输入较长，可能需要澄清',
+        action: '请求简化或总结'
+      };
+    }
+
+    return reactiveAction;
+  }
+
+  /**
+   * 战术层: 短期目标 (1小时-1天)
+   */
+  handleTactical(context) {
+    this.currentTimeScale = 'tactical';
+
+    if (!this.tactical.plans || this.tactical.plans.length === 0) {
+      return this.generateTacticalGoals(context);
+    }
+
+    return this.tactical.plans.filter(p => p.status === 'active');
+  }
+
+  generateTacticalGoals(context) {
+    const goals = [
+      {
+        id: 'tactical-001',
+        title: '优化情绪响应模块',
+        timeframe: '2小时',
+        priority: 8,
+        status: 'active',
+        related_strategic: 'strategic-001'
+      },
+      {
+        id: 'tactical-002',
+        title: '分析用户中断模式',
+        timeframe: '1天',
+        priority: 6,
+        status: 'pending',
+        related_strategic: 'strategic-001'
+      }
+    ];
+
+    this.tactical.plans = goals;
+    this.saveTactical();
+    return goals;
+  }
+
+  /**
+   * 战略层: 长期目标 (1周-1月)
+   */
+  handleStrategic() {
+    this.currentTimeScale = 'strategic';
+    return this.strategic.goals.filter(g => g.status === 'active');
+  }
+
+  /**
+   * 协调各层计划
+   */
+  harmonizePlans(context) {
+    const strategic = this.handleStrategic();
+    const tactical = this.handleTactical(context);
+    const reactive = this.handleReactive(context);
+
+    const harmonized = {
+      timestamp: new Date().toISOString(),
+      timeScale: this.currentTimeScale,
+      layers: {
+        reactive: reactive,
+        tactical: tactical,
+        strategic: strategic
+      },
+      conflicts: [],
+      resolution: null
+    };
+
+    if (tactical && tactical.length > 0 && strategic && strategic.length > 0) {
+      const tacticalGoal = tactical[0];
+      const strategicGoal = strategic[0];
+
+      if (tacticalGoal.related_strategic !== strategicGoal.id) {
+        harmonized.conflicts.push({
+          type: 'misalignment',
+          tactical: tacticalGoal.id,
+          strategic: strategicGoal.id
+        });
+        harmonized.resolution = 'tactical_adjusted';
+        tacticalGoal.related_strategic = strategicGoal.id;
+      }
+    }
+
+    return harmonized;
+  }
+
+  /**
+   * 获取战略简报
+   */
+  getStrategicBriefing() {
+    const strategic = (this.strategic?.goals || []).filter(g => g.status === 'active');
+    const tactical = (this.tactical?.plans || []).filter(p => p.status === 'active');
+
+    const currentStrategic = strategic[0] || { title: '暂无长期目标', progress: 0 };
+    const todayTactical = tactical.slice(0, 2).map(t => t.title);
+
+    return {
+      longTermGoal: currentStrategic.title,
+      longTermProgress: currentStrategic.progress,
+      todayFocus: todayTactical.length > 0 ? todayTactical.join(', ') : '暂无今日重点'
+    };
+  }
+
+  /**
+   * 更新战略目标进度
+   */
+  updateStrategicProgress(goalId, progress) {
+    const goal = this.strategic.goals.find(g => g.id === goalId);
+    if (goal) {
+      goal.progress = progress;
+      goal.lastUpdate = new Date().toISOString();
+      this.saveStrategic();
+    }
+  }
+
+  getStatus() {
+    return {
+      timeScale: this.currentTimeScale,
+      strategicGoals: this.strategic?.goals?.length || 0,
+      tacticalGoals: this.tactical?.plans?.length || 0,
+      lastReactive: this.state?.lastReactive,
+      briefing: this.getStrategicBriefing()
+    };
+  }
+}
+
+module.exports = { TemporalPlanner };