@dsh-overdrive/gateway 0.1.5 → 0.1.7

package/src/index.ts

@@ -7,6 +7,7 @@ import { parseCommand, HELP_TEXT, type ParsedCommand } from './commands.js';
 import { TrajectoryAggregator, formatTrajectorySummary } from './trajectory.js';
 import { createStatusServer } from './status.js';
 import { createTranscriber, type AsrTranscriber } from './asr.js';
+import { MemoryStore, memoryScope, formatMemories } from './memory.js';
 
 /**
  * message.delta → 打字指示去重：同一 turn 内首个 delta 触发一次 typing，
@@ -69,9 +70,24 @@ export interface WireOptions {
   allowAll?: boolean;
   /** ASR 转写器；配置了 API key 时启用，语音消息转成文本再发给 agent。 */
   asr?: AsrTranscriber;
+  /** 记忆系统（OpenClaw 式长期记忆）；未提供则记忆命令返回不可用。 */
+  memory?: MemoryStore;
 }
 
-/** 命令面分发：/trace /new /task /cron /agents /help（M4）。 */
+/** 纯函数：一次性提醒的时间 → cron 5 字段表达式（分钟精度）。 */
+export function remindSchedule(minutes: number, atTime: string | null, now = new Date()): string {
+  const target = new Date(now);
+  if (atTime) {
+    const [h, m] = atTime.split(':').map(Number);
+    target.setHours(h, m, 0, 0);
+    if (target <= now) target.setDate(target.getDate() + 1); // 已过则明天
+  } else {
+    target.setMinutes(target.getMinutes() + minutes);
+  }
+  return `${target.getMinutes()} ${target.getHours()} ${target.getDate()} ${target.getMonth() + 1} *`;
+}
+
+/** 命令面分发：/trace /new /task /cron /agents /help /remind /remember /recall /forget（M4 + v0.3）。 */
 async function handleCommand(
   adapter: Adapter,
   client: GatewayClient,
@@ -79,6 +95,7 @@ async function handleCommand(
   sessionId: string,
   chatId: string,
   aggregator: TrajectoryAggregator,
+  memory: MemoryStore | undefined,
 ): Promise<void> {
   switch (command.kind) {
     case 'trace': {
@@ -104,7 +121,12 @@ async function handleCommand(
     case 'crons': {
       const res = await client.listTasks();
       const text = res.tasks.length
-        ? res.tasks.map((task) => `- \`${task.id}\` ${task.schedule} — ${task.prompt}`).join('\n')
+        ? res.tasks.map((task) => {
+            const next = task.nextRunAt
+              ? new Date(task.nextRunAt).toLocaleString('zh-CN', { hour12: false })
+              : '（无下次触发）';
+            return `- \`${task.id}\` ${task.schedule} — ${task.prompt}（下次 ${next}）`;
+          }).join('\n')
         : '暂无定时任务。';
       await adapter.send(chatId, { text: `⏰ 定时任务（${res.tasks.length}）:\n${text}` });
       return;
@@ -120,6 +142,38 @@ async function handleCommand(
       await adapter.send(chatId, { text: '（M4 简化）子任务状态由 agent 汇报，/task 派发' });
       return;
     }
+    case 'remember': {
+      if (!memory) { await adapter.send(chatId, { text: '记忆系统未启用。' }); return; }
+      const scope = memoryScope(adapter.id, sessionId.split(':')[2] ?? '');
+      const entry = memory.add(scope, command.text);
+      await adapter.send(chatId, { text: `✅ 已记住（\`${entry.id}\`）：${command.text}` });
+      return;
+    }
+    case 'recall': {
+      if (!memory) { await adapter.send(chatId, { text: '记忆系统未启用。' }); return; }
+      const scope = memoryScope(adapter.id, sessionId.split(':')[2] ?? '');
+      const hits = memory.search(scope, command.query);
+      if (hits.length === 0) { await adapter.send(chatId, { text: '没有相关记忆。' }); return; }
+      await adapter.send(chatId, {
+        text: `🧠 ${hits.length} 条记忆：\n` + hits.map((e) => `- \`${e.id}\` ${e.text}`).join('\n'),
+      });
+      return;
+    }
+    case 'forget': {
+      if (!memory) { await adapter.send(chatId, { text: '记忆系统未启用。' }); return; }
+      const scope = memoryScope(adapter.id, sessionId.split(':')[2] ?? '');
+      const ok = memory.remove(scope, command.memoryId);
+      await adapter.send(chatId, { text: ok ? `🗑️ 已删除记忆 \`${command.memoryId}\`` : `未找到记忆 \`${command.memoryId}\`` });
+      return;
+    }
+    case 'remind': {
+      const schedule = remindSchedule(command.inMinutes ?? 0, command.atTime);
+      await client.createTask({ sessionId, kind: 'cron', prompt: `⏰ 提醒：${command.text}`, schedule, once: true });
+      await adapter.send(chatId, {
+        text: `⏰ 已设置提醒「${command.text}」（${command.atTime ? `at ${command.atTime}` : `${command.inMinutes} 分钟后`}，一次性）`,
+      });
+      return;
+    }
     case 'help': {
       await adapter.send(chatId, { text: HELP_TEXT });
       return;
@@ -151,10 +205,20 @@ export async function wireAdapter(
       const command = parseCommand(msg.text);
       if (command) {
         console.log(`[gateway][${adapter.id}] 命令: ${JSON.stringify(command)}`);
-        await handleCommand(adapter, client, command, key, msg.chatId, aggregator);
+        await handleCommand(adapter, client, command, key, msg.chatId, aggregator, opts.memory);
         return;
       }
 
+      // OpenClaw 式记忆注入：入站消息前检索相关记忆，拼到文本后让 agent「记得你」
+      if (opts.memory) {
+        const scope = memoryScope(adapter.id, msg.userId);
+        const hits = opts.memory.search(scope, msg.text);
+        if (hits.length > 0) {
+          msg.text = `${msg.text}${formatMemories(hits)}`;
+          console.log(`[gateway][${adapter.id}] 注入 ${hits.length} 条相关记忆`);
+        }
+      }
+
       // ASR 语音转写：配置了 API key 时把语音消息转成文本；失败/未配置走原降级路径
       if (msg.media?.kind === 'voice' && opts.asr?.enabled) {
         const transcript = await opts.asr.transcribe(msg.media);
@@ -229,7 +293,7 @@ export async function wireAdapter(
 
 async function main(): Promise<void> {
   const dshBaseUrl = process.env.DSH_BASE_URL ?? 'http://127.0.0.1:3191';
-  const dshToken = process.env.DSH_TOKEN ?? 'dev-token';
+  const dshToken = process.env.DSH_OVERDRIVE_TOKEN ?? process.env.DSH_TOKEN ?? 'dev-token';
   const allowlist = (process.env.ALLOWLIST ?? '')
     .split(',').map((s) => s.trim()).filter(Boolean);
   const allowAll = process.env.ALLOW_ALL === '1';
@@ -241,6 +305,8 @@ async function main(): Promise<void> {
     model: env.asrModel,
   });
   if (asr.enabled) console.log('[gateway] ASR 语音转写已启用');
+  const memory = new MemoryStore(process.env.MEMORY_FILE ?? 'data/memory.json');
+  console.log(`[gateway] 记忆系统已启用（文件: ${process.env.MEMORY_FILE ?? 'data/memory.json'}）`);
 
   const client = new GatewayClient(dshBaseUrl, dshToken);
   await client.health(); // 确认 DSH 侧（或 mock）活着
@@ -248,7 +314,7 @@ async function main(): Promise<void> {
   const adapters: Adapter[] = adapterIds.map((id) => createAdapter(id, env));
   for (const adapter of adapters) {
     await adapter.connect();
-    await wireAdapter(adapter, client, { allowlist, allowAll, asr });
+    await wireAdapter(adapter, client, { allowlist, allowAll, asr, memory });
     console.log(`[gateway] ${adapter.id} 适配器已就绪`);
   }
 

package/src/memory.ts

@@ -0,0 +1,108 @@
+// 记忆系统（对标 OpenClaw 的 long-term memory）。
+// 按 platform:userId 作用域存储用户显式记忆（/remember），支持搜索（/recall）与删除（/forget）；
+// 入站消息时自动检索相关记忆注入上下文，让 agent「记得你」。
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+export interface MemoryEntry {
+  id: string;
+  text: string;
+  createdAt: string;
+}
+
+/** 作用域键：platform:userId（记忆跟随用户，跨频道共享，与 OpenClaw 一致）。 */
+export function memoryScope(adapterId: string, userId: string): string {
+  return `${adapterId}:${userId}`;
+}
+
+/** 字符 2-gram：CJK 无空格分词，用共享 bigram 判断相关性（比子串包含更鲁棒）。 */
+function bigrams(text: string): Set<string> {
+  const clean = text.toLowerCase();
+  const out = new Set<string>();
+  for (let i = 0; i < clean.length - 1; i++) out.add(clean.slice(i, i + 2));
+  return out;
+}
+
+/** 纯函数：按查询文本检索记忆——与查询共享任意 2-gram 即相关；空查询返回全部。 */
+export function searchMemories(entries: MemoryEntry[], query: string): MemoryEntry[] {
+  const queryBigrams = bigrams(query);
+  if (queryBigrams.size === 0) return entries;
+  return entries.filter((entry) => {
+    const memoryBigrams = bigrams(entry.text);
+    for (const gram of queryBigrams) {
+      if (memoryBigrams.has(gram)) return true;
+    }
+    return false;
+  });
+}
+
+/** 纯函数：记忆列表 → 注入文本（拼在用户消息后）。 */
+export function formatMemories(entries: MemoryEntry[]): string {
+  if (entries.length === 0) return '';
+  const lines = entries.map((e) => `- ${e.text}`).join('\n');
+  return `\n📌 相关记忆：\n${lines}`;
+}
+
+/** JSON 文件持久化的记忆存储；file 缺省时仅内存（测试/无盘环境用）。 */
+export class MemoryStore {
+  private readonly data = new Map<string, MemoryEntry[]>();
+  private readonly file?: string;
+
+  constructor(file?: string) {
+    this.file = file;
+    if (file && existsSync(file)) {
+      try {
+        const parsed = JSON.parse(readFileSync(file, 'utf8')) as Record<string, MemoryEntry[]>;
+        for (const [scope, entries] of Object.entries(parsed)) {
+          if (Array.isArray(entries)) this.data.set(scope, entries);
+        }
+      } catch {
+        /* 损坏则从空开始 */
+      }
+    }
+  }
+
+  private persist(): void {
+    if (!this.file) return;
+    try {
+      mkdirSync(dirname(this.file), { recursive: true });
+      writeFileSync(this.file, JSON.stringify(Object.fromEntries(this.data), null, 2), 'utf8');
+    } catch {
+      /* 持久化失败不阻断 */
+    }
+  }
+
+  add(scope: string, text: string): MemoryEntry {
+    const entry: MemoryEntry = { id: randomUUID().slice(0, 8), text: text.trim(), createdAt: new Date().toISOString() };
+    const list = this.data.get(scope) ?? [];
+    list.push(entry);
+    this.data.set(scope, list);
+    this.persist();
+    return entry;
+  }
+
+  list(scope: string): MemoryEntry[] {
+    return this.data.get(scope) ?? [];
+  }
+
+  search(scope: string, query: string): MemoryEntry[] {
+    return searchMemories(this.list(scope), query);
+  }
+
+  /** 删除某作用域下指定 id 的记忆；不存在返回 false。 */
+  remove(scope: string, id: string): boolean {
+    const list = this.data.get(scope);
+    if (!list) return false;
+    const next = list.filter((e) => e.id !== id);
+    if (next.length === list.length) return false;
+    this.data.set(scope, next);
+    this.persist();
+    return true;
+  }
+
+  count(scope: string): number {
+    return this.list(scope).length;
+  }
+}

package/test/adapters.wechat.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, it } from 'vitest';
+import {
+  buildGetUpdatesBody, buildNumberedReplyText, buildSendMessageBody, chunkText, extractWeChatText, parseWeChatUpdate,
+} from '../src/adapters/wechat.js';
+
+describe('extractWeChatText', () => {
+  it('提取 text_item 文本', () => {
+    expect(extractWeChatText({ from_user_id: 'u1', text_item: { text: 'hello' } })).toBe('hello');
+  });
+  it('提取 item_list 中 type===1 的文本', () => {
+    expect(extractWeChatText({ item_list: [{ type: 2, text_item: { text: 'img' } }, { type: 1, text_item: { text: 'text' } }] })).toBe('text');
+  });
+  it('无文本返回 null', () => {
+    expect(extractWeChatText({ from_user_id: 'u1' })).toBeNull();
+  });
+});
+
+describe('parseWeChatUpdate', () => {
+  it('文本消息 → NormalizedMessage（chatId=userId=from_user_id）', () => {
+    expect(parseWeChatUpdate({ from_user_id: 'wx-1', context_token: 'tok', text_item: { text: 'hi' } }))
+      .toEqual({ chatId: 'wx-1', userId: 'wx-1', text: 'hi' });
+  });
+  it('非文本或缺发送者返回 null', () => {
+    expect(parseWeChatUpdate({ from_user_id: 'wx-1', text_item: { text: '' } })).toBeNull();
+    expect(parseWeChatUpdate({ text_item: { text: 'x' } })).toBeNull();
+  });
+});
+
+describe('buildGetUpdatesBody', () => {
+  it('带同步游标与 longpolling，且必须带 base_info.channel_version', () => {
+    const body = buildGetUpdatesBody('buf-1');
+    expect(body.get_updates_buf).toBe('buf-1');
+    expect(body.longpolling_timeout).toBe(35000);
+    expect(body.base_info).toEqual({ channel_version: '1.0.2' });
+  });
+});
+
+describe('buildSendMessageBody', () => {
+  it('msg 包裹 + text_item，带回话 context_token', () => {
+    const body = buildSendMessageBody('wx-1', '回复', 'tok-1', 'client-1');
+    expect(body.base_info).toEqual({ channel_version: '1.0.2' });
+    expect(body.msg).toMatchObject({
+      from_user_id: '',
+      to_user_id: 'wx-1',
+      client_id: 'client-1',
+      message_type: 2,
+      message_state: 2,
+      context_token: 'tok-1',
+      item_list: [{ type: 1, text_item: { text: '回复' } }],
+    });
+  });
+});
+
+describe('chunkText', () => {
+  it('长文本按上限分段', () => {
+    const chunks = chunkText('a'.repeat(1700), 800);
+    expect(chunks).toHaveLength(3);
+    expect(chunks[0].length).toBe(800);
+    expect(chunks[2].length).toBe(100);
+  });
+  it('短文本单段', () => {
+    expect(chunkText('hi', 800)).toEqual(['hi']);
+  });
+});
+
+describe('buildNumberedReplyText', () => {
+  it('生成 1/2 选项文本', () => {
+    const text = buildNumberedReplyText('需要批准', [
+      { id: 'approve:r1', label: '✅ 同意' },
+      { id: 'reject:r1', label: '🚫 拒绝' },
+    ]);
+    expect(text).toContain('1) ✅ 同意');
+    expect(text).toContain('回复数字选择');
+  });
+  it('无按钮时原样返回', () => {
+    expect(buildNumberedReplyText('hi', [])).toBe('hi');
+  });
+});

package/test/commands.test.ts

@@ -21,4 +21,18 @@ describe('parseCommand', () => {
     expect(parseCommand('/task')).toBeNull(); // 缺参数
     expect(parseCommand('/cronrm')).toBeNull(); // 缺任务 id
   });
+  it('识别 /remember /recall /forget', () => {
+    expect(parseCommand('/remember 用户喜欢美式咖啡')).toEqual({ kind: 'remember', text: '用户喜欢美式咖啡' });
+    expect(parseCommand('/recall 咖啡')).toEqual({ kind: 'recall', query: '咖啡' });
+    expect(parseCommand('/recall')).toEqual({ kind: 'recall', query: '' });
+    expect(parseCommand('/forget abc123')).toEqual({ kind: 'forget', memoryId: 'abc123' });
+    expect(parseCommand('/remember')).toBeNull(); // 缺内容
+  });
+  it('识别 /remind（相对时间与定点时间）', () => {
+    expect(parseCommand('/remind in 10 分钟 喝水')).toEqual({ kind: 'remind', text: '喝水', inMinutes: 10, atTime: null });
+    expect(parseCommand('/remind in 2 小时 开会')).toEqual({ kind: 'remind', text: '开会', inMinutes: 120, atTime: null });
+    expect(parseCommand('/remind in 30 minutes 散步')).toEqual({ kind: 'remind', text: '散步', inMinutes: 30, atTime: null });
+    expect(parseCommand('/remind in 1 day 汇报')).toEqual({ kind: 'remind', text: '汇报', inMinutes: 1440, atTime: null });
+    expect(parseCommand('/remind at 14:30 开会')).toEqual({ kind: 'remind', text: '开会', inMinutes: null, atTime: '14:30' });
+  });
 });

package/test/memory.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from 'vitest';
+import { MemoryStore, formatMemories, memoryScope, searchMemories } from '../src/memory.js';
+
+describe('memoryScope', () => {
+  it('按 platform:userId 作用域（记忆跟随用户跨频道）', () => {
+    expect(memoryScope('telegram', 'u1')).toBe('telegram:u1');
+  });
+});
+
+describe('searchMemories', () => {
+  const entries = [
+    { id: '1', text: '用户喜欢喝美式咖啡', createdAt: 'x' },
+    { id: '2', text: '用户住在杭州', createdAt: 'x' },
+    { id: '3', text: '项目用 TypeScript', createdAt: 'x' },
+  ];
+  it('任一关键词命中即返回', () => {
+    expect(searchMemories(entries, '咖啡').map((e) => e.id)).toEqual(['1']);
+    expect(searchMemories(entries, '杭州 咖啡').map((e) => e.id).sort()).toEqual(['1', '2']);
+  });
+  it('无匹配返回空', () => {
+    expect(searchMemories(entries, '滑雪')).toEqual([]);
+  });
+  it('空查询返回全部', () => {
+    expect(searchMemories(entries, '')).toHaveLength(3);
+  });
+  it('大小写不敏感', () => {
+    expect(searchMemories(entries, 'typescript').map((e) => e.id)).toEqual(['3']);
+  });
+});
+
+describe('formatMemories', () => {
+  it('空列表返回空串', () => {
+    expect(formatMemories([])).toBe('');
+  });
+  it('渲染注入块', () => {
+    const text = formatMemories([{ id: '1', text: '用户住在杭州', createdAt: 'x' }]);
+    expect(text).toContain('📌 相关记忆');
+    expect(text).toContain('用户住在杭州');
+  });
+});
+
+describe('MemoryStore（内存模式）', () => {
+  it('add / list / search / remove 全流程', () => {
+    const store = new MemoryStore(); // 无文件 = 纯内存
+    const entry = store.add('telegram:u1', '用户喜欢喝美式咖啡');
+    expect(store.count('telegram:u1')).toBe(1);
+    expect(store.list('telegram:u1')[0].text).toBe('用户喜欢喝美式咖啡');
+    expect(store.search('telegram:u1', '咖啡')).toHaveLength(1);
+    expect(store.remove('telegram:u1', entry.id)).toBe(true);
+    expect(store.count('telegram:u1')).toBe(0);
+    expect(store.remove('telegram:u1', entry.id)).toBe(false);
+  });
+  it('不同作用域隔离', () => {
+    const store = new MemoryStore();
+    store.add('telegram:u1', 'A 的记忆');
+    store.add('whatsapp:u1', 'B 的记忆');
+    expect(store.list('telegram:u1')).toHaveLength(1);
+    expect(store.list('whatsapp:u1')).toHaveLength(1);
+  });
+});

package/test/multi.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it } from 'vitest';
-import { wireAdapter } from '../src/index.js';
+import { remindSchedule, wireAdapter } from '../src/index.js';
 import { GatewayClient } from '@dsh-overdrive/sdk';
+import { MemoryStore } from '../src/memory.js';
 import type { Adapter, NormalizedMessage, OutboundPayload, ReplySender } from '../src/adapter.js';
 
 /** 可编程 FakeAdapter：验证 wiring 逻辑（白名单/会话键/错误兜底）。 */
@@ -104,4 +105,51 @@ describe('wireAdapter（多适配器装配核心）', () => {
     await adapter.emit({ chatId: 'C1', userId: 'U1', text: 'hi' });
     expect(adapter.sent[0].payload.text).toContain('❌');
   });
+
+  it('相关记忆自动注入到发给 agent 的文本（OpenClaw 式）', async () => {
+    const adapter = new FakeAdapter('telegram');
+    const { client, messages } = fakeClient();
+    const memory = new MemoryStore();
+    memory.add('telegram:222', '用户喜欢美式咖啡');
+    await wireAdapter(adapter, client, { allowlist: ['telegram:111:222'], memory });
+
+    await adapter.emit({ chatId: '111', userId: '222', text: '帮我点一杯咖啡' });
+    expect(messages[0].text).toContain('帮我点一杯咖啡');
+    expect(messages[0].text).toContain('📌 相关记忆');
+    expect(messages[0].text).toContain('用户喜欢美式咖啡');
+  });
+
+  it('无相关记忆时不注入', async () => {
+    const adapter = new FakeAdapter('telegram');
+    const { client, messages } = fakeClient();
+    const memory = new MemoryStore();
+    memory.add('telegram:222', '用户喜欢美式咖啡');
+    await wireAdapter(adapter, client, { allowlist: ['telegram:111:222'], memory });
+
+    await adapter.emit({ chatId: '111', userId: '222', text: '今天天气如何' });
+    expect(messages[0].text).toBe('今天天气如何');
+  });
+
+  it('/remember 命令写入记忆并回执', async () => {
+    const adapter = new FakeAdapter('telegram');
+    const { client } = fakeClient();
+    const memory = new MemoryStore();
+    await wireAdapter(adapter, client, { allowlist: ['telegram:111:222'], memory });
+
+    await adapter.emit({ chatId: '111', userId: '222', text: '/remember 用户住在杭州' });
+    expect(memory.count('telegram:222')).toBe(1);
+    expect(adapter.sent[0].payload.text).toContain('已记住');
+  });
+});
+
+describe('remindSchedule', () => {
+  it('相对分钟 → cron 5 字段', () => {
+    const now = new Date('2026-08-20T10:05:00');
+    expect(remindSchedule(10, null, now)).toBe('15 10 20 8 *');
+  });
+  it('定点时间 → cron；已过则推到明天', () => {
+    const now = new Date('2026-08-20T10:05:00');
+    expect(remindSchedule(0, '14:30', now)).toBe('30 14 20 8 *');
+    expect(remindSchedule(0, '09:00', now)).toBe('0 9 21 8 *');
+  });
 });