bingocode 1.0.41 → 1.1.42

package/adapters/feishu/__tests__/flush-controller.test.ts

@@ -1,290 +0,0 @@
-/**
- * FlushController 单元测试
- *
- * 覆盖:
- * - 基础: cardMessageReady gate, complete() 锁死
- * - 节流窗口: 立即 flush / 延迟 flush
- * - Mutex: 进行中的 flush 重复调用标记 needsReflush
- * - Conflict reflush: API 结束后自动补一次
- * - 长间隔批量: elapsed > 2000ms 后延迟 300ms 再 flush
- * - waitForFlush: 等当前 flush 结束
- */
-
-import { describe, it, expect } from 'bun:test'
-import { FlushController, THROTTLE } from '../flush-controller.js'
-
-// 创建一个可控的 doFlush —— 返回一个 Promise 可以手动 resolve
-function makeControllableFlush() {
-  const calls: string[] = []
-  let resolveCurrent: (() => void) | null = null
-  let latch: Promise<void> | null = null
-
-  const doFlush = async () => {
-    calls.push('flush-start')
-    if (latch) {
-      await latch
-      latch = null
-    }
-    calls.push('flush-end')
-  }
-
-  const blockNext = () => {
-    latch = new Promise<void>((resolve) => {
-      resolveCurrent = resolve
-    })
-  }
-
-  const unblock = () => {
-    if (resolveCurrent) {
-      const r = resolveCurrent
-      resolveCurrent = null
-      r()
-    }
-  }
-
-  return { doFlush, calls, blockNext, unblock }
-}
-
-async function sleep(ms: number): Promise<void> {
-  await new Promise((r) => setTimeout(r, ms))
-}
-
-// ---------------------------------------------------------------------------
-// Basic gating
-// ---------------------------------------------------------------------------
-
-describe('FlushController: cardMessageReady gate', () => {
-  it('在 cardMessageReady=false 时不 flush', async () => {
-    let count = 0
-    const fc = new FlushController(async () => {
-      count += 1
-    })
-    await fc.flush()
-    await fc.throttledUpdate(50)
-    expect(count).toBe(0)
-  })
-
-  it('setCardMessageReady(true) 后 flush 可执行', async () => {
-    let count = 0
-    const fc = new FlushController(async () => {
-      count += 1
-    })
-    fc.setCardMessageReady(true)
-    await fc.flush()
-    expect(count).toBe(1)
-  })
-
-  it('setCardMessageReady(true) 同步初始化 lastUpdateTime —— 刚 ready 时 throttledUpdate 被节流窗口阻挡', async () => {
-    let count = 0
-    const fc = new FlushController(async () => {
-      count += 1
-    })
-    fc.setCardMessageReady(true)
-    // 立即调用 throttledUpdate 500ms 窗口，首次 elapsed≈0 → 进入延迟分支
-    await fc.throttledUpdate(500)
-    // 同步阶段还没到 500ms，不应触发 flush
-    expect(count).toBe(0)
-    // 500+ms 后延迟 timer 触发
-    await sleep(600)
-    expect(count).toBe(1)
-  })
-})
-
-describe('FlushController: complete()', () => {
-  it('complete() 后拒绝新 flush', async () => {
-    let count = 0
-    const fc = new FlushController(async () => {
-      count += 1
-    })
-    fc.setCardMessageReady(true)
-    fc.complete()
-    await fc.flush()
-    await fc.throttledUpdate(50)
-    expect(count).toBe(0)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Throttle window
-// ---------------------------------------------------------------------------
-
-describe('FlushController: 节流窗口', () => {
-  it('超过窗口立即 flush', async () => {
-    let count = 0
-    const fc = new FlushController(async () => {
-      count += 1
-    })
-    fc.setCardMessageReady(true)
-    // 手动把 lastUpdateTime 挪远（等同于已过了节流窗口）
-    await sleep(150)
-    await fc.throttledUpdate(100)
-    expect(count).toBe(1)
-  })
-
-  it('在窗口内首次调用安排延迟 flush', async () => {
-    let count = 0
-    const fc = new FlushController(async () => {
-      count += 1
-    })
-    fc.setCardMessageReady(true) // lastUpdateTime = now
-
-    await fc.throttledUpdate(200)
-    expect(count).toBe(0) // 延迟中，还没触发
-
-    await sleep(300)
-    expect(count).toBe(1) // 200ms 后延迟 timer 触发
-  })
-
-  it('窗口内多次调用复用同一个延迟 timer（不重复 flush）', async () => {
-    let count = 0
-    const fc = new FlushController(async () => {
-      count += 1
-    })
-    fc.setCardMessageReady(true)
-
-    await fc.throttledUpdate(200)
-    await fc.throttledUpdate(200)
-    await fc.throttledUpdate(200)
-    await fc.throttledUpdate(200)
-
-    await sleep(300)
-    expect(count).toBe(1)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Mutex + conflict reflush
-// ---------------------------------------------------------------------------
-
-describe('FlushController: mutex + 冲突重刷', () => {
-  it('flush 进行中的重复调用不并发执行', async () => {
-    const { doFlush, calls, blockNext, unblock } = makeControllableFlush()
-    const fc = new FlushController(doFlush)
-    fc.setCardMessageReady(true)
-
-    blockNext()
-    const p1 = fc.flush() // flush-start 后被 latch 卡住
-    // 让事件循环走一轮，确保第一次 flush 进入 body
-    await sleep(10)
-    // 第二次调用时第一次还没结束 —— 应被 mutex 挡住
-    const p2 = fc.flush()
-
-    // 两次 Promise 都已登记，但都还没 end
-    expect(calls).toEqual(['flush-start'])
-
-    unblock()
-    await p1
-    await p2
-    // 第一次跑完后，由于 needsReflush 被标记，会触发一次补刷
-    // （conflict reflush 是通过 setTimeout 0 调度的，需要让它跑完）
-    await sleep(20)
-
-    // 第一次 flush-start + flush-end，然后冲突补刷再一次 start + end
-    expect(calls).toEqual([
-      'flush-start', 'flush-end',
-      'flush-start', 'flush-end',
-    ])
-  })
-
-  it('flush 进行中的 throttledUpdate 也会触发补刷', async () => {
-    const { doFlush, calls, blockNext, unblock } = makeControllableFlush()
-    const fc = new FlushController(doFlush)
-    fc.setCardMessageReady(true)
-
-    blockNext()
-    const p1 = fc.flush()
-    await sleep(10)
-
-    // API 进行中收到新的 update 请求
-    await fc.throttledUpdate(10)
-
-    unblock()
-    await p1
-    await sleep(30)
-
-    // 第一次 flush + 冲突补刷
-    expect(calls.filter((c) => c === 'flush-end').length).toBe(2)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Long gap batching
-// ---------------------------------------------------------------------------
-
-describe('FlushController: 长间隔批量', () => {
-  it('elapsed > LONG_GAP_THRESHOLD_MS 时延迟 BATCH_AFTER_GAP_MS 再 flush', async () => {
-    let count = 0
-    let flushAtMs = 0
-    const start = Date.now()
-    const fc = new FlushController(async () => {
-      count += 1
-      flushAtMs = Date.now() - start
-    })
-    fc.setCardMessageReady(true)
-
-    // 等到 elapsed > 2000ms
-    await sleep(THROTTLE.LONG_GAP_THRESHOLD_MS + 50)
-    const callAt = Date.now() - start
-
-    await fc.throttledUpdate(THROTTLE.CARDKIT_MS)
-    // throttledUpdate 同步阶段不应立即 flush（因为走批量分支）
-    expect(count).toBe(0)
-
-    // 等 BATCH_AFTER_GAP_MS + 余量
-    await sleep(THROTTLE.BATCH_AFTER_GAP_MS + 50)
-    expect(count).toBe(1)
-    // 实际 flush 时刻至少比 throttledUpdate 调用晚 300ms
-    expect(flushAtMs - callAt).toBeGreaterThanOrEqual(THROTTLE.BATCH_AFTER_GAP_MS - 20)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// waitForFlush
-// ---------------------------------------------------------------------------
-
-describe('FlushController: waitForFlush', () => {
-  it('没在 flush 时立即返回', async () => {
-    const fc = new FlushController(async () => {})
-    fc.setCardMessageReady(true)
-    const start = Date.now()
-    await fc.waitForFlush()
-    expect(Date.now() - start).toBeLessThan(10)
-  })
-
-  it('有 flush 在跑时等它结束', async () => {
-    const { doFlush, blockNext, unblock } = makeControllableFlush()
-    const fc = new FlushController(doFlush)
-    fc.setCardMessageReady(true)
-
-    blockNext()
-    const p1 = fc.flush()
-    await sleep(10)
-
-    let resolved = false
-    const waiter = fc.waitForFlush().then(() => {
-      resolved = true
-    })
-    await sleep(20)
-    expect(resolved).toBe(false)
-
-    unblock()
-    await p1
-    await waiter
-    expect(resolved).toBe(true)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// 常量合理性
-// ---------------------------------------------------------------------------
-
-describe('FlushController: THROTTLE 常量', () => {
-  it('CARDKIT_MS=100, PATCH_MS=1500', () => {
-    expect(THROTTLE.CARDKIT_MS).toBe(100)
-    expect(THROTTLE.PATCH_MS).toBe(1500)
-  })
-  it('LONG_GAP_THRESHOLD_MS=2000, BATCH_AFTER_GAP_MS=300', () => {
-    expect(THROTTLE.LONG_GAP_THRESHOLD_MS).toBe(2000)
-    expect(THROTTLE.BATCH_AFTER_GAP_MS).toBe(300)
-  })
-})

package/adapters/feishu/__tests__/markdown-style.test.ts

@@ -1,353 +0,0 @@
-/**
- * markdown-style 单元测试
- *
- * 覆盖:
- * - 标题降级 (H1~H3 workaround)
- * - 代码块保护
- * - 空行压缩
- * - Schema 2.0: 连续标题/表格/代码块 <br> 间距
- * - stripInvalidImageKeys
- * - sanitizeTextForCard (表格数限制)
- * - findMarkdownTablesOutsideCodeBlocks
- */
-
-import { describe, it, expect } from 'bun:test'
-import {
-  optimizeMarkdownForFeishu,
-  sanitizeTextForCard,
-  findMarkdownTablesOutsideCodeBlocks,
-  FEISHU_CARD_TABLE_LIMIT,
-} from '../markdown-style.js'
-
-// 默认 cardVersion=2 的 shortcut
-const opt = (text: string, v?: number) => optimizeMarkdownForFeishu(text, v)
-
-// ---------------------------------------------------------------------------
-// 标题降级
-// ---------------------------------------------------------------------------
-
-describe('optimizeMarkdownForFeishu: 标题降级', () => {
-  it('H1 → H4 (cardVersion=1 简化检查)', () => {
-    expect(opt('# Title', 1)).toBe('#### Title')
-  })
-
-  it('H2 → H5 (cardVersion=1)', () => {
-    expect(opt('## Title', 1)).toBe('##### Title')
-  })
-
-  it('H3 → H5 (cardVersion=1)', () => {
-    expect(opt('### Title', 1)).toBe('##### Title')
-  })
-
-  it('混合 H1+H2+H3 全部降级 (cardVersion=1)', () => {
-    expect(opt('# H1\n## H2\n### H3', 1)).toBe('#### H1\n##### H2\n##### H3')
-  })
-
-  it('纯 H4 文档不触发降级 (cardVersion=1)', () => {
-    // 触发条件: 原文必须有 H1~H3
-    expect(opt('#### Already H4', 1)).toBe('#### Already H4')
-  })
-
-  it('同时存在 H1 和 H4: H1→H4, 原 H4 → H5 (cardVersion=1)', () => {
-    expect(opt('# Top\n#### Sub', 1)).toBe('#### Top\n##### Sub')
-  })
-
-  it('# 后必须有空格才算标题', () => {
-    expect(opt('#notaheading', 1)).toBe('#notaheading')
-  })
-
-  it('顺序保证: # 降成 #### 后不会被 #{2,6} 再次吃成 #####', () => {
-    // openclaw-lark 源码里的关键注释：顺序不能颠倒
-    expect(opt('# Top', 1)).toBe('#### Top')
-  })
-
-  it('无标题文本原样返回', () => {
-    expect(opt('just plain text', 1)).toBe('just plain text')
-  })
-
-  it('默认 cardVersion=2 下也能正确降级标题', () => {
-    const out = opt('# Title')
-    expect(out).toContain('#### Title')
-    expect(out).not.toMatch(/^# Title$/m)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// 代码块保护
-// ---------------------------------------------------------------------------
-
-describe('optimizeMarkdownForFeishu: 代码块保护', () => {
-  it('代码块内的 # 不被降级 (cardVersion=1)', () => {
-    const input = '```\n# not a heading\n## also not\n```'
-    expect(opt(input, 1)).toBe(input)
-  })
-
-  it('外部 H1 降级，代码块内 # 保持 (cardVersion=1)', () => {
-    const input = '# Real heading\n\n```\n# inside code\n```'
-    expect(opt(input, 1)).toBe('#### Real heading\n\n```\n# inside code\n```')
-  })
-
-  it('语言标记的 fenced 代码块也受保护 (cardVersion=1)', () => {
-    const input = '## Section\n\n```python\n# python comment\n### not a heading\n```'
-    expect(opt(input, 1)).toBe('##### Section\n\n```python\n# python comment\n### not a heading\n```')
-  })
-
-  it('多个代码块按顺序保护与还原 (cardVersion=1)', () => {
-    const input = '# A\n```\n# b1\n```\n## C\n```\n### b2\n```'
-    expect(opt(input, 1)).toBe('#### A\n```\n# b1\n```\n##### C\n```\n### b2\n```')
-  })
-
-  it('默认 cardVersion=2 下代码块内 # 仍受保护（语义断言）', () => {
-    const out = opt('# Heading\n\n```\n# inside\n```')
-    expect(out).toContain('#### Heading') // 外部 H1 降级
-    expect(out).toContain('# inside') // 代码块内保留
-    expect(out).toContain('```') // fence 保留
-  })
-})
-
-// ---------------------------------------------------------------------------
-// 空行压缩
-// ---------------------------------------------------------------------------
-
-describe('optimizeMarkdownForFeishu: 空行压缩', () => {
-  it('3 个换行 → 2 个 (cardVersion=1)', () => {
-    expect(opt('line1\n\n\nline2', 1)).toBe('line1\n\nline2')
-  })
-
-  it('5 个换行 → 2 个 (cardVersion=1)', () => {
-    expect(opt('line1\n\n\n\n\nline2', 1)).toBe('line1\n\nline2')
-  })
-
-  it('2 个换行保留 (cardVersion=1)', () => {
-    expect(opt('line1\n\nline2', 1)).toBe('line1\n\nline2')
-  })
-
-  it('代码块内部连续换行被保留 (cardVersion=1)', () => {
-    const input = '# Title\n\n```\nline1\n\n\nline2\n```'
-    expect(opt(input, 1)).toBe('#### Title\n\n```\nline1\n\n\nline2\n```')
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Schema 2.0: <br> 间距
-// ---------------------------------------------------------------------------
-
-describe('optimizeMarkdownForFeishu: Schema 2.0 <br> 间距', () => {
-  it('cardVersion=2 默认在代码块前后加 <br>', () => {
-    const out = opt('text\n\n```\ncode\n```')
-    // 代码块前后应包裹 <br>
-    expect(out).toContain('<br>\n```')
-    expect(out).toContain('```\n<br>')
-  })
-
-  it('cardVersion=1 代码块前后不加 <br>', () => {
-    const out = opt('text\n\n```\ncode\n```', 1)
-    expect(out).not.toContain('<br>')
-  })
-
-  it('cardVersion=2 连续标题之间加 <br>', () => {
-    const out = opt('# A\n# B')
-    // H1 降级为 H4，之间插入 <br>
-    expect(out).toMatch(/#### A\n<br>\n#### B/)
-  })
-
-  it('cardVersion=2 表格前后加 <br>', () => {
-    const input = 'text before\n\n| col1 | col2 |\n|------|------|\n| v1 | v2 |\n\ntext after'
-    const out = opt(input)
-    // 表格前: <br> 紧贴文本行（规则 3e 压缩多余空行）
-    expect(out).toMatch(/text before\n<br>\n\| col1/)
-    // 表格后: <br> 跟两个换行到下一段文本
-    expect(out).toMatch(/\| v1 \| v2 \|\n<br>\n\ntext after/)
-  })
-
-  it('cardVersion=1 表格前后不加 <br>', () => {
-    const input = 'text before\n\n| col1 | col2 |\n|------|------|\n| v1 | v2 |\n\ntext after'
-    const out = opt(input, 1)
-    expect(out).not.toContain('<br>')
-  })
-
-  it('代码块内的 | 不被当表格处理 (Schema 2.0)', () => {
-    const input = '```\n| in code | not a table |\n|---|---|\n```'
-    const out = opt(input)
-    // 代码块本体应完整保留
-    expect(out).toContain('| in code | not a table |')
-    // 代码块外应该没有出现表格 br 标记（因为代码块内不算表格）
-    // 代码块本身会被 <br> 包裹（Schema 2.0）但不会在 | 周围单独加 <br>
-    expect(out).toMatch(/<br>\n```\n\| in code/)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// stripInvalidImageKeys
-// ---------------------------------------------------------------------------
-
-describe('optimizeMarkdownForFeishu: stripInvalidImageKeys', () => {
-  it('img_* 图片 key 保留', () => {
-    const out = opt('前缀 ![alt](img_abc123) 后缀')
-    expect(out).toContain('![alt](img_abc123)')
-  })
-
-  it('http:// URL 图片被删除', () => {
-    const out = opt('前缀 ![alt](http://example.com/img.png) 后缀')
-    expect(out).toBe('前缀  后缀')
-  })
-
-  it('https:// URL 图片被删除', () => {
-    const out = opt('![a](https://x.y/z.jpg)')
-    expect(out).toBe('')
-  })
-
-  it('本地路径被删除', () => {
-    const out = opt('![a](/Users/me/pic.png)')
-    expect(out).toBe('')
-  })
-
-  it('无图片文本原样', () => {
-    expect(opt('no images here', 1)).toBe('no images here')
-  })
-
-  it('混合: img_ 保留，URL 删除', () => {
-    const out = opt('![keep](img_good) 和 ![drop](http://bad.com/x.png)')
-    expect(out).toContain('![keep](img_good)')
-    expect(out).not.toContain('bad.com')
-    expect(out).not.toContain('![drop]')
-  })
-})
-
-// ---------------------------------------------------------------------------
-// findMarkdownTablesOutsideCodeBlocks
-// ---------------------------------------------------------------------------
-
-describe('findMarkdownTablesOutsideCodeBlocks', () => {
-  it('识别单张表格', () => {
-    const text = '| a | b |\n|---|---|\n| 1 | 2 |'
-    const matches = findMarkdownTablesOutsideCodeBlocks(text)
-    expect(matches.length).toBe(1)
-    expect(matches[0]!.raw).toContain('| a | b |')
-  })
-
-  it('识别多张表格', () => {
-    const text =
-      '| a | b |\n|---|---|\n| 1 | 2 |\n\ntext\n\n| x | y |\n|---|---|\n| 3 | 4 |'
-    const matches = findMarkdownTablesOutsideCodeBlocks(text)
-    expect(matches.length).toBe(2)
-  })
-
-  it('代码块内的 | 不被算作表格', () => {
-    const text = '```\n| in | code |\n|---|---|\n| 1 | 2 |\n```'
-    const matches = findMarkdownTablesOutsideCodeBlocks(text)
-    expect(matches.length).toBe(0)
-  })
-
-  it('代码块 + 外部表格: 只识别外部的', () => {
-    const text =
-      '```\n| in | code |\n|---|---|\n| 1 | 2 |\n```\n\n| real | table |\n|---|---|\n| a | b |'
-    const matches = findMarkdownTablesOutsideCodeBlocks(text)
-    expect(matches.length).toBe(1)
-    expect(matches[0]!.raw).toContain('real')
-  })
-
-  it('无表格文本返回空数组', () => {
-    expect(findMarkdownTablesOutsideCodeBlocks('just text').length).toBe(0)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// sanitizeTextForCard
-// ---------------------------------------------------------------------------
-
-describe('sanitizeTextForCard: 表格数量限制', () => {
-  function makeTable(label: string): string {
-    return `| ${label} h1 | h2 |\n|---|---|\n| v1 | v2 |`
-  }
-
-  it('表格数 ≤ 3 时原样返回', () => {
-    const text = [makeTable('A'), makeTable('B'), makeTable('C')].join('\n\n')
-    expect(sanitizeTextForCard(text)).toBe(text)
-  })
-
-  it('恰好 3 张表格原样返回', () => {
-    const text = [makeTable('A'), makeTable('B'), makeTable('C')].join('\n\n')
-    const matches = findMarkdownTablesOutsideCodeBlocks(text)
-    expect(matches.length).toBe(3)
-    expect(sanitizeTextForCard(text)).toBe(text)
-  })
-
-  it('4 张表格: 前 3 张保留，第 4 张包裹成 code block', () => {
-    const text = [makeTable('A'), makeTable('B'), makeTable('C'), makeTable('D')].join('\n\n')
-    const out = sanitizeTextForCard(text)
-    // 前 3 张表格原样
-    expect(out).toContain(makeTable('A'))
-    expect(out).toContain(makeTable('B'))
-    expect(out).toContain(makeTable('C'))
-    // 第 4 张被包裹
-    expect(out).toContain('```\n' + makeTable('D') + '\n```')
-  })
-
-  it('自定义 limit=1: 第 1 张保留，之后全部包裹', () => {
-    const text = [makeTable('A'), makeTable('B'), makeTable('C')].join('\n\n')
-    const out = sanitizeTextForCard(text, 1)
-    expect(out).toContain(makeTable('A'))
-    expect(out).toContain('```\n' + makeTable('B') + '\n```')
-    expect(out).toContain('```\n' + makeTable('C') + '\n```')
-  })
-
-  it('limit=0: 全部包裹', () => {
-    const text = makeTable('Solo')
-    const out = sanitizeTextForCard(text, 0)
-    expect(out).toContain('```\n' + makeTable('Solo') + '\n```')
-  })
-
-  it('无表格原样返回', () => {
-    expect(sanitizeTextForCard('no tables here')).toBe('no tables here')
-  })
-
-  it('FEISHU_CARD_TABLE_LIMIT 默认值 = 3', () => {
-    expect(FEISHU_CARD_TABLE_LIMIT).toBe(3)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// 边界与真实场景
-// ---------------------------------------------------------------------------
-
-describe('optimizeMarkdownForFeishu: 边界与真实场景', () => {
-  it('screenshot 里的 OpenCutSkill 项目结构报告', () => {
-    const input = `## OpenCutSkill 项目架构概览
-
-### 1. 项目定位
-
-Screen Studio 视频自动剪辑工具。
-
-### 2. 模块结构
-
-\`\`\`
-opencutskill/
-├── cli/
-├── core/
-└── tests/
-\`\`\``
-    const out = opt(input)
-    // 所有 H2~H3 应被降级为 H5
-    expect(out).toContain('##### OpenCutSkill 项目架构概览')
-    expect(out).toContain('##### 1. 项目定位')
-    expect(out).toContain('##### 2. 模块结构')
-    // 代码块内容原封不动
-    expect(out).toContain('opencutskill/')
-    expect(out).toContain('├── cli/')
-    // 原始 ## 字面量不残留
-    expect(out).not.toMatch(/^## OpenCutSkill/m)
-    expect(out).not.toMatch(/^### 1\./m)
-    // 代码块前后有 <br>（Schema 2.0 默认）
-    expect(out).toContain('<br>\n```')
-    expect(out).toContain('```\n<br>')
-  })
-
-  it('异常输入 fallback 到原文不抛错', () => {
-    expect(() => opt('\u0000\uFFFF```unclosed')).not.toThrow()
-  })
-
-  it('空字符串返回空字符串', () => {
-    expect(opt('')).toBe('')
-  })
-})