agent-loft 0.2.24 → 0.2.26

package/src/core/chat-history.ts

@@ -0,0 +1,250 @@
+// 聊天记录索引：给「参考以前的聊天」（search_past_chats）和「聊完自动整理记忆」用。
+//
+// 每个用户一份，data/history/<用户 id>.jsonl，一行一句（用户说的 / agent 的最终回复）。
+// 只收有主人的对话（见 personal.ts 的 memoryOwnerOf），按主人分开存 —— 搜索只在自己的里面搜。
+// 来源两个：
+//   - 实时：hub 的事件流（见 startHistoryCapture），从现在起说的话；
+//   - 回填：第一次用时把已有对话从 agent 的记录里读一遍（见 memory-curator.ts），只做一次。
+//
+// 为什么不用 SQLite 全文索引：FTS5 的 trigram 分词搜不到两个字的中文词（「豆豆」），
+// 个人的聊天量直接扫文件就够快（几万句也是毫秒级），也省得 MCP 子进程每次打实验性 API 的警告。
+import fs from "node:fs";
+import path from "node:path";
+import { dataDir, readJson, writeJsonAtomic } from "../home.js";
+
+export type HistoryRecord = {
+  /** 对话 key */
+  k: string;
+  /** agent */
+  a: string;
+  /** u：用户说的；a：agent 的回复 */
+  r: "u" | "a";
+  t: string;
+  ts: number;
+};
+
+export type CurationLog = {
+  at: number;
+  /** 整理了几段对话 */
+  conversations: number;
+  added: string[];
+  updated: string[];
+  removed: number;
+  /** 用的哪个 agent / 模型 */
+  by?: string;
+  error?: string;
+};
+
+export type Meta = {
+  /** 已有对话回填过了 */
+  backfilled?: boolean;
+  /** 每条对话整理记忆整理到了哪个时刻（这之后的话还没整理过） */
+  extracted: Record<string, number>;
+  /** 「每天一次」上次跑的是哪天（本地日期 YYYY-MM-DD） */
+  lastDaily?: string;
+  /** 上次整理的结果，设置页显示 */
+  lastCuration?: CurationLog;
+};
+
+const historyDir = path.join(dataDir, "history");
+/** 一句话最多存这么多字：长篇代码、整页网页没必要全存 */
+const TEXT_MAX = 4000;
+
+function base(userId: string): string {
+  if (!/^[A-Za-z0-9_]{1,64}$/.test(userId)) throw new Error("用户 id 不合法");
+  return path.join(historyDir, userId);
+}
+
+export function appendRecords(userId: string, records: HistoryRecord[]): void {
+  if (records.length === 0) return;
+  fs.mkdirSync(historyDir, { recursive: true, mode: 0o700 });
+  const lines = records.map((r) => JSON.stringify({ ...r, t: r.t.slice(0, TEXT_MAX) })).join("\n");
+  fs.appendFileSync(`${base(userId)}.jsonl`, `${lines}\n`, { mode: 0o600 });
+}
+
+export function readRecords(userId: string): HistoryRecord[] {
+  let raw: string;
+  try {
+    raw = fs.readFileSync(`${base(userId)}.jsonl`, "utf8");
+  } catch {
+    return [];
+  }
+  const out: HistoryRecord[] = [];
+  for (const line of raw.split("\n")) {
+    if (!line) continue;
+    try {
+      const r = JSON.parse(line) as HistoryRecord;
+      if (typeof r.k === "string" && typeof r.t === "string" && (r.r === "u" || r.r === "a")) out.push(r);
+    } catch {
+      // 写到一半被打断的行：跳过
+    }
+  }
+  return out;
+}
+
+export function readMeta(userId: string): Meta {
+  const m = readJson<Partial<Meta>>(`${base(userId)}.meta.json`, {});
+  return { ...m, extracted: m.extracted && typeof m.extracted === "object" ? m.extracted : {} };
+}
+
+export function patchMeta(userId: string, patch: Partial<Meta>): void {
+  writeMeta(userId, { ...readMeta(userId), ...patch });
+}
+
+export function writeMeta(userId: string, meta: Meta): void {
+  fs.mkdirSync(historyDir, { recursive: true, mode: 0o700 });
+  writeJsonAtomic(`${base(userId)}.meta.json`, meta);
+}
+
+export function markExtracted(userId: string, key: string, upTo: number): void {
+  const meta = readMeta(userId);
+  meta.extracted[key] = Math.max(meta.extracted[key] ?? 0, upTo);
+  writeMeta(userId, meta);
+}
+
+/** 删用户时：整个删掉 */
+export function purgeHistory(userId: string): void {
+  fs.rmSync(`${base(userId)}.jsonl`, { force: true });
+  fs.rmSync(`${base(userId)}.meta.json`, { force: true });
+}
+
+/**
+ * 还没整理过的对话：最后一句已经过去 idleMs 了（聊完了），而且在上次整理之后又说过话。
+ * 返回每条对话上次整理之后的那些句子。
+ */
+export function pendingConversations(
+  userId: string,
+  idleMs: number,
+  now = Date.now(),
+): { key: string; records: HistoryRecord[]; last: number }[] {
+  const meta = readMeta(userId);
+  const byKey = new Map<string, HistoryRecord[]>();
+  for (const r of readRecords(userId)) {
+    if (r.ts <= (meta.extracted[r.k] ?? 0)) continue;
+    let list = byKey.get(r.k);
+    if (!list) byKey.set(r.k, (list = []));
+    list.push(r);
+  }
+  const out: { key: string; records: HistoryRecord[]; last: number }[] = [];
+  for (const [key, records] of byKey) {
+    const last = Math.max(...records.map((r) => r.ts));
+    if (now - last >= idleMs) out.push({ key, records, last });
+  }
+  return out;
+}
+
+// ---------- 搜索 ----------
+
+/** 把查询拆成词：按空白和标点切开。中文不切词，长的中文词另外拆成两字一组做模糊匹配 */
+function terms(query: string): string[] {
+  return query
+    .toLowerCase()
+    .split(/[\s,，。.!！?？、;；:："'“”‘’()（）[\]【】<>《》/\\|]+/)
+    .map((t) => t.trim())
+    .filter(Boolean);
+}
+
+const isCjk = (s: string) => /[㐀-鿿]/.test(s);
+
+function bigrams(s: string): string[] {
+  const out: string[] = [];
+  for (let i = 0; i + 2 <= s.length; i++) out.push(s.slice(i, i + 2));
+  return out;
+}
+
+function occurrences(hay: string, needle: string, cap = 5): number {
+  let n = 0;
+  for (let i = hay.indexOf(needle); i >= 0 && n < cap; i = hay.indexOf(needle, i + needle.length)) n++;
+  return n;
+}
+
+/** 一句话和查询的相关程度，0 是不相关 */
+export function scoreText(text: string, query: string): number {
+  const hay = text.toLowerCase();
+  const ts = terms(query);
+  if (ts.length === 0) return 0;
+  let score = 0;
+  let hit = 0;
+  for (const term of ts) {
+    const n = occurrences(hay, term);
+    if (n > 0) {
+      hit++;
+      score += n * Math.min(term.length, 8);
+      continue;
+    }
+    // 长的中文没整个出现：看两字组合命中了多少（「软路由防污染」能搜到「软路由怎么防 DNS 污染」）
+    if (isCjk(term) && term.length >= 4) {
+      const grams = bigrams(term);
+      const found = grams.filter((g) => hay.includes(g)).length;
+      if (found / grams.length >= 0.5) {
+        hit += found / grams.length;
+        score += found;
+      }
+    }
+  }
+  if (score === 0) return 0;
+  // 所有词都命中的排前面
+  return score * (hit >= ts.length ? 2 : 1);
+}
+
+/** 截一段命中位置附近的文字 */
+function snippet(text: string, query: string, max: number): string {
+  const flat = text.replace(/\s+/g, " ").trim();
+  if (flat.length <= max) return flat;
+  const lower = flat.toLowerCase();
+  const first = terms(query)
+    .map((t) => lower.indexOf(t))
+    .filter((i) => i >= 0)
+    .sort((a, b) => a - b)[0];
+  const start = Math.max(0, Math.min((first ?? 0) - Math.floor(max / 3), flat.length - max));
+  return `${start > 0 ? "…" : ""}${flat.slice(start, start + max)}${start + max < flat.length ? "…" : ""}`;
+}
+
+export type SearchHit = { key: string; ts: number; user?: string; assistant?: string; score: number };
+
+/**
+ * 在这个用户的聊天记录里搜。结果是一问一答为单位，相关的在前（同样相关的新的在前）。
+ * skip：不要的对话（被删掉的、当前这条）。
+ */
+export function searchHistory(
+  userId: string,
+  query: string,
+  opts: { limit?: number; skip?: (key: string) => boolean; now?: number } = {},
+): SearchHit[] {
+  const records = readRecords(userId);
+  const now = opts.now ?? Date.now();
+  const scored: { i: number; score: number }[] = [];
+  records.forEach((r, i) => {
+    if (opts.skip?.(r.k)) return;
+    const s = scoreText(r.t, query);
+    if (s === 0) return;
+    // 新的稍微靠前：一个月内的最多加 30%
+    const age = Math.max(0, now - r.ts) / (30 * 86400_000);
+    scored.push({ i, score: s * (1 + 0.3 * Math.exp(-age)) });
+  });
+  scored.sort((a, b) => b.score - a.score || records[b.i]!.ts - records[a.i]!.ts);
+  const out: SearchHit[] = [];
+  const used = new Set<number>();
+  const limit = opts.limit ?? 6;
+  for (const { i, score } of scored) {
+    if (out.length >= limit) break;
+    if (used.has(i)) continue;
+    const r = records[i]!;
+    // 配上同一条对话里紧挨着的另一半：问配答，答配问
+    const pairIndex = r.r === "u" ? i + 1 : i - 1;
+    const pair = records[pairIndex];
+    const partner = pair && pair.k === r.k && pair.r !== r.r ? pair : undefined;
+    used.add(i);
+    if (partner) used.add(pairIndex);
+    const user = r.r === "u" ? r : partner;
+    const assistant = r.r === "a" ? r : partner;
+    out.push({
+      key: r.k,
+      ts: r.ts,
+      ...(user ? { user: snippet(user.t, query, 300) } : {}),
+      ...(assistant ? { assistant: snippet(assistant.t, query, 600) } : {}),
+      score,
+    });
+  }
+  return out;
+}

package/src/core/chat-mode.ts

@@ -0,0 +1,62 @@
+// 聊天模式要告诉 agent 的话，以及怎么告诉。
+//
+// 两个 agent 的「换系统提示」能力不一样（都实测过）：
+//   - Claude：系统提示每次拉起进程时整个给，换模式 = 带着新的系统提示 resume，干净利落。
+//     聊天模式就用 chatSystemPrompt 换掉 Claude Code 原装的那一大段（约 1.6 万 token）。
+//   - Codex：thread 的基础指令一旦设了就钉在 thread 上（resume 时不传就沿用，传 null 也一样），
+//     开发者指令只在 thread 开头写一次、resume 时给新的会被忽略。所以 Codex 不动它的指令，
+//     模式和记忆用 contextBlock 附在「这个会话进程的第一条消息」后面 —— 它按时间顺序进历史，
+//     模型以最新的为准。读历史、列会话时用 stripContext 把它剥掉。
+//
+// 日期写进去是因为模型不知道今天几号；它在一条会话里不变，不影响提示缓存。
+
+function today(): string {
+  const d = new Date();
+  const pad = (n: number) => String(n).padStart(2, "0");
+  const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}（${tz}）`;
+}
+
+/** search：这个 agent 里联网搜索 / 读网页的工具怎么称呼 */
+function chatRules(search: string): string[] {
+  return [
+    "- 用用户使用的语言回答，自然、直接、简洁；需要时用 Markdown 排版（列表、表格、代码块）。",
+    `- 涉及最新信息、新闻、价格、版本、事实核查时，先用${search}查，回答里附上来源链接；不要凭记忆编造。`,
+    "- 用户发来的图片、PDF 和文本文件内容会直接附在消息里。",
+    "- 现在是「聊天模式」：你不能执行命令，也不能读写这台机器上的文件。用户要你动手干活（写代码、改文件、跑命令、操作服务器）时，告诉他发 /work 切到工作模式，同一条对话会接着聊。",
+  ];
+}
+
+/** Claude 聊天模式的整段系统提示 */
+export function chatSystemPrompt(search: string, memory?: string): string {
+  const base = ["你是用户的私人 AI 助手，他通过 agent-loft 的网页或飞书和你聊天。", "", ...chatRules(search), "", `今天是 ${today()}。`].join("\n");
+  return memory ? `${base}\n\n${memory}` : base;
+}
+
+const OPEN = "<agent-loft-context>";
+const CLOSE = "</agent-loft-context>";
+
+/** Codex：附在会话进程第一条消息后面的背景（模式 + 记忆） */
+export function contextBlock(mode: "chat" | "work", memory: string | undefined, search: string): string {
+  const head =
+    mode === "chat"
+      ? ["当前是「聊天模式」，你作为用户的私人 AI 助手和他聊天：", ...chatRules(search)]
+      : ["当前是「工作模式」：可以执行命令、读写文件，按平常的方式干活。之前如果说过「聊天模式下不能做」，那个限制已经解除。"];
+  return [
+    OPEN,
+    "（这段是 agent-loft 自动附上的背景，不是用户写的。照着做，但不要在回复里提到它。）",
+    "",
+    ...head,
+    ...(memory ? ["", memory] : []),
+    CLOSE,
+  ].join("\n");
+}
+
+/** 剥掉 contextBlock（读历史、列会话标题时用） */
+export function stripContext(text: string): string {
+  const start = text.indexOf(OPEN);
+  if (start < 0) return text;
+  const end = text.indexOf(CLOSE, start);
+  const rest = end < 0 ? "" : text.slice(end + CLOSE.length);
+  return `${text.slice(0, start)}${rest}`.trim();
+}

package/src/core/command-catalog.ts

@@ -22,6 +22,8 @@ export const BUILTIN_COMMANDS: BuiltinSpec[] = [
   { name: "stop", description: "中断当前执行" },
   { name: "model", args: "[名称]", description: "切换模型（不带参数弹选择）" },
   { name: "effort", args: "[程度]", description: "切换思考程度" },
+  { name: "chat", description: "切到聊天模式：精简、只能联网搜索，每轮开销小很多" },
+  { name: "work", description: "切到工作模式：agent 原装的全部能力" },
   { name: "status", description: "查看当前会话、模型、目录、剩余额度" },
   { name: "sessions", args: "[all]", description: "列出历史会话，点按钮恢复；加 all 列所有目录" },
   { name: "resume", args: "<会话ID>", description: "恢复指定会话" },
@@ -34,6 +36,7 @@ export const BUILTIN_COMMANDS: BuiltinSpec[] = [
   { name: "codex", description: "切换到 Codex", multiAgentOnly: true },
   { name: "web", description: "接上一条 Web 会话，在飞书里查看和回复", feishuOnly: true },
   { name: "detach", description: "不再接着 Web 会话，回到这个聊天自己的会话", feishuOnly: true },
+  { name: "bind", args: "<绑定码>", description: "把这个飞书账号绑定到你的 agent-loft 用户（绑定码在 Web 的「设置 → 我的账号」里生成）", feishuOnly: true },
   { name: "help", description: "显示帮助" },
   { name: "approve", args: "<请求ID> allow-once|allow-always|allow-session|deny", description: "审批兜底（卡片失效时用）" },
 ];

package/src/core/commands.ts

@@ -18,6 +18,7 @@ export type ParsedCommand =
   | { kind: "status" }
   | { kind: "pwd" }
   | { kind: "autoedit"; on?: boolean }
+  | { kind: "mode"; mode: "chat" | "work" }
   | { kind: "help" }
   /** 只发了一个「/」：列出可用命令 */
   | { kind: "commands" }
@@ -69,6 +70,9 @@ export function parseCommand(raw: string): ParsedCommand {
       if (["off", "关", "0", "false"].includes(v)) return { kind: "autoedit", on: false };
       return { kind: "chat", text };
     }
+    case "chat":
+    case "work":
+      return arg ? { kind: "chat", text } : { kind: "mode", mode: head.toLowerCase() as "chat" | "work" };
     case "help":
       return { kind: "help" };
     case "approve": {

package/src/core/feishu-links.ts

@@ -0,0 +1,119 @@
+// 飞书账号 ↔ agent-loft 用户的绑定。
+//
+// 绑定之后，这个飞书账号和机器人的私聊就是这个用户的个人会话：归他所有（Web 上别人看不到），
+// 用他的记忆，/sessions 只列他的会话，/web 只能接上他自己的 Web 会话。
+// 群聊不受影响：群里不止一个人，照旧是管理员的地盘，也不用记忆。
+//
+// 绑定必须由用户本人完成：在 Web 上（已登录）生成绑定码，再用飞书在私聊里发 /bind 绑定码。
+// 两边都证明了身份，才算数。不提供「管理员直接指定」—— 那样管理员把自己的飞书绑到成员名下，
+// 就能在飞书里读到成员的记忆。管理员只能解除绑定（只会让人失去访问，不会多出访问）。
+//
+// open_id 是按飞书应用分的：同一个人在不同机器人上 open_id 不同，所以按 (机器人, open_id) 记。
+import crypto from "node:crypto";
+import path from "node:path";
+import { dataDir, readJson, writeJsonAtomic } from "../home.js";
+import { getUser, type User } from "./users.js";
+
+export type FeishuLink = { botId: string; openId: string; userId: string; boundAt: number };
+
+type Store = Record<string, Record<string, { userId: string; boundAt: number }>>;
+
+const storePath = path.join(dataDir, "feishu-links.json");
+
+function read(): Store {
+  return readJson<Store>(storePath, {});
+}
+
+const norm = (openId: string) => openId.trim().toLowerCase();
+
+/** 这个飞书账号绑定的用户（还在、没被停用的）。没绑定返回 undefined */
+export function linkedUser(botId: string, openId: string | undefined): User | undefined {
+  if (!openId) return undefined;
+  const userId = read()[botId]?.[norm(openId)]?.userId;
+  const user = getUser(userId);
+  return user && !user.disabled ? user : undefined;
+}
+
+export function listLinks(userId?: string): FeishuLink[] {
+  return Object.entries(read()).flatMap(([botId, links]) =>
+    Object.entries(links)
+      .filter(([, l]) => !userId || l.userId === userId)
+      .map(([openId, l]) => ({ botId, openId, userId: l.userId, boundAt: l.boundAt })),
+  );
+}
+
+/** 解除一个绑定。onlyUser 给了的话，只能解除属于他的 */
+export function unlink(botId: string, openId: string, onlyUser?: string): boolean {
+  const store = read();
+  const id = norm(openId);
+  const link = store[botId]?.[id];
+  if (!link || (onlyUser && link.userId !== onlyUser)) return false;
+  delete store[botId]![id];
+  if (Object.keys(store[botId]!).length === 0) delete store[botId];
+  writeJsonAtomic(storePath, store);
+  return true;
+}
+
+/** 解除这个用户的所有绑定（删用户、管理员解除时） */
+export function unlinkUser(userId: string): number {
+  const store = read();
+  let n = 0;
+  for (const [botId, links] of Object.entries(store)) {
+    for (const [openId, l] of Object.entries(links)) {
+      if (l.userId !== userId) continue;
+      delete links[openId];
+      n++;
+    }
+    if (Object.keys(links).length === 0) delete store[botId];
+  }
+  if (n > 0) writeJsonAtomic(storePath, store);
+  return n;
+}
+
+// ---------- 绑定码 ----------
+//
+// 只在内存里：十分钟有效，服务重启就作废（重新生成一个就行）。
+
+const CODE_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+const CODE_TTL_MS = 10 * 60 * 1000;
+const codes = new Map<string, { userId: string; expiresAt: number }>();
+
+function sweep(now = Date.now()): void {
+  for (const [code, c] of codes) if (c.expiresAt <= now) codes.delete(code);
+}
+
+/** 给这个用户生成一个绑定码。之前没用掉的作废，同一时间每人只有一个 */
+export function createLinkCode(userId: string): { code: string; expiresAt: number } {
+  sweep();
+  for (const [code, c] of codes) if (c.userId === userId) codes.delete(code);
+  const code = Array.from(crypto.randomBytes(8), (b) => CODE_ALPHABET[b % CODE_ALPHABET.length]).join("");
+  const expiresAt = Date.now() + CODE_TTL_MS;
+  codes.set(code, { userId, expiresAt });
+  return { code, expiresAt };
+}
+
+/**
+ * 飞书里发了 /bind 绑定码：认领它，把 (机器人, open_id) 绑到生成这个码的用户上。
+ * 一个飞书账号只能绑一个用户，再绑就是换人（码证明了新主人的身份）。
+ */
+export function redeemLinkCode(code: string, botId: string, openId: string): User {
+  sweep();
+  const key = code.trim().toUpperCase();
+  const entry = codes.get(key);
+  if (!entry) throw new Error("绑定码不对或已过期。请在 Web 上（设置 → 我的账号）重新生成一个。");
+  const user = getUser(entry.userId);
+  if (!user || user.disabled) {
+    codes.delete(key);
+    throw new Error("生成这个绑定码的用户已经不存在或被停用了。");
+  }
+  codes.delete(key);
+  const store = read();
+  (store[botId] ??= {})[norm(openId)] = { userId: user.id, boundAt: Date.now() };
+  writeJsonAtomic(storePath, store);
+  return user;
+}
+
+/** 测试用 */
+export function resetLinkCodesForTest(): void {
+  codes.clear();
+}