metona-ai-desktop/electron/services/__tests__/session-summary.test.ts

/**
 * SessionSummaryService + truncateMessagesAfter 交互回归测试
 *
 * 覆盖全量复检 #1 修复：消息截断必须同步清理 session_summaries 摘要游标，
 * 否则 (1) afterRowid 过滤返回空 tail 导致截断点前原文永不加载；
 * (2) 摘要包含被撤销的"未来"内容（因果污染）。
 *
 * 运行要求：better-sqlite3 为 Electron ABI 构建，需 test:electron 模式
 * （cross-env ELECTRON_RUN_AS_NODE=1 electron ...）执行；系统 Node 下自动跳过。
 */

import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';

vi.mock('electron-log', () => ({
  default: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
}));

import { mkdtempSync, rmSync } from 'fs';
import { tmpdir } from 'os';
import { join } from 'path';

let dbAvailable = true;
let Database: typeof import('better-sqlite3');
try {
  // eslint-disable-next-line @typescript-eslint/no-require-imports
  Database = require('better-sqlite3');
  const probe = new Database(':memory:');
  probe.close();
} catch {
  dbAvailable = false;
}

describe.skipIf(!dbAvailable)('SessionSummary 分层上下文 × 截断交互', () => {
  let db: any;
  let dir: string;
  let sessionService: any;
  let summaryService: any;

  const insertMessage = (sessionId: string, id: string, role: string, content: string): void => {
    db.prepare(
      `INSERT INTO messages (id, session_id, role, content, created_at) VALUES (?, ?, ?, ?, ?)`,
    ).run(id, sessionId, role, content, Date.now());
  };

  beforeAll(async () => {
    const { SessionService } = await import('../session.service');
    const { SessionSummaryService } = await import('../session-summary.service');
    dir = mkdtempSync(join(tmpdir(), 'metona-summary-'));
    db = new Database(':memory:');
    db.exec(`
      CREATE TABLE sessions (
        id TEXT PRIMARY KEY,
        title TEXT DEFAULT '新会话',
        created_at INTEGER NOT NULL,
        updated_at INTEGER NOT NULL,
        message_count INTEGER DEFAULT 0,
        pinned INTEGER DEFAULT 0,
        archived INTEGER DEFAULT 0,
        metadata TEXT DEFAULT '{}'
      );
      CREATE TABLE messages (
        id TEXT PRIMARY KEY,
        session_id TEXT NOT NULL,
        role TEXT NOT NULL,
        content TEXT,
        reasoning_content TEXT,
        tool_calls TEXT,
        tool_result TEXT,
        attachments TEXT,
        iteration INTEGER,
        created_at INTEGER NOT NULL
      );
      CREATE TABLE session_summaries (
        session_id TEXT PRIMARY KEY,
        summary TEXT NOT NULL,
        summarized_until_rowid INTEGER NOT NULL,
        updated_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
      );
    `);
    db.prepare(
      'INSERT INTO sessions (id, created_at, updated_at, message_count) VALUES (?, ?, ?, ?)',
    ).run('s_test', Date.now(), Date.now(), 0);

    sessionService = new SessionService(() => db);
    summaryService = new SessionSummaryService(
      () => db,
      sessionService,
      // buildHistoryMessages 不触 adapter（仅 maybeSummarize 用），占位即可
      () => null as unknown as Parameters<typeof Object>[0],
    );
  });

  afterAll(() => {
    try {
      db?.close();
    } catch {
      /* ignore */
    }
    rmSync(dir, { recursive: true, force: true });
  });

  it('分层加载：摘要存在时返回 [摘要消息, 游标之后的原文]', () => {
    // 5 条消息，摘要覆盖到第 3 条（rowid 3）
    for (let i = 1; i <= 5; i++) {
      insertMessage('s_test', `m${i}`, i % 2 === 1 ? 'user' : 'assistant', `消息 ${i}`);
    }
    summaryService.saveSummary('s_test', '早期对话的滚动摘要', 3);

    const history = summaryService.buildHistoryMessages('s_test');
    // 1 条摘要 + rowid 4、5 两条原文
    expect(history.length).toBe(3);
    expect((history[0].content as string).startsWith('[Context Summary]')).toBe(true);
    expect(history[1].content).toBe('消息 4');
    expect(history[2].content).toBe('消息 5');
  });

  it('其他会话的摘要不影响本会话（游标按 session_id 隔离）', () => {
    // s_other 的摘要不应影响 s_test 的分层加载结果
    summaryService.saveSummary('s_other', 'x', 0);
    const history = summaryService.buildHistoryMessages('s_test');
    // s_test 摘要（游标 3）仍生效：摘要 + rowid 4、5
    expect(history.length).toBe(3);
  });

  // ===== v0.5.4: 多轮图片记忆用例置于 describe 末尾（插入新行消耗全局自增 rowid，
  // 若插在中间会破坏 inclusive=false 用例对 rowid 数值的断言） =====

  it('截断清理摘要（缺陷 #1 回归）：游标落在删除范围内时摘要被删', () => {
    // 编辑重发第 2 条消息（rowid 2，inclusive）→ 删除 rowid>=2 的 4 条
    // 摘要游标为 3，落在 [2, ∞) 内 → 摘要必须被清理
    const truncated = sessionService.truncateMessagesAfter('s_test', 'm2', true);
    expect(truncated).toBe(true);

    // 摘要已删除
    expect(summaryService.getSummary('s_test')).toBeNull();
    // 只剩 rowid 1 的消息
    const remaining = sessionService.getMessages('s_test');
    expect(remaining.length).toBe(1);
    expect(remaining[0].content).toBe('消息 1');
    // 分层加载退化为全量原文（无摘要注入）
    const history = summaryService.buildHistoryMessages('s_test');
    expect(history.length).toBe(1);
    expect(history[0].content).toBe('消息 1');
  });

  it('inclusive=false：游标等于锚点时摘要保留（语义仍一致）', () => {
    // 重建场景：rowid 1（消息1）+ 新插入 3 条 → rowid 2-4；摘要游标 = 2
    insertMessage('s_test', 'm2b', 'user', '消息 2b');
    insertMessage('s_test', 'm3b', 'assistant', '消息 3b');
    insertMessage('s_test', 'm4b', 'user', '消息 4b');
    summaryService.saveSummary('s_test', '摘要到 rowid2', 2);

    // 截断 rowid > 3（保留锚点 3）：游标 2 < 3+1 → 摘要保留
    const truncated = sessionService.truncateMessagesAfter('s_test', 'm3b', false);
    expect(truncated).toBe(true);
    expect(summaryService.getSummary('s_test')).not.toBeNull();

    // 分层加载：摘要 + rowid 3 原文（rowid 4 已删）
    const history = summaryService.buildHistoryMessages('s_test');
    expect(history.length).toBe(2);
    expect(history[1].content).toBe('消息 3b');
  });

  it('锚点消息不存在时返回 false 且不产生副作用', () => {
    const before = sessionService.getMessages('s_test').length;
    expect(sessionService.truncateMessagesAfter('s_test', 'not_exist', true)).toBe(false);
    expect(sessionService.getMessages('s_test').length).toBe(before);
  });

  /** 插入带 attachments 的用户消息（模拟 ChatInput 持久化形态） */
  const insertMessageWithAttachments = (
    sessionId: string,
    id: string,
    content: string,
    attachments: Array<{ type: string; preview?: string; textContent?: string }>,
  ): void => {
    db.prepare(
      `INSERT INTO messages (id, session_id, role, content, attachments, created_at) VALUES (?, ?, 'user', ?, ?, ?)`,
    ).run(id, sessionId, content, JSON.stringify(attachments), Date.now());
  };

  it('多轮图片记忆：历史消息的图片 attachments 恢复为 images 回传', () => {
    db.prepare(`DELETE FROM messages WHERE session_id = 's_img'`).run();
    db.prepare(
      `INSERT INTO sessions (id, created_at, updated_at, message_count) VALUES ('s_img', ?, ?, 0)`,
    ).run(Date.now(), Date.now());

    insertMessageWithAttachments('s_img', 'img_m1', '第一轮带图', [
      { type: 'image', preview: 'data:image/jpeg;base64,ROUND1PIC' },
    ]);
    insertMessageWithAttachments('s_img', 'img_m2', '第二轮无图', []);
    insertMessageWithAttachments('s_img', 'img_m3', '第三轮带图', [
      { type: 'image', preview: 'data:image/jpeg;base64,ROUND3PIC' },
      { type: 'text', textContent: '文本附件不恢复为图片' },
    ]);

    const history = summaryService.buildHistoryMessages('s_img');
    // 第一轮的图片仍被恢复（多轮记忆修复点：此前历史消息 images 恒为 undefined）
    const round1 = history.find((m: any) => m.content === '第一轮带图');
    expect(round1?.images).toEqual([{ url: 'data:image/jpeg;base64,ROUND1PIC', detail: 'auto' }]);
    // 第三轮两张附件只恢复 image 类型
    const round3 = history.find((m: any) => m.content === '第三轮带图');
    expect(round3?.images).toEqual([{ url: 'data:image/jpeg;base64,ROUND3PIC', detail: 'auto' }]);
    // 无图消息不带 images 字段
    const round2 = history.find((m: any) => m.content === '第二轮无图');
    expect(round2?.images).toBeUndefined();
  });

  it('多轮图片记忆：注入上限 10 张（从最新向前收集，更早的丢弃）', () => {
    db.prepare(`DELETE FROM messages WHERE session_id = 's_cap'`).run();
    db.prepare(
      `INSERT INTO sessions (id, created_at, updated_at, message_count) VALUES ('s_cap', ?, ?, 0)`,
    ).run(Date.now(), Date.now());

    // 12 条带图消息（每条 1 张）— 上限 10 张，最早的 2 条不注入
    for (let i = 1; i <= 12; i++) {
      insertMessageWithAttachments('s_cap', `cap_m${i}`, `第 ${i} 轮`, [
        { type: 'image', preview: `data:image/jpeg;base64,PIC${i}` },
      ]);
    }

    const history = summaryService.buildHistoryMessages('s_cap');
    const withImages = history.filter((m: any) => m.images?.length > 0);
    expect(withImages).toHaveLength(10);
    // 保留的是第 3~12 轮（最新的 10 张）
    const contents = withImages.map((m: any) => m.content);
    expect(contents).not.toContain('第 1 轮');
    expect(contents).not.toContain('第 2 轮');
    expect(contents).toContain('第 12 轮');
  });

  it('多轮图片记忆：摘要区间内的图片不恢复（符合滚动摘要语义）', () => {
    db.prepare(`DELETE FROM messages WHERE session_id = 's_sum_img'`).run();
    db.prepare(
      `INSERT INTO sessions (id, created_at, updated_at, message_count) VALUES ('s_sum_img', ?, ?, 0)`,
    ).run(Date.now(), Date.now());

    for (let i = 1; i <= 3; i++) {
      insertMessageWithAttachments('s_sum_img', `sm${i}`, `摘要区间第 ${i} 条`, [
        { type: 'image', preview: `data:image/jpeg;base64,OLDPIC${i}` },
      ]);
    }
    // 摘要覆盖前 3 条（含全部图片消息）
    const cursor = (
      db.prepare(`SELECT MAX(rowid) AS r FROM messages WHERE session_id = 's_sum_img'`).get() as {
        r: number;
      }
    ).r;
    summaryService.saveSummary('s_sum_img', '早期含图对话的摘要', cursor);
    insertMessageWithAttachments('s_sum_img', 'sm4', '摘要后的新消息（无图）', []);

    const history = summaryService.buildHistoryMessages('s_sum_img');
    // 摘要消息 + 1 条原文，均无图片（游标前的图片消息不在 tail 中）
    expect(history).toHaveLength(2);
    expect(history.every((m: any) => !m.images?.length)).toBe(true);
  });
});

/**
 * B-2 回归：clearMessages 必须同步删除滚动摘要
 *
 * 缺陷根因（v0.6.4 审计）：messages 使用隐式 rowid，非 AUTOINCREMENT 表全表
 * DELETE 后新消息的 rowid 从 1 重新分配。若清空消息时保留 session_summaries
 * 的 summarized_until_rowid 游标（如 =500），则：
 *   (1) buildHistoryMessages 的 `rowid > 500` 过滤令所有新消息落空 →
 *       新对话永远不进入 LLM 历史（直到重新攒满 500 条）；
 *   (2) maybeSummarize 的 `rowid > lastSummarized` 增量判定长期误报"无增量"。
 */
describe.skipIf(!dbAvailable)('clearMessages × 摘要游标交互（B-2）', () => {
  let db: any;
  let sessionService: any;
  let summaryService: any;

  beforeAll(async () => {
    const { SessionService } = await import('../session.service');
    const { SessionSummaryService } = await import('../session-summary.service');
    db = new Database(':memory:');
    db.exec(`
      CREATE TABLE sessions (
        id TEXT PRIMARY KEY,
        title TEXT DEFAULT '新会话',
        created_at INTEGER NOT NULL,
        updated_at INTEGER NOT NULL,
        message_count INTEGER DEFAULT 0,
        pinned INTEGER DEFAULT 0,
        archived INTEGER DEFAULT 0,
        metadata TEXT DEFAULT '{}'
      );
      CREATE TABLE messages (
        id TEXT PRIMARY KEY,
        session_id TEXT NOT NULL,
        role TEXT NOT NULL,
        content TEXT,
        reasoning_content TEXT,
        tool_calls TEXT,
        tool_result TEXT,
        attachments TEXT,
        iteration INTEGER,
        created_at INTEGER NOT NULL
      );
      CREATE TABLE session_summaries (
        session_id TEXT PRIMARY KEY,
        summary TEXT NOT NULL,
        summarized_until_rowid INTEGER NOT NULL,
        updated_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
      );
    `);
    db.prepare(
      'INSERT INTO sessions (id, created_at, updated_at, message_count) VALUES (?, ?, ?, ?)',
    ).run('s_clear', Date.now(), Date.now(), 0);

    sessionService = new SessionService(() => db);
    summaryService = new SessionSummaryService(
      () => db,
      sessionService,
      () => null as unknown as Parameters<typeof Object>[0],
    );
  });

  afterAll(() => {
    try {
      db?.close();
    } catch {
      /* ignore */
    }
  });

  it('清空消息后摘要与游标一并清除；rowid 重分配后新对话正常进入历史', () => {
    const ins = (id: string, content: string): void => {
      db.prepare(
        `INSERT INTO messages (id, session_id, role, content, created_at) VALUES (?, ?, 'user', ?, ?)`,
      ).run(id, 's_clear', content, Date.now());
    };

    // 阶段一：5 条历史 + 摘要游标远超当前 rowid（模拟旧会话曾积累大量已摘要消息：
    // 用户在长会话里攒到 summarized_until_rowid=500 后执行"清空消息"）
    for (let i = 1; i <= 5; i++) ins(`old_m${i}`, `旧消息 ${i}`);
    const maxRowIdBefore = (
      db.prepare(`SELECT MAX(rowid) AS r FROM messages WHERE session_id='s_clear'`).get() as { r: number }
    ).r;
    expect(maxRowIdBefore).toBe(5);
    summaryService.saveSummary('s_clear', '覆盖全部旧消息的摘要', 500);

    // 复现缺陷前提（且暴露缺陷真实严重度）：rowid=6 < 游标 500，
    // 新消息全部被 `rowid > 500` 过滤落空；而摘要注入又要求"存在 tail"才生效
    // （buildHistoryMessages: existing && messages.length > 0）—— 结果历史恒为空：
    // 该会话从此刻起 LLM 完全失忆，直到新消息 rowid 涨过 500。
    ins('transition_m', '过渡期新消息');
    expect(summaryService.buildHistoryMessages('s_clear').length).toBe(0);

    // 阶段二：用户点击"清空消息"
    expect(sessionService.clearMessages('s_clear')).toBe(true);
    expect(sessionService.getMessages('s_clear')).toHaveLength(0);

    // 核心契约 1：摘要记录被同步删除（原实现此处残留 cursor=5）
    expect(summaryService.getSummary('s_clear')).toBeNull();

    // 核心契约 2：全表 DELETE 后 rowid 从 1 重排（SQLite 非 AUTOINCREMENT 行为），
    // 若摘要未删，这些 rowid=1..n 的新消息将永远过不了 `rowid > 500` 过滤。
    for (let i = 1; i <= 2; i++) ins(`new_m${i}`, `新对话 ${i}`);
    const historyAfterClear = summaryService.buildHistoryMessages('s_clear');
    expect(historyAfterClear).toHaveLength(2);
    expect(historyAfterClear[0].content).toBe('新对话 1');
    expect(historyAfterClear[1].content).toBe('新对话 2');
  });
});

/**
 * F-3 回归：session_summaries 级联删除
 *
 * 缺陷：该表此前无 FOREIGN KEY ON DELETE CASCADE —— 删除会话后摘要残留。
 * 迁移 8 重建表补级联；此测试验证目标 schema 的行为契约：
 * DELETE sessions 必须级联清除对应摘要（真实库由 DatabaseService 开启 foreign_keys pragma）。
 */
describe.skipIf(!dbAvailable)('session_summaries 级联删除（F-3）', () => {
  let db: any;

  beforeAll(() => {
    db = new Database(':memory:');
    // 与 DatabaseService.initialize 一致：开启外键约束（级联依赖此开关）
    db.pragma('foreign_keys = ON');
    db.exec(`
      CREATE TABLE sessions (
        id TEXT PRIMARY KEY,
        title TEXT DEFAULT '新会话',
        created_at INTEGER NOT NULL,
        updated_at INTEGER NOT NULL,
        message_count INTEGER DEFAULT 0,
        pinned INTEGER DEFAULT 0,
        archived INTEGER DEFAULT 0,
        metadata TEXT DEFAULT '{}'
      );
      CREATE TABLE session_summaries (
        session_id              TEXT PRIMARY KEY,
        summary                 TEXT NOT NULL,
        summarized_until_rowid  INTEGER NOT NULL,
        updated_at              INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
        FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
      );
    `);
  });

  afterAll(() => {
    db?.close();
  });

  it('外键声明存在且为 CASCADE（迁移 8 后的目标 schema）', () => {
    const fks = db.prepare('PRAGMA foreign_key_list(session_summaries)').all() as Array<{
      table: string;
      on_delete: string;
    }>;
    expect(fks.some((fk) => fk.table === 'sessions' && fk.on_delete === 'CASCADE')).toBe(true);
  });

  it('删除会话后摘要级联清除（不再残留孤儿数据）', () => {
    const now = Date.now();
    db.prepare(`INSERT INTO sessions (id, created_at, updated_at) VALUES ('s_cascade', ?, ?)`).run(
      now,
      now,
    );
    db.prepare(
      `INSERT INTO session_summaries (session_id, summary, summarized_until_rowid, updated_at)
       VALUES ('s_cascade', '将被级联删除的摘要', 99, ?)`,
    ).run(now);
    db.prepare(`INSERT INTO sessions (id, created_at, updated_at) VALUES ('s_keep', ?, ?)`).run(
      now,
      now,
    );
    db.prepare(
      `INSERT INTO session_summaries (session_id, summary, summarized_until_rowid, updated_at)
       VALUES ('s_keep', '保留的摘要', 50, ?)`,
    ).run(now);

    db.prepare(`DELETE FROM sessions WHERE id = 's_cascade'`).run();

    const remaining = db.prepare(`SELECT session_id FROM session_summaries`).all() as Array<{
      session_id: string;
    }>;
    expect(remaining.map((r) => r.session_id)).toEqual(['s_keep']);
  });
});