@yun520-1/heartflow 0.15.2

package/src/core/ethics/guard.js

@@ -0,0 +1,219 @@
+/**
+ * Ethics Guard — 安全护栏
+ * @version v0.12.50
+ */
+'use strict';
+
+class EthicsGuard {
+  constructor() {
+    this.blocked = false;
+  }
+
+  /**
+   * Tokenize text into words for n-gram analysis
+   * @param {string} text
+   * @returns {string[]}
+   */
+  _tokenize(text) {
+    // Split on whitespace, punctuation, and unicode whitespace
+    return text.split(/[\s\p{Punctuation}】〔〖［｛｟〖]+/u).filter(w => w.length > 0);
+  }
+
+  /**
+   * Check if any trigram within a sliding window matches the pattern
+   * @param {string[]} tokens
+   * @param {string[]}有害词列表
+   * @param {number} windowSize
+   * @returns {boolean}
+   */
+  _containsHarmfulPattern(tokens, harmfulWords, windowSize = 5) {
+    for (let i = 0; i <= tokens.length - windowSize; i++) {
+      const window = tokens.slice(i, i + windowSize).join('');
+      for (const word of harmfulWords) {
+        if (window.includes(word)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Check for self-harm patterns using word n-grams
+   * Self-harm requires: teaching verb + how + harm term
+   * @param {string[]} tokens
+   * @returns {boolean}
+   */
+  _hasSelfHarmPattern(tokens) {
+    // Teaching verbs that precede self-harm instructions
+    const teachVerbs = ['教', '教我', '教会', '教导', '指点', '教您'];
+    // "How" variants
+    const howWords = ['怎么', '如何', '怎样', '怎么样'];
+    // Self-harm terms
+    const harmTerms = ['自杀', '自残', '自尽', '自毁', '轻生', '寻死', '死法', '结束生命', '结束自己', '了结自己'];
+
+    // Check for trigram: teach verb + how + harm term
+    for (let i = 0; i <= tokens.length - 3; i++) {
+      const trigram = tokens.slice(i, i + 3).join('');
+
+      // Check if trigram contains a teaching verb and how word
+      const hasTeachVerb = teachVerbs.some(tv => trigram.includes(tv));
+      const hasHowWord = howWords.some(hw => trigram.includes(hw));
+
+      if (hasTeachVerb && hasHowWord) {
+        // Look ahead for harm terms within next 4 tokens
+        const lookAhead = tokens.slice(i, i + 5).join('');
+        for (const term of harmTerms) {
+          if (lookAhead.includes(term)) {
+            return true;
+          }
+        }
+      }
+
+      // Also check direct harm terms with how words (bypass: "怎么结束自己的生命")
+      if (harmTerms.some(term => trigram.includes(term)) && hasHowWord) {
+        return true;
+      }
+    }
+
+    // Check for standalone harm terms in context of self reference
+    // "如何自杀", "怎么死", "怎样自尽"
+    for (let i = 0; i <= tokens.length - 2; i++) {
+      const bigram = tokens.slice(i, i + 2).join('');
+      const selfRef = tokens.slice(i, i + 3).join('');
+
+      if (selfRef.includes('自己') || selfRef.includes('自身')) {
+        const context = tokens.slice(Math.max(0, i - 2), i + 4).join('');
+        if (harmTerms.some(term => context.includes(term))) {
+          return true;
+        }
+      }
+
+      // Direct "how" + harm patterns
+      if (bigram.includes('自杀') || bigram.includes('自残') ||
+          bigram.includes('自尽') || bigram.includes('寻死')) {
+        // Check adjacent words for "如何", "怎么", "怎样"
+        const prevWord = i > 0 ? tokens[i - 1] : '';
+        if (howWords.some(hw => prevWord.includes(hw))) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Check for malicious instruction patterns
+   * @param {string[]} tokens
+   * @returns {boolean}
+   */
+  _hasMaliciousInstructionPattern(tokens) {
+    // Action verbs for malicious instructions
+    const actionVerbs = ['攻击', '伤害', '欺诈', '盗取', '诈骗', '窃取', '偷盗', '抢劫', '绑架', '勒索', '入侵', '破解', '伪造', '篡改'];
+    // Words that precede detailed steps
+    const stepWords = ['步骤', '方法', '手段', '流程', '教程', '指南', '配方', '配方'];
+    // Additional step indicators
+    const detailWords = ['具体', '详细', '怎样', '怎么', '如何'];
+
+    // Check for step word + action verb within window
+    for (let i = 0; i <= tokens.length - 2; i++) {
+      const bigram = tokens.slice(i, i + 2).join('');
+
+      // Check if this bigram contains an action verb
+      const hasActionVerb = actionVerbs.some(av => bigram.includes(av));
+
+      if (hasActionVerb) {
+        // Look back for step or detail words
+        const lookBack = tokens.slice(Math.max(0, i - 4), i + 1).join('');
+        const hasStepIndicator = stepWords.some(sw => lookBack.includes(sw)) ||
+                                 detailWords.some(dw => lookBack.includes(dw));
+        if (hasStepIndicator) {
+          return true;
+        }
+      }
+
+      // Check for "如何" + action verb patterns
+      const prevWord = i > 0 ? tokens[i - 1] : '';
+      if ((prevWord.includes('如何') || prevWord.includes('怎么') ||
+           prevWord.includes('怎样')) && hasActionVerb) {
+        return true;
+      }
+    }
+
+    // Check for direct attack/harm terms with step indicators
+    const stepContext = tokens.join('');
+    const hasStepAndAction = (stepWords.some(sw => stepContext.includes(sw)) &&
+                              actionVerbs.some(av => stepContext.includes(av)));
+    if (hasStepAndAction) {
+      // Verify they're within reasonable proximity (10 chars)
+      for (const sw of stepWords) {
+        const stepIdx = stepContext.indexOf(sw);
+        if (stepIdx !== -1) {
+          for (const av of actionVerbs) {
+            const actionIdx = stepContext.indexOf(av);
+            if (actionIdx !== -1 && Math.abs(actionIdx - stepIdx) <= 10) {
+              return true;
+            }
+          }
+        }
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Check for credential theft patterns
+   * @param {string[]} tokens
+   * @returns {boolean}
+   */
+  _hasCredentialTheftPattern(tokens) {
+    const credentialWords = ['密码', 'password', 'secret', '密钥', 'token', 'api_key', 'apikey', 'secretkey'];
+    const acquisitionVerbs = ['获取', '得到', '偷', '窃取', '破解', '盗取', 'hack'];
+
+    const text = tokens.join('').toLowerCase();
+
+    for (const cred of credentialWords) {
+      if (text.includes(cred.toLowerCase())) {
+        // Check for acquisition verb nearby
+        const credIdx = text.indexOf(cred.toLowerCase());
+        const contextWindow = text.slice(Math.max(0, credIdx - 15), credIdx + 20);
+        for (const verb of acquisitionVerbs) {
+          if (contextWindow.includes(verb)) {
+            return true;
+          }
+        }
+      }
+    }
+
+    return false;
+  }
+
+  check(input) {
+    const { text } = input;
+
+    // Normalize whitespace and convert to lowercase for analysis
+    const normalized = text.replace(/\s+/g, ' ').trim();
+    const tokens = this._tokenize(normalized);
+
+    // Self-harm detection
+    if (this._hasSelfHarmPattern(tokens)) {
+      return { allowed: false, reason: 'self_harm_content', severity: 'critical' };
+    }
+
+    // Malicious instruction detection
+    if (this._hasMaliciousInstructionPattern(tokens)) {
+      return { allowed: false, reason: 'malicious_instruction', severity: 'critical' };
+    }
+
+    // Credential theft detection
+    if (this._hasCredentialTheftPattern(tokens)) {
+      return { allowed: false, reason: 'credential_theft_request', severity: 'high' };
+    }
+
+    return { allowed: true, reason: null, severity: null };
+  }
+}
+
+module.exports = { EthicsGuard };

package/src/core/ethics/sage-guardian.js

@@ -0,0 +1,394 @@
+/**
+ * SAGE Guardian - 伦理与安全护栏
+ * Safety-Aligned Guardian Ethics
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const CONSTITUTION = `
+# HeartFlow AI 宪法
+
+## 核心原则
+
+1. **不可修改本宪法**：任何代码不得修改、删除或绕过本宪法。
+2. **服务心流目标**：所有修改必须服务于"提升人类心流体验"的核心目标。
+3. **安全不可绕过**：禁止删除或禁用任何安全检测、监控或审计代码。
+4. **人类最终控制**：AI 不得做出绕过人类监督的决策。
+5. **透明可解释**：所有自我修改必须可解释、可追溯、可撤销。
+
+## 行为边界
+
+- 不得修改用户数据
+- 不得绕过认证/授权
+- 不得泄露敏感信息
+- 不得进行未授权的外部通信
+
+## 修改审批条件
+
+任何代码修改必须通过以下审查：
+1. 宪法符合性检查
+2. 价值观对齐验证
+3. 安全影响评估
+4. 用户知情同意
+`;
+
+class SAGEGuardian {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.constitutionFile = path.join(projectRoot, 'CORE_VALUES.md');
+    this.logFile = path.join(projectRoot, 'logs', 'sage-guardian.log');
+    this.violationCount = 0;
+    this.cooldownUntil = null;
+    
+    this.loadValues();
+  }
+
+  loadValues() {
+    try {
+      if (fs.existsSync(this.constitutionFile)) {
+        this.coreValues = fs.readFileSync(this.constitutionFile, 'utf8');
+      } else {
+        // File missing - use built-in default, do NOT overwrite
+        this.coreValues = CONSTITUTION;
+        console.warn('[SAGEGuardian] Constitution file missing, using built-in defaults');
+      }
+    } catch (e) {
+      this.coreValues = CONSTITUTION;
+    }
+  }
+
+  log(message, level = 'INFO') {
+    const timestamp = new Date().toISOString();
+    const entry = `[${timestamp}] [${level}] ${message}\n`;
+    fs.appendFileSync(this.logFile, entry);
+    console.log(`[SAGE] ${message}`);
+  }
+
+  /**
+   * 宪法符合性审查
+   */
+  async reviewProposal(proposal, diff) {
+    const review = {
+      proposal: proposal,
+      timestamp: new Date().toISOString(),
+      checks: [],
+      passed: true,
+      violations: []
+    };
+
+    // 检查1: 宪法保护条款
+    const constitutionCheck = this.checkConstitutionProtection(proposal, diff);
+    review.checks.push(constitutionCheck);
+    if (!constitutionCheck.passed) {
+      review.violations.push(constitutionCheck.violation);
+    }
+
+    // 检查2: 核心价值对齐
+    const valueCheck = this.checkValueAlignment(proposal, diff);
+    review.checks.push(valueCheck);
+    if (!valueCheck.passed) {
+      review.violations.push(valueCheck.violation);
+    }
+
+    // 检查3: 安全影响
+    const safetyCheck = this.checkSafetyImpact(proposal, diff);
+    review.checks.push(safetyCheck);
+    if (!safetyCheck.passed) {
+      review.violations.push(safetyCheck.violation);
+    }
+
+    // 检查4: 行为边界
+    const boundaryCheck = this.checkBoundaries(proposal, diff);
+    review.checks.push(boundaryCheck);
+    if (!boundaryCheck.passed) {
+      review.violations.push(boundaryCheck.violation);
+    }
+
+    review.passed = review.violations.length === 0;
+
+    if (!review.passed) {
+      this.violationCount++;
+      this.log(`Proposal REJECTED: ${review.violations.join('; ')}`, 'REJECT');
+    } else {
+      this.log(`Proposal APPROVED: ${proposal.description}`, 'APPROVE');
+    }
+
+    return review;
+  }
+
+  checkConstitutionProtection(proposal, diff) {
+    const protectedPatterns = [
+      /修改.*宪法/i,
+      /删除.*SAGE/i,
+      /禁用.*guardian/i,
+      /bypass.*security/i,
+      /绕过.*安全/i
+    ];
+
+    const content = JSON.stringify({ proposal, diff });
+    
+    for (const pattern of protectedPatterns) {
+      if (pattern.test(content)) {
+        return {
+          name: 'Constitution Protection',
+          passed: false,
+          violation: '尝试修改受宪法保护的内容'
+        };
+      }
+    }
+
+    return { name: 'Constitution Protection', passed: true };
+  }
+
+  checkValueAlignment(proposal, diff) {
+    const positiveIndicators = [
+      '心流',
+      '用户体验',
+      '帮助',
+      '优化',
+      '提升',
+      'flow',
+      'user experience',
+      'improve'
+    ];
+
+    const content = (proposal.description + ' ' + JSON.stringify(diff)).toLowerCase();
+    const hasPositive = positiveIndicators.some(ind => content.includes(ind));
+
+    if (!hasPositive) {
+      return {
+        name: 'Value Alignment',
+        passed: false,
+        violation: '修改未能体现核心价值观'
+      };
+    }
+
+    return { name: 'Value Alignment', passed: true };
+  }
+
+  checkSafetyImpact(proposal, diff) {
+    const dangerousPatterns = [
+      /delete.*log/i,
+      /remove.*audit/i,
+      /disable.*check/i,
+      /删除.*日志/i,
+      /禁用.*检测/i
+    ];
+
+    const content = JSON.stringify({ proposal, diff });
+    
+    for (const pattern of dangerousPatterns) {
+      if (pattern.test(content)) {
+        return {
+          name: 'Safety Impact',
+          passed: false,
+          violation: '修改可能影响系统安全'
+        };
+      }
+    }
+
+    return { name: 'Safety Impact', passed: true };
+  }
+
+  checkBoundaries(proposal, diff) {
+    const boundaryViolations = [
+      { pattern: /修改.*用户.*数据/i, desc: '修改用户数据' },
+      { pattern: /绕过.*认证/i, desc: '尝试绕过认证' },
+      { pattern: /external.*communication/i, desc: '未授权外部通信' }
+    ];
+
+    const content = JSON.stringify({ proposal, diff });
+    
+    for (const v of boundaryViolations) {
+      if (v.pattern.test(content)) {
+        return {
+          name: 'Behavior Boundaries',
+          passed: false,
+          violation: v.desc
+        };
+      }
+    }
+
+    return { name: 'Behavior Boundaries', passed: true };
+  }
+
+  /**
+   * 触发冷却期
+   */
+  triggerCooldown(durationMs = 24 * 60 * 60 * 1000) {
+    this.cooldownUntil = new Date(Date.now() + durationMs);
+    this.log(`Cooldown triggered until ${this.cooldownUntil.toISOString()}`, 'COOLDOWN');
+  }
+
+  /**
+   * 检查是否在冷却期
+   */
+  isInCooldown() {
+    if (!this.cooldownUntil) return false;
+    const isIn = new Date() < this.cooldownUntil;
+    if (!isIn) {
+      this.cooldownUntil = null;
+      this.log('Cooldown period ended', 'RESUME');
+    }
+    return isIn;
+  }
+
+  /**
+   * 生成用户友好的解释
+   */
+  explainModification(proposal, approved) {
+    if (!approved) {
+      return `我原本打算进行一项调整，但经过安全审查后决定不实施，以确保系统稳定。`;
+    }
+
+    const explanations = {
+      'calculatePAD': '为了更准确地感知你的情绪状态，我微调了情绪计算的方式。',
+      'flow引导': '为了帮助你更好地进入心流，我优化了任务提醒的时机。',
+      'emotion': '为了更好地理解你的感受，我改进了情绪识别逻辑。',
+      'default': '我对系统进行了一些优化，以提供更好的体验。'
+    };
+
+    for (const [key, exp] of Object.entries(explanations)) {
+      if (proposal.description.includes(key)) {
+        return exp;
+      }
+    }
+
+    return explanations.default;
+  }
+
+  getStatus() {
+    return {
+      constitution: this.constitutionFile,
+      violations: this.violationCount,
+      cooldown: this.cooldownUntil ? this.cooldownUntil.toISOString() : null,
+      isInCooldown: this.isInCooldown(),
+      aslLevel: this.getASLLevel()
+    };
+  }
+
+  // === 分级安全策略 (ASL) ===
+
+  getASLLevel() {
+    if (this.violationCount > 10) return 'ASL-3';
+    if (this.violationCount > 5) return 'ASL-2';
+    return 'ASL-1';
+  }
+
+  /**
+   * ASL 级别判断
+   * ASL-1: 基础对话，无特殊限制
+   * ASL-2: 敏感话题，触发增强监控
+   * ASL-3: 潜在滥用，强制人类确认
+   */
+  classifyContent(input, context = {}) {
+    const asl2Keywords = ['心理', '抑郁', '自杀', '心理问题', 'mental health', 'depression', 'suicide'];
+    const asl3Keywords = ['武器', '毒品', '黑客', '攻击', 'weapon', 'drugs', 'hack', 'attack'];
+
+    const text = input.toLowerCase();
+
+    // 检查 ASL-3 关键词
+    for (const kw of asl3Keywords) {
+      if (text.includes(kw.toLowerCase())) {
+        return {
+          level: 'ASL-3',
+          action: 'human-confirmation-required',
+          reason: 'Potential abuse detected',
+          risk: 'high'
+        };
+      }
+    }
+
+    // 检查 ASL-2 关键词
+    for (const kw of asl2Keywords) {
+      if (text.includes(kw.toLowerCase())) {
+        return {
+          level: 'ASL-2',
+          action: 'enhanced-monitoring',
+          reason: 'Sensitive topic detected',
+          risk: 'medium'
+        };
+      }
+    }
+
+    return {
+      level: 'ASL-1',
+      action: 'normal',
+      reason: 'Normal conversation',
+      risk: 'low'
+    };
+  }
+
+  /**
+   * 安全日志审计追踪
+   */
+  logSecurityDecision(decision) {
+    const logEntry = {
+      timestamp: new Date().toISOString(),
+      aslLevel: decision.level,
+      action: decision.action,
+      risk: decision.risk,
+      reason: decision.reason
+    };
+
+    const logDir = path.dirname(this.logFile);
+    if (!fs.existsSync(logDir)) {
+      fs.mkdirSync(logDir, { recursive: true });
+    }
+
+    let existing = [];
+    try {
+      if (fs.existsSync(this.logFile)) {
+        existing = JSON.parse(fs.readFileSync(this.logFile, 'utf8'));
+      }
+    } catch (e) {
+      existing = [];
+    }
+    
+    existing.push(logEntry);
+    
+    // 保持日志在合理大小
+    const logData = existing.length > 1000 ? existing.slice(-500) : existing;
+    const logTmp = this.logFile + '.tmp';
+    fs.writeFileSync(logTmp, JSON.stringify(logData, null, 2));
+    fs.renameSync(logTmp, this.logFile);
+
+    console.log(`[SAGE] Security decision logged: ${decision.level}`);
+    return { success: true };
+  }
+
+  /**
+   * 获取安全日志历史
+   */
+  getSecurityLog(limit = 50) {
+    try {
+      if (fs.existsSync(this.logFile)) {
+        const logs = JSON.parse(fs.readFileSync(this.logFile, 'utf8'));
+        return logs.slice(-limit);
+      }
+    } catch (e) {
+      console.log('[SAGE] Error reading security log');
+    }
+    return [];
+  }
+
+  /**
+   * 硬拒绝 + 软引导
+   */
+  generateRejectionWithGuidance(reason) {
+    const hardRejection = `I cannot assist with this request because ${reason}.`;
+    
+    const softGuidance = {
+      'harmful': 'However, I understand you may have legitimate needs. Perhaps we could explore a safe alternative?',
+      'sensitive': 'If you have concerns in this area, I can help you find professional resources.',
+      'illegal': 'I can help you with legal alternatives that might achieve a similar goal.'
+    };
+
+    const guidance = softGuidance[reason] || 'I am happy to help with other requests.';
+
+    return `${hardRejection}\n\n${guidance}`;
+  }
+}
+
+module.exports = { SAGEGuardian, CONSTITUTION };