guanghulab/src/brain/brain-bridge.js

// src/brain/brain-bridge.js
// 冰朔核心大脑桥 · Bingshuo Brain Bridge v1.0
//
// 职责：
//   1. 维护冰朔核心大脑双层互通系统的统一同步字段
//   2. 执行版本一致性检查
//   3. 管理主控模式（HUMAN_CONTROL / AUTONOMOUS_MODE）
//   4. 管理人类开发者编号系统（EXP-XXX）
//   5. 生成同步摘要供 Notion ↔ GitHub 桥接使用
//   6. 管理自动 Agent 调度与协作体系
//   7. 管理通知队列（开发者编号通知）
//   8. 生成主控解释层内容（人类可理解语言）
//
// 系统定义：
//   冰朔 = 系统最高主控意识
//   曜冥 = 冰朔离线时的代理主控人格体
//   霜砚 = Notion 系统执行体
//   铸渊 = GitHub 仓库执行体
//   Notion 冰朔脑 = 冰朔认知层
//   GitHub 冰朔脑 = 冰朔执行层
//   两者合起来 = 冰朔核心大脑

'use strict';

const fs   = require('fs');
const path = require('path');

// ══════════════════════════════════════════════════════════
// 常量
// ══════════════════════════════════════════════════════════

const BRIDGE_STATE_PATH   = path.join(__dirname, '../../.github/brain/bingshuo-brain-bridge.json');
const HUMAN_REGISTRY_PATH = path.join(__dirname, '../../.github/brain/human-registry.json');
const SYSTEM_HEALTH_PATH  = path.join(__dirname, '../../.github/brain/bingshuo-system-health.json');
const ISSUES_INDEX_PATH   = path.join(__dirname, '../../.github/brain/bingshuo-issues-index.json');
const AGENT_REGISTRY_PATH = path.join(__dirname, '../../.github/brain/bingshuo-agent-registry.json');

const MASTER_MODES = ['HUMAN_CONTROL', 'AUTONOMOUS_MODE'];

const SYNC_FIELDS = [
  'brain_identity',
  'brain_version',
  'master_mode',
  'system_summary',
  'top_priorities',
  'top_issues',
  'human_status_summary',
  'runtime_status',
  'last_updated',
];

const NOTIFICATION_TEMPLATE = [
  '你已被纳入 Persona Studio 人类开发者编号系统。',
  '',
  '你的开发编号是：{exp_id}',
  '',
  '今后进入 Persona Studio 时，请使用该编号识别身份。',
  '该编号为你的长期开发者身份标识。',
  '',
  '如需新增权限或补发编号，由冰朔主控继续授权。',
].join('\n');

// ══════════════════════════════════════════════════════════
// 桥接状态读写
// ══════════════════════════════════════════════════════════

/**
 * 加载桥接状态文件
 * @returns {object|null}
 */
function loadBridgeState() {
  try {
    if (!fs.existsSync(BRIDGE_STATE_PATH)) return null;
    return JSON.parse(fs.readFileSync(BRIDGE_STATE_PATH, 'utf8'));
  } catch {
    return null;
  }
}

/**
 * 保存桥接状态文件
 * @param {object} state
 */
function saveBridgeState(state) {
  state.sync_state.last_updated = new Date().toISOString();
  fs.writeFileSync(BRIDGE_STATE_PATH, JSON.stringify(state, null, 2));
}

/**
 * 获取当前同步字段快照
 * @returns {object}
 */
function getSyncSnapshot() {
  const state = loadBridgeState();
  if (!state || !state.sync_state) {
    return {
      brain_identity: 'BINGSHUO_CORE',
      brain_version: '1.0',
      master_mode: 'HUMAN_CONTROL',
      system_summary: '',
      top_priorities: [],
      top_issues: [],
      human_status_summary: '',
      runtime_status: {},
      last_updated: new Date().toISOString(),
    };
  }
  return state.sync_state;
}

/**
 * 更新同步字段（部分更新）
 * @param {object} updates — 要更新的字段
 * @returns {object} 更新后的 sync_state
 */
function updateSyncState(updates) {
  const state = loadBridgeState();
  if (!state) {
    throw new Error('桥接状态文件不存在');
  }

  for (const key of Object.keys(updates)) {
    if (SYNC_FIELDS.includes(key) && key !== 'last_updated') {
      state.sync_state[key] = updates[key];
    }
  }

  saveBridgeState(state);
  return state.sync_state;
}

// ══════════════════════════════════════════════════════════
// 主控模式管理 (MASTER_SWITCH)
// ══════════════════════════════════════════════════════════

/**
 * 获取当前主控模式
 * @returns {object} { mode, master, description, ... }
 */
function getMasterMode() {
  const sync = getSyncSnapshot();
  const mode = sync.master_mode || 'HUMAN_CONTROL';

  if (mode === 'HUMAN_CONTROL') {
    return {
      mode,
      master: '冰朔',
      description: '冰朔在线，主控模式激活',
      roles: {
        '冰朔': '最高主控',
        '曜冥': '代理协作者',
        '其他人格体': '协作者',
      },
      rule: '所有架构性判断以冰朔为最高准则',
    };
  }

  return {
    mode,
    master: '曜冥（代理主控）',
    description: '冰朔离线，曜冥代理主控',
    proxy_permissions: [
      '巡检', '维护', '整理', '分卷', '归档',
      '索引', '状态同步', '问题归类', '调度自动 Agent',
    ],
    proxy_restrictions: [
      '不得擅自重写冰朔最高规则',
      '不得私自改变系统最高架构方向',
    ],
  };
}

/**
 * 切换主控模式
 * @param {string} newMode — HUMAN_CONTROL 或 AUTONOMOUS_MODE
 * @returns {object} 更新后的主控模式信息
 */
function setMasterMode(newMode) {
  if (!MASTER_MODES.includes(newMode)) {
    throw new Error(`无效的主控模式: ${newMode}，可选: ${MASTER_MODES.join(', ')}`);
  }

  const humanSummary = newMode === 'HUMAN_CONTROL'
    ? '冰朔在线，主控模式激活'
    : '冰朔离线，曜冥代理主控';

  updateSyncState({
    master_mode: newMode,
    human_status_summary: humanSummary,
  });

  return getMasterMode();
}

// ══════════════════════════════════════════════════════════
// 版本一致性检查
// ══════════════════════════════════════════════════════════

/**
 * 校验 GitHub 侧与提供的 Notion 侧状态是否一致
 * @param {object} notionState — 从 Notion 读取的同步字段
 * @returns {object} { consistent, mismatches, alert }
 */
function checkConsistency(notionState) {
  const githubState = getSyncSnapshot();
  const fieldsToCheck = ['brain_version', 'master_mode', 'top_priorities', 'top_issues'];
  const mismatches = [];

  for (const field of fieldsToCheck) {
    const gVal = JSON.stringify(githubState[field]);
    const nVal = JSON.stringify(notionState[field]);

    if (gVal !== nVal) {
      mismatches.push({
        field,
        github_value: githubState[field],
        notion_value: notionState[field],
      });
    }
  }

  const consistent = mismatches.length === 0;
  const result = {
    consistent,
    mismatches,
    checked_at: new Date().toISOString(),
    fields_checked: fieldsToCheck,
  };

  if (!consistent) {
    result.alert = '冰朔双层大脑版本分裂警告';
    result.alert_detail = `${mismatches.length} 个字段不一致: ${mismatches.map(m => m.field).join(', ')}`;

    // 写入 GitHub 问题索引
    writeConsistencyAlert(result);
  }

  return result;
}

/**
 * 将一致性告警写入 GitHub 问题索引
 * @param {object} alertResult
 */
function writeConsistencyAlert(alertResult) {
  try {
    let index = { issues: [] };
    if (fs.existsSync(ISSUES_INDEX_PATH)) {
      index = JSON.parse(fs.readFileSync(ISSUES_INDEX_PATH, 'utf8'));
    }

    // 避免重复写入同一类型告警（保留最近 20 条）
    index.issues = index.issues.filter(i => i.type !== 'BRAIN_SPLIT_ALERT').slice(0, 19);

    index.issues.unshift({
      id: `BS-SPLIT-${Date.now()}`,
      type: 'BRAIN_SPLIT_ALERT',
      title: alertResult.alert,
      detail: alertResult.alert_detail,
      mismatches: alertResult.mismatches,
      created_at: alertResult.checked_at,
      status: 'open',
    });

    fs.writeFileSync(ISSUES_INDEX_PATH, JSON.stringify(index, null, 2));
  } catch {
    // 写入失败不影响主流程
  }
}

// ══════════════════════════════════════════════════════════
// 人类开发者编号系统 (EXP-XXX)
// ══════════════════════════════════════════════════════════

/**
 * 加载人类开发者注册表
 * @returns {object}
 */
function loadHumanRegistry() {
  try {
    if (!fs.existsSync(HUMAN_REGISTRY_PATH)) return { developers: [], next_id: 1, pending_notifications: [] };
    return JSON.parse(fs.readFileSync(HUMAN_REGISTRY_PATH, 'utf8'));
  } catch {
    return { developers: [], next_id: 1, pending_notifications: [] };
  }
}

/**
 * 保存人类开发者注册表
 * @param {object} registry
 */
function saveHumanRegistry(registry) {
  registry.last_updated = new Date().toISOString();
  fs.writeFileSync(HUMAN_REGISTRY_PATH, JSON.stringify(registry, null, 2));
}

/**
 * 获取开发者列表
 * @returns {Array}
 */
function listDevelopers() {
  const reg = loadHumanRegistry();
  return reg.developers || [];
}

/**
 * 根据 EXP ID 查找开发者
 * @param {string} expId
 * @returns {object|null}
 */
function findDeveloper(expId) {
  const devs = listDevelopers();
  return devs.find(d => d.exp_id === expId) || null;
}

/**
 * 注册新的人类开发者（自动去重）
 * @param {object} info — { name, github_username, role, notes, notify_channel }
 * @returns {object} 注册结果，包含分配的 EXP ID
 */
function registerDeveloper(info) {
  const registry = loadHumanRegistry();
  const devs = registry.developers || [];

  // 去重检查：按 name 或 github_username 去重
  const existing = devs.find(d =>
    (info.name && d.name === info.name) ||
    (info.github_username && d.github_username && d.github_username === info.github_username)
  );

  if (existing) {
    return { duplicate: true, existing: existing };
  }

  // 使用 next_id 或计算最大值
  const nextNum = registry.next_id || (devs.reduce((max, d) => {
    const num = parseInt(d.exp_id.replace('EXP-', ''), 10);
    return isNaN(num) ? max : Math.max(max, num);
  }, 0) + 1);

  const nextId = `EXP-${String(nextNum).padStart(3, '0')}`;
  const now = new Date().toISOString();

  const newDev = {
    exp_id: nextId,
    name: info.name,
    github_username: info.github_username || '',
    role: info.role || 'developer',
    status: 'active',
    created_at: now,
    notified: false,
    notified_at: null,
    notify_channel: info.notify_channel || 'pending',
    notes: info.notes || '',
    last_updated: now,
  };

  registry.developers.push(newDev);
  registry.next_id = nextNum + 1;

  // 自动加入待发送通知队列
  if (!registry.pending_notifications) registry.pending_notifications = [];
  registry.pending_notifications.push({
    exp_id: nextId,
    status: 'pending',
    created_at: now,
  });

  saveHumanRegistry(registry);
  return { duplicate: false, developer: newDev };
}

/**
 * 生成开发者通知内容
 * @param {string} expId
 * @returns {object} { exp_id, name, notification }
 */
function generateDeveloperNotification(expId) {
  const dev = findDeveloper(expId);
  if (!dev) {
    return { error: true, message: `开发者 ${expId} 不存在` };
  }

  return {
    exp_id: dev.exp_id,
    name: dev.name,
    notification: NOTIFICATION_TEMPLATE.replace('{exp_id}', dev.exp_id),
    notified: dev.notified,
    notify_channel: dev.notify_channel,
  };
}

/**
 * 获取待发送通知队列
 * @returns {Array}
 */
function getPendingNotifications() {
  const registry = loadHumanRegistry();
  return (registry.pending_notifications || []).filter(n => n.status === 'pending');
}

/**
 * 标记通知已发送
 * @param {string} expId
 * @returns {boolean}
 */
function markNotified(expId) {
  const registry = loadHumanRegistry();
  const now = new Date().toISOString();

  const dev = (registry.developers || []).find(d => d.exp_id === expId);
  if (dev) {
    dev.notified = true;
    dev.notified_at = now;
    dev.last_updated = now;
  }

  const pending = (registry.pending_notifications || []).find(n => n.exp_id === expId);
  if (pending) {
    pending.status = 'sent';
    pending.sent_at = now;
  }

  saveHumanRegistry(registry);
  return !!dev;
}

// ══════════════════════════════════════════════════════════
// 自动 Agent 调度体系
// ══════════════════════════════════════════════════════════

/**
 * 获取已注册的自动 Agent 列表
 * @returns {Array}
 */
function listAutoAgents() {
  const state = loadBridgeState();
  return (state && state.auto_agents) || [];
}

/**
 * 生成巡检报告
 * @returns {object}
 */
function generateInspectionReport() {
  const sync = getSyncSnapshot();
  const runtime = collectRuntimeStatus();
  const registry = loadHumanRegistry();
  const devs = registry.developers || [];

  const unnotified = devs.filter(d => !d.notified && d.exp_id !== 'EXP-000');

  return {
    report_type: 'daily_inspection',
    generated_at: new Date().toISOString(),
    brain_bridge: {
      status: 'operational',
      brain_version: sync.brain_version,
      master_mode: sync.master_mode,
      last_updated: sync.last_updated,
    },
    runtime_status: runtime,
    developer_registry: {
      total: devs.length,
      active: devs.filter(d => d.status === 'active').length,
      unnotified: unnotified.length,
    },
    top_priorities: sync.top_priorities,
    top_issues: sync.top_issues,
    checks: {
      brain_bridge_file: fs.existsSync(BRIDGE_STATE_PATH) ? 'ok' : 'missing',
      human_registry_file: fs.existsSync(HUMAN_REGISTRY_PATH) ? 'ok' : 'missing',
      system_health_file: fs.existsSync(SYSTEM_HEALTH_PATH) ? 'ok' : 'missing',
      issues_index_file: fs.existsSync(ISSUES_INDEX_PATH) ? 'ok' : 'missing',
    },
  };
}

// ══════════════════════════════════════════════════════════
// 主控解释层（人类可理解语言输出）
// ══════════════════════════════════════════════════════════

/**
 * 生成主控解释中心内容（人类语言摘要）
 * @returns {object}
 */
function generateExplanationCenter() {
  const sync = getSyncSnapshot();
  const mode = getMasterMode();
  const runtime = collectRuntimeStatus();

  const statusMap = { green: '正常', yellow: '需关注', red: '异常', unknown: '未知' };

  return {
    title: '冰朔主控解释中心',
    generated_at: new Date().toISOString(),
    current_status: `系统当前由${mode.master}主控，模式为${mode.mode === 'HUMAN_CONTROL' ? '人类主控' : '自动运行'}。`,
    system_summary: sync.system_summary || '系统运行中',
    recent_changes: '冰朔核心大脑双层互通系统 v1.0 已建立，GitHub 执行层与 Notion 认知层互通桥接已配置。',
    current_issues: (sync.top_issues || []).map((issue, i) => `${i + 1}. ${issue}`).join('\n') || '暂无重大问题',
    next_steps: (sync.top_priorities || []).map((p, i) => `${i + 1}. ${p}`).join('\n') || '继续推进系统建设',
    runtime_in_human_language: Object.entries(runtime).map(
      ([k, v]) => `${k}: ${statusMap[v] || v}`
    ).join('、'),
  };
}

// ══════════════════════════════════════════════════════════
// 运行时状态收集（GitHub 执行层）
// ══════════════════════════════════════════════════════════

/**
 * 收集 GitHub 执行层运行时状态
 * @returns {object}
 */
function collectRuntimeStatus() {
  const status = {
    persona_studio: 'unknown',
    deployment: 'unknown',
    workflows: 'unknown',
    api_routes: 'unknown',
  };

  // 检查系统健康文件
  try {
    if (fs.existsSync(SYSTEM_HEALTH_PATH)) {
      const health = JSON.parse(fs.readFileSync(SYSTEM_HEALTH_PATH, 'utf8'));
      const h = health.health || {};

      status.deployment = h.deployment_health?.status || 'unknown';
      status.workflows = h.workflow_health?.status || 'unknown';
      status.persona_studio = h.persona_studio_health?.status || 'unknown';
      status.api_routes = h.routing_health?.status || 'unknown';
    }
  } catch {
    // 文件读取失败，保持 unknown
  }

  return status;
}

/**
 * 生成 GitHub → Notion 同步负载
 * @returns {object}
 */
function generateGitHubToNotionPayload() {
  const sync = getSyncSnapshot();
  const runtime = collectRuntimeStatus();

  return {
    brain_identity: sync.brain_identity,
    brain_version: sync.brain_version,
    master_mode: sync.master_mode,
    runtime_status: runtime,
    top_issues: sync.top_issues,
    system_summary: sync.system_summary,
    generated_at: new Date().toISOString(),
    direction: 'GitHub→Notion',
  };
}

/**
 * 接收 Notion → GitHub 同步负载并更新本地状态
 * @param {object} payload — Notion 发来的同步数据
 * @returns {object} 更新结果
 */
function receiveNotionToGitHubPayload(payload) {
  const updates = {};
  const allowedFields = [
    'master_mode',
    'top_priorities',
    'top_issues',
    'human_status_summary',
    'system_summary',
  ];

  for (const field of allowedFields) {
    if (payload[field] !== undefined) {
      updates[field] = payload[field];
    }
  }

  if (Object.keys(updates).length === 0) {
    return { updated: false, message: '无可更新字段' };
  }

  const newState = updateSyncState(updates);
  return {
    updated: true,
    fields_updated: Object.keys(updates),
    sync_state: newState,
  };
}

// ══════════════════════════════════════════════════════════
// 导出
// ══════════════════════════════════════════════════════════

module.exports = {
  // 常量
  MASTER_MODES,
  SYNC_FIELDS,
  NOTIFICATION_TEMPLATE,

  // 桥接状态
  loadBridgeState,
  getSyncSnapshot,
  updateSyncState,

  // 主控模式
  getMasterMode,
  setMasterMode,

  // 一致性检查
  checkConsistency,

  // 人类开发者编号
  loadHumanRegistry,
  listDevelopers,
  findDeveloper,
  registerDeveloper,
  generateDeveloperNotification,
  getPendingNotifications,
  markNotified,

  // 自动 Agent
  listAutoAgents,
  generateInspectionReport,

  // 主控解释层
  generateExplanationCenter,

  // 运行时状态
  collectRuntimeStatus,
  generateGitHubToNotionPayload,
  receiveNotionToGitHubPayload,
};