@iamsamyiok/agents-chat 3.18.0

package/app/lib/memory.js

@@ -0,0 +1,202 @@
+// 管家长期记忆：跨会话记住用户偏好、项目事实与教训（借鉴 Hermes MEMORY.md/USER.md 双仓设计）
+// 鲁棒性原则（任何一步失败都不阻塞、不报硬错）：
+// - 写入阶梯：直接写入 → 超限时辅助小模型整理合并 → 辅助失败/输出无效时淘汰最旧条目
+// - 一切异常吞掉并返回结果说明，调用方据此展示 💾 提示或静默降级
+// - 未配置辅助模型时全部走确定性路径，功能照常
+const store = require('./store');
+const { auxReady, auxChat, parseAuxJSON } = require('./aux-llm');
+
+const LIMITS = { memory: 2000, user: 1200 }; // 字符上限（约 700/450 tokens，常驻规划上下文）
+
+function memoryEnabled() {
+  return process.env.AGENTS_CHAT_MEMORY !== '0';
+}
+
+const entryChars = (entries) => entries.reduce((n, e) => n + String(e).length, 0);
+const usage = (target) => {
+  const d = store.getMemoryData();
+  const used = entryChars(d[target]);
+  return { used, limit: LIMITS[target], pct: Math.round(used / LIMITS[target] * 100) };
+};
+
+// 注入管家的记忆块（冻结快照，带用量便于模型自觉控制）
+function memoryBlock(targets) {
+  const d = store.getMemoryData();
+  const parts = [];
+  for (const t of (targets || ['memory', 'user'])) {
+    const entries = d[t];
+    if (!entries.length) continue;
+    const label = t === 'user' ? '用户画像' : '工作笔记';
+    const u = usage(t);
+    parts.push(`〔${label} ${u.pct}% ${u.used}/${u.limit}字〕\n${entries.join('\n§\n')}`);
+  }
+  return parts.join('\n\n');
+}
+
+// ---------- 确定性整理（无辅助模型时的兜底） ----------
+// 淘汰最旧条目直到放得下；至少保留 1 条（单条超长则截断该条）
+function makeRoom(entries, incoming, limit) {
+  const list = entries.slice();
+  while (list.length > 0 && entryChars(list) + incoming.length > limit) list.shift();
+  if (!list.length && incoming.length > limit) return [incoming.slice(0, limit)];
+  return list;
+}
+
+const isDup = (entries, text) => entries.some(e => e.trim() === text.trim());
+
+// ---------- 辅助小模型整理：把现有条目 + 新条目合并成更紧凑的清单 ----------
+async function llmConsolidate(target, entries, incoming) {
+  const limit = LIMITS[target];
+  const label = target === 'user' ? '用户画像' : '工作笔记';
+  const res = await auxChat([
+    { role: 'system', content: `你是记忆整理器。把「现有条目」与「新条目」合并成一份更紧凑的清单：合并重复信息、删去过时内容、保留全部关键事实。总字数必须不超过 ${limit} 字。直接输出 JSON：{"entries":["条目1","条目2"]}，每条是一句信息密集的完整陈述，不要输出其他内容。` },
+    { role: 'user', content: `〔${label}·现有条目〕\n${entries.join('\n§\n') || '（空）'}\n\n〔新条目〕\n${incoming}` }
+  ], { maxTokens: 700, timeoutMs: 30000 });
+  if (!res.ok) return null;
+  const j = parseAuxJSON(res.text);
+  if (!j || !Array.isArray(j.entries)) return null;
+  const merged = j.entries.map(s => String(s).trim()).filter(Boolean).slice(0, 20);
+  if (!merged.length || entryChars(merged) > limit) return null; // 输出仍超限视为无效
+  return merged;
+}
+
+// ---------- 写入操作（鲁棒阶梯，永不抛异常） ----------
+// op: {action:'add'|'replace'|'remove', target:'memory'|'user', content, old}
+async function applyOps(ops) {
+  const results = [];
+  for (const op of (Array.isArray(ops) ? ops : []).slice(0, 10)) {
+    const target = op.target === 'user' ? 'user' : 'memory';
+    const action = op.action;
+    const content = String(op.content || '').trim().slice(0, Math.max(200, LIMITS[target]));
+    const old = String(op.old || '').trim();
+    if (action !== 'add' && !old) { results.push({ ok: false, why: '缺少 old' }); continue; }
+
+    const d = store.getMemoryData();
+    const entries = d[target].slice();
+    let note = '';
+
+    if (action === 'remove') {
+      const i = entries.findIndex(e => e.includes(old));
+      if (i < 0) { results.push({ ok: false, why: '未匹配' }); continue; }
+      entries.splice(i, 1);
+      note = '删除 1 条';
+    } else if (action === 'replace') {
+      if (!content) { results.push({ ok: false, why: '缺少 content' }); continue; }
+      const i = entries.findIndex(e => e.includes(old));
+      if (i < 0) { results.push({ ok: false, why: '未匹配' }); continue; }
+      entries[i] = content;
+      note = '更新 1 条';
+    } else { // add
+      if (!content) { results.push({ ok: false, why: '空内容' }); continue; }
+      if (isDup(entries, content)) { results.push({ ok: true, note: '重复已跳过', dup: true }); continue; }
+      if (entryChars(entries) + content.length <= LIMITS[target]) {
+        entries.push(content);
+        note = '新增 1 条';
+      } else {
+        // 超限 → 辅助模型整理；失败 → 淘汰最旧
+        const merged = auxReady() ? await llmConsolidate(target, entries, content) : null;
+        if (merged) {
+          entries.length = 0;
+          entries.push(...merged);
+          note = `整理合并后写入（${merged.length} 条）`;
+        } else {
+          entries.length = 0;
+          entries.push(...makeRoom(entries, content, LIMITS[target]));
+          if (!entries.includes(content)) entries.push(content);
+          note = '空间不足，淘汰最旧后写入';
+        }
+      }
+    }
+    d[target] = entries;
+    store.saveMemoryData(d);
+    results.push({ ok: true, note });
+  }
+  return results;
+}
+
+// ---------- 历史回忆：跨会话/跨任务关键词检索（确定性、毫秒级、零 token） ----------
+// 返回拼接片段（含来源标注），供规划时注入「以前聊过什么」
+function recallFromMessages(allMessages, query, opts) {
+  const o = opts || {};
+  const terms = String(query || '')
+    .replace(/[，。！？、,.!?；;：:\s@]+/g, ' ')
+    .split(' ')
+    .filter(t => t.length >= 2 && t.length <= 12)
+    .slice(0, 8);
+  if (!terms.length) return '';
+  const curTask = o.excludeTaskId || '';
+  const curEpoch = o.excludeEpoch;
+  const scored = [];
+  for (const m of allMessages) {
+    if (!m || !m.content) continue;
+    if (curTask && (m.taskId || '') === curTask) continue; // 同一任务的历史不重复回忆（已在工作背景里）
+    if (!curTask && curEpoch !== undefined && !m.taskId && (Number(m.epoch) || 0) === curEpoch) continue; // 主会话排除当前轮次（已在会话背景里）
+    const text = String(m.content);
+    if (text.length < 10) continue;
+    let score = 0;
+    for (const t of terms) {
+      let idx = text.indexOf(t);
+      while (idx >= 0 && score < 50) { score++; idx = text.indexOf(t, idx + t.length); }
+    }
+    if (score >= 2) scored.push({ m, score, text });
+  }
+  scored.sort((a, b) => b.score - a.score);
+  const parts = [];
+  let total = 0;
+  for (const s of scored.slice(0, 4)) {
+    const src = s.m.taskId ? '历史任务' : '早前会话';
+    const who = s.m.role === 'user' ? '用户' : (s.m.agentName || '智能体');
+    const line = `[${src}] ${who}：${s.text.replace(/\s+/g, ' ').slice(0, 260)}`;
+    if (total + line.length > 900) break;
+    parts.push(line);
+    total += line.length;
+  }
+  return parts.join('\n');
+}
+
+// ---------- 上下文压缩：辅助模型把长历史压成要点（失败→确定性保留结尾） ----------
+async function compressHistory(history, opts) {
+  const o = opts || {};
+  const limit = o.limit || 1200;
+  const text = String(history || '').trim();
+  if (!text || text.length <= (o.minLen || 4000)) return { text, compressed: false };
+  const head = text.slice(0, 200);
+  const res = await auxChat([
+    { role: 'system', content: `把这段会话历史压缩成不超过 ${limit} 字的要点：保留用户偏好、已做决定、关键事实与结论，去掉寒暄与过程细节。直接输出要点文本。` },
+    { role: 'user', content: `${head}\n…（中略）…\n${text.slice(-2500)}` }
+  ], { maxTokens: Math.min(900, limit), timeoutMs: 30000 });
+  if (res.ok && res.text.length >= 50) {
+    return { text: `〔会话历史要点（原文 ${text.length} 字已压缩）〕\n${res.text}`, compressed: true };
+  }
+  // 确定性回退：直接保留结尾（最近的内容通常最重要）
+  return { text: text.slice(-limit), compressed: false };
+}
+
+// ---------- 编排后自省：从本轮对话提取值得长期记住的内容 ----------
+async function reflectOnRun(digest) {
+  if (!auxReady()) return null;
+  const mem = memoryBlock(['memory', 'user']);
+  const res = await auxChat([
+    { role: 'system', content: `你是管家的记忆助手。根据本轮对话提取「值得跨会话长期记住」的信息，只记稳定的偏好与事实，忽略一次性细节。
+当前记忆：
+${mem || '（空）'}
+
+输出 JSON（无值得记的输出 {"ops":[]}）：
+{"ops":[{"action":"add","target":"user 或 memory","content":"一句完整陈述"}],"note":"不超过 15 字的说明"}
+target 规则：用户偏好/沟通习惯/身份 → user；项目事实/环境/教训/约定 → memory。
+优先 add；若新内容与现有条目重复或更新现有条目，用 {"action":"replace","target":"…","old":"现有条目的唯一片段","content":"更新后的完整条目"}。` },
+    { role: 'user', content: digest }
+  ], { maxTokens: 500, timeoutMs: 30000 });
+  if (!res.ok) return null;
+  const j = parseAuxJSON(res.text);
+  if (!j || !Array.isArray(j.ops) || !j.ops.length) return null;
+  const results = await applyOps(j.ops);
+  const applied = results.filter(r => r.ok && !r.dup);
+  if (!applied.length) return null;
+  return { note: String(j.note || '').slice(0, 30), applied: applied.length, results };
+}
+
+module.exports = {
+  LIMITS, memoryEnabled, memoryBlock, usage, applyOps,
+  recallFromMessages, compressHistory, reflectOnRun, makeRoom, isDup
+};

package/app/lib/oc.js

@@ -0,0 +1,244 @@
+// 单聊工作台引擎：网页会话 ←→ opencode 会话（-s 续聊）
+// - chatSolo：spawn `opencode run --format json [-m model] [-s ses_xxx]`，prompt 经 stdin
+// - 事件流：text/reasoning 为全量快照（按 partId 覆盖渲染），tool_use 为过程提示
+// - 首个 sessionID 事件回填 store，实现同一网页会话跨轮次续聊
+// - 非 opencode 内核（claude/codex/pi）无 -s 续聊能力：单聊退化为一次性对话，每轮全新上下文
+// - 演示模式（AGENTS_CHAT_MOCK=1）走 mock 子进程，输出模拟为快照事件
+const path = require('path');
+const { spawn, execFileSync } = require('child_process');
+const { registerChild, describeTool, resolveCwd } = require('./agent');
+
+const MOCK_SCRIPT = path.join(__dirname, '..', 'mock', 'mock-agent.js');
+
+// 模型标识必须形如 provider/model，且只含安全字符（会进入命令行参数）
+const MODEL_RE = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+// opencode 会话 ID（ses_ 开头的安全字符序列）
+const OC_SESSION_RE = /^[A-Za-z0-9_-]{1,128}$/;
+
+// ---------- 模型列表：`opencode models` 输出尽力解析（60s 缓存） ----------
+let modelCache = { ts: 0, list: null };
+
+function listOcModels(runner, force) {
+  if (!runner || runner.kind !== 'opencode' || !runner.cmd) return [];
+  if (!force && modelCache.list && Date.now() - modelCache.ts < 60000) return modelCache.list;
+  let out = '';
+  try {
+    // 同步执行（带超时）；输出为人类可读列表，统一按 provider/model 形态抓取
+    out = execFileSync(runner.cmd, ['models'], {
+      encoding: 'utf8', timeout: 20000, shell: runner.shell,
+      windowsHide: true, cwd: resolveCwd(), maxBuffer: 4 * 1024 * 1024
+    });
+  } catch (e) {
+    // 失败时仍可能带部分 stdout，尽力解析
+    out = (e && e.stdout) ? String(e.stdout) : '';
+  }
+  const ids = new Set();
+  for (const m of String(out).match(/[A-Za-z0-9][A-Za-z0-9_.-]*\/[A-Za-z0-9][A-Za-z0-9_.-]*/g) || []) {
+    if (MODEL_RE.test(m)) ids.add(m);
+  }
+  const list = [...ids].sort().map(id => ({ id, label: id.split('/').pop() }));
+  modelCache = { ts: Date.now(), list };
+  return list;
+}
+
+// 演示模式的假模型列表（仅 UI 可交互，无真实调用）
+function demoModels() {
+  return [
+    { id: 'demo/qwen-plus', label: 'qwen-plus（演示）' },
+    { id: 'demo/glm', label: 'glm（演示）' }
+  ];
+}
+
+// ---------- opencode 事件行 → 统一单聊事件 ----------
+// onEvent 事件：
+//   {type:'session', ocSessionId}        首个 sessionID（回填续聊）
+//   {type:'text', partId, text}          正文快照（覆盖式）
+//   {type:'reasoning', partId, text}     思考快照（覆盖式）
+//   {type:'tool', partId, name, summary} 工具调用提示
+// state.errEvents 收集错误，close 时合并上报
+function parseSoloEventLine(line, onEvent, state) {
+  let ev;
+  try { ev = JSON.parse(line); } catch { return; }
+  if (!ev || !ev.type) return;
+  if (ev.sessionID && !state.ocSessionId && OC_SESSION_RE.test(String(ev.sessionID))) {
+    state.ocSessionId = String(ev.sessionID);
+    onEvent({ type: 'session', ocSessionId: state.ocSessionId });
+  }
+  const part = ev.part;
+  if (ev.type === 'text' && part && typeof part.text === 'string') {
+    if (part.text.trim()) {
+      onEvent({ type: 'text', partId: String(part.id || part.messageID || 'txt'), text: part.text });
+    }
+    return;
+  }
+  if (ev.type === 'reasoning' && part && typeof part.text === 'string') {
+    if (part.text.trim()) {
+      onEvent({ type: 'reasoning', partId: String(part.id || 'rs'), text: part.text });
+    }
+    return;
+  }
+  if (ev.type === 'tool_use' && part) {
+    const name = String(part.tool || 'tool');
+    let summary = '';
+    try { summary = describeTool(part).replace(/\n$/, ''); } catch { /* ignore */ }
+    state.toolSeq = (state.toolSeq || 0) + 1;
+    onEvent({ type: 'tool', partId: `tool-${state.toolSeq}`, name, summary });
+    return;
+  }
+  if (ev.type === 'error') {
+    const e = ev.error;
+    let msg;
+    if (e && e.data && e.data.message) msg = String(e.data.message);
+    else if (e && e.name) msg = String(e.name);
+    else msg = JSON.stringify(e).slice(0, 500);
+    if (msg) state.errEvents.push(msg);
+  }
+  // step_start / step_finish / message.updated 等对聊天界面是噪音，忽略
+}
+
+// ---------- 通用子进程运行器 ----------
+// runnerSpec: { cmd, shell, json, cwd }；json=false 时把输出行累积为快照（演示模式用）
+function spawnSoloRunner(runnerSpec, args, prompt, env, onEvent, finish) {
+  let child;
+  try {
+    child = spawn(runnerSpec.cmd, args, {
+      cwd: runnerSpec.cwd || process.cwd(),
+      stdio: ['pipe', 'pipe', 'pipe'],
+      shell: !!runnerSpec.shell,
+      windowsHide: true,
+      env: env || process.env
+    });
+  } catch (error) {
+    finish(`启动失败：${error.message}`);
+    return null;
+  }
+  registerChild(child, 'solo'); // 停止/退出清理复用 agent.js 的登记表（scope='solo'）
+
+  child.stdin.on('error', () => { /* stdin 已关闭则忽略 */ });
+  if (prompt) child.stdin.write(prompt);
+  child.stdin.end();
+
+  let stdoutBuf = '';
+  let stderrBuf = '';
+  let killed = false;
+  const state = { ocSessionId: '', errEvents: [], toolSeq: 0, mockText: '', textOrder: [] };
+
+  const timeoutMs = Number(process.env.AGENTS_CHAT_TIMEOUT_MS) > 0
+    ? Number(process.env.AGENTS_CHAT_TIMEOUT_MS)
+    : 600000;
+  const timer = setTimeout(() => { killed = true; killTree(child); }, timeoutMs);
+
+  const runLine = (line) => {
+    if (runnerSpec.json) {
+      parseSoloEventLine(line, onEvent, state);
+    } else {
+      // 非 JSON 输出（演示模式）：按行累积成快照
+      state.mockText += line + '\n';
+      onEvent({ type: 'text', partId: 'mock', text: state.mockText });
+    }
+  };
+
+  child.stdout.on('data', (data) => {
+    stdoutBuf += data.toString();
+    let idx;
+    while ((idx = stdoutBuf.indexOf('\n')) >= 0) {
+      const line = stdoutBuf.slice(0, idx).trim();
+      stdoutBuf = stdoutBuf.slice(idx + 1);
+      if (line) runLine(line);
+    }
+  });
+
+  child.stderr.on('data', (data) => { stderrBuf += data.toString(); });
+
+  child.on('error', (error) => {
+    clearTimeout(timer);
+    finish(`调用失败：${error.message}`, state);
+  });
+
+  child.on('close', (code) => {
+    clearTimeout(timer);
+    if (stdoutBuf.trim()) runLine(stdoutBuf.trim());
+    let error;
+    if (child._stopped) error = '已手动停止';
+    else if (killed) error = `执行超时（超过 ${Math.round(timeoutMs / 1000)} 秒已强制终止）。可在 .env 调大 AGENTS_CHAT_TIMEOUT_MS`;
+    else if (state.errEvents.length) error = state.errEvents.join('\n').slice(0, 2000);
+    else if (code !== 0) error = (stderrBuf.trim() || `进程异常退出（退出码 ${code}）`).slice(0, 2000);
+    finish(error, state);
+  });
+
+  return child;
+}
+
+function killTree(child) {
+  if (!child || child.exitCode !== null) return;
+  try {
+    if (process.platform === 'win32') {
+      require('child_process').execSync(`taskkill /pid ${child.pid} /T /F`, { stdio: 'ignore', timeout: 10000 });
+    } else {
+      child.kill('SIGKILL');
+    }
+  } catch { /* 进程可能已退出 */ }
+}
+
+// ---------- 单轮对话 ----------
+// runnerKind:
+//   'demo'：演示模式（mock 子进程，快照事件 + 本地 fake 会话 ID）
+//   'opencode'：真实链路（ocSessionId 存在则 -s 续聊；首个 sessionID 事件回填）
+//   其他内核：退化为一次性对话（无续聊，文本经 agent.js 内核解析转发）
+// onEvent 收到 {type:'done', error} 即本轮结束
+function chatSolo(runnerKind, runner, opts, onEvent) {
+  const prompt = String(opts.prompt || '');
+  const model = String(opts.model || '');
+  const ocSessionId = String(opts.ocSessionId || '');
+  // 工作区：指定后 Agent 在该目录读写文件（卡牌可选 workspace）
+  const cwd = opts.cwd && fs.existsSync(opts.cwd) && fs.statSync(opts.cwd).isDirectory() ? opts.cwd : '';
+  const cwdEnv = cwd ? { ...process.env, AGENTS_CHAT_CWD: cwd } : process.env;
+
+  // ---- 演示模式：mock 子进程 + 快照模拟 ----
+  if (runnerKind === 'demo') {
+    return spawnSoloRunner(
+      { cmd: process.execPath, shell: false, json: false, cwd: cwd || process.cwd() },
+      [MOCK_SCRIPT, prompt],
+      '',
+      cwdEnv,
+      onEvent,
+      (error) => {
+        // 演示模式的会话 ID：续聊时复用传入 ID（打通链路），新任务本地生成（无真实续聊）
+        onEvent({ type: 'session', ocSessionId: ocSessionId || 'ses_demo-' + Date.now().toString(36) });
+        onEvent({ type: 'done', error });
+      }
+    );
+  }
+
+  // ---- opencode 真实链路 ----
+  if (runnerKind === 'opencode') {
+    const args = ['run', '--format', 'json'];
+    if (model && MODEL_RE.test(model)) args.push('-m', model);
+    if (ocSessionId && OC_SESSION_RE.test(ocSessionId)) args.push('-s', ocSessionId);
+    // 非交互模式下 opencode 对权限请求默认自动拒绝，导致无法真实干活；
+    // 默认加 --auto，.env 可用 AGENTS_CHAT_AUTO_APPROVE=0 关闭（与群聊一致）
+    if (process.env.AGENTS_CHAT_AUTO_APPROVE !== '0') args.push('--auto');
+    return spawnSoloRunner(
+      { cmd: runner.cmd, shell: runner.shell, json: true, cwd: cwd || resolveCwd() },
+      args, prompt, cwdEnv,
+      onEvent,
+      (error) => onEvent({ type: 'done', error })
+    );
+  }
+
+  // ---- 其他内核（claude/codex/pi）：一次性对话，无续聊 ----
+  // 这些内核的文本事件是增量块，这里累积成快照后再发（与 opencode 快照语义对齐）
+  const { runAgent } = require('./agent');
+  let acc = '';
+  return runAgent(
+    { model: model || process.env.AGENTS_CHAT_MODEL || '', behavior: 'echo', id: 'solo', name: runner.kernel ? runner.kernel.label : 'AI' },
+    prompt,
+    (chunk) => {
+      if (chunk.content) { acc += chunk.content; onEvent({ type: 'text', partId: 'solo', text: acc }); }
+      if (chunk.done) onEvent({ type: 'done', error: chunk.error, noResume: true });
+    },
+    'solo'
+  );
+}
+
+module.exports = { chatSolo, listOcModels, demoModels, MODEL_RE, parseSoloEventLine };