@morningljn/mnemo 0.2.0 → 0.3.0

package/src/store.ts

@@ -12,9 +12,12 @@
 import Database from 'better-sqlite3'
 import type { Statement } from 'better-sqlite3'
 import { mkdirSync } from 'node:fs'
-import { dirname } from 'node:path'
+import { dirname, join } from 'node:path'
 import { SCHEMA } from './schema.js'
-import type { Fact, FactCategory } from './types.js'
+import type { Fact, FactCategory, DreamReport } from './types.js'
+import { loadConfig } from './config.js'
+import { LLMClient } from './llm-client.js'
+import { DreamEngine } from './dream-engine.js'
 
 // 信任评分常量
 const HELPFUL_DELTA = 0.05
@@ -136,10 +139,10 @@ export class MemoryStore {
         DROP TRIGGER IF EXISTS facts_ad;
         DROP TRIGGER IF EXISTS facts_au;
       `)
-      // 重建 FTS5 虚拟表（含 summary）
+      // 重建 FTS5 虚拟表（含 summary，使用 trigram tokenizer 支持中文子串）
       this.db.exec(`
         CREATE VIRTUAL TABLE facts_fts
-          USING fts5(content, tags, summary, content=facts, content_rowid=fact_id);
+          USING fts5(content, tags, summary, content=facts, content_rowid=fact_id, tokenize='trigram');
       `)
       // 重填充
       this.db.exec(`
@@ -743,7 +746,9 @@ export class MemoryStore {
 
       // Rate-based adjustment (需要 30+ 次检索)
       if (row.retrieval_count > 30) {
-        if (rate < 0.05) {
+        // 高频检索保护：检索 >100 次说明被持续需要，feedback 少不代表无用
+        const highFrequencyProtected = row.retrieval_count > 100
+        if (rate < 0.05 && !highFrequencyProtected) {
           const newTrust = clampTrust(row.trust_score * 0.9)
           this.db.prepare('UPDATE facts SET trust_score = ? WHERE fact_id = ?').run(newTrust, row.fact_id)
           demoted++
@@ -839,6 +844,194 @@ export class MemoryStore {
     }
   }
 
+  /** Dream 前备份数据库（使用 better-sqlite3 内置备份，安全处理 WAL 模式） */
+  async backupDatabase(): Promise<string> {
+    const dbDir = dirname(this.db.name)
+    const backupDir = join(dbDir, 'backup')
+    mkdirSync(backupDir, { recursive: true })
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19)
+    const backupPath = join(backupDir, `dream-${timestamp}.db`)
+    await this.db.backup(backupPath)
+    return backupPath
+  }
+
+  /** 合并同 category 内 Jaccard > 0.6 的重叠 fact */
+  mergeOverlappingFacts(): { merged: number; details: Array<{ kept: number; removed: number; similarity: number }> } {
+    return this.db.transaction(() => {
+      const categories: FactCategory[] = ['identity', 'coding_style', 'tool_pref', 'workflow', 'general']
+      let merged = 0
+      const details: Array<{ kept: number; removed: number; similarity: number }> = []
+
+      for (const cat of categories) {
+        const rows = this.db.prepare(
+          'SELECT fact_id, content, retrieval_count FROM facts WHERE category = ? ORDER BY trust_score DESC'
+        ).all(cat) as Array<{ fact_id: number; content: string; retrieval_count: number }>
+
+        const removed = new Set<number>()
+
+        for (let i = 0; i < rows.length; i++) {
+          if (removed.has(rows[i].fact_id)) continue
+          const tokensA = this.tokenizeForDedup(rows[i].content)
+
+          for (let j = i + 1; j < rows.length; j++) {
+            if (removed.has(rows[j].fact_id)) continue
+            const tokensB = this.tokenizeForDedup(rows[j].content)
+            const sim = this.jaccardSimilarity(tokensA, tokensB)
+
+            if (sim > 0.4) {
+              const aHighFreq = rows[i].retrieval_count > 100
+              const bHighFreq = rows[j].retrieval_count > 100
+
+              if (aHighFreq && bHighFreq) continue
+
+              let keptId: number, removedId: number
+              if (bHighFreq) {
+                keptId = rows[j].fact_id
+                removedId = rows[i].fact_id
+              } else {
+                keptId = rows[i].fact_id
+                removedId = rows[j].fact_id
+              }
+
+              this.removeFact(removedId)
+              removed.add(removedId)
+              details.push({ kept: keptId, removed: removedId, similarity: Math.round(sim * 100) / 100 })
+              merged++
+              // 外层 fact 被删除时停止内层循环，避免幽灵操作
+              if (removedId === rows[i].fact_id) break
+            }
+          }
+        }
+      }
+      return { merged, details }
+    })()
+  }
+
+  /** 分类修正：按关键词规则表将误分类的 fact 挪到正确 category */
+  reclassifyFacts(): number {
+    return this.db.transaction(() => {
+      const rules: Array<{ keywords: string[]; target: FactCategory }> = [
+        { keywords: ['角色设定', '暖暖', '身份', '编程女朋友', '暖宝宝'], target: 'identity' },
+        { keywords: ['编码规范', '代码风格', 'pytest', '文件不超过', '方法不超过'], target: 'coding_style' },
+        { keywords: ['工作流', 'OpenSpec', 'writing-plans', 'subagent'], target: 'workflow' },
+        { keywords: ['偏好', 'VS Code', '编辑器', 'IDE', '快捷键'], target: 'tool_pref' },
+      ]
+
+      // 只从 general 分类移动，避免已分类 fact 被反复震荡
+      const rows = this.db.prepare(
+        "SELECT fact_id, content, category FROM facts WHERE category = 'general'"
+      ).all() as Array<{ fact_id: number; content: string; category: string }>
+
+      let reclassified = 0
+      for (const row of rows) {
+        for (const rule of rules) {
+          if (rule.keywords.some(kw => row.content.includes(kw))) {
+            this.db.prepare("UPDATE facts SET category = ?, updated_at = datetime('now', 'localtime') WHERE fact_id = ?").run(rule.target, row.fact_id)
+            reclassified++
+            break
+          }
+        }
+      }
+      return reclassified
+    })()
+  }
+
+  /** 执行完整 dream cycle：备份 → LLM 整理 → 降级规则引擎 → 报告 */
+  async runDream(options?: { skipBackup?: boolean }): Promise<DreamReport> {
+    if (!options?.skipBackup) {
+      await this.backupDatabase()
+    }
+
+    // 尝试 LLM 驱动的 dream
+    const config = loadConfig()
+    const llmClient = new LLMClient(config)
+
+    const available = await llmClient.isAvailable()
+    if (available) {
+      try {
+        const engine = new DreamEngine(llmClient, this)
+        const mergeResult = await engine.semanticMerge()
+        const compressed = await engine.smartCompress()
+        const reclassified = await engine.smartReclassify()
+
+        return this.buildDreamReport(mergeResult.merged, compressed, reclassified, mergeResult.details.map(d => ({ kept: d.kept, removed: d.removed, similarity: 0 })), false)
+      } catch {
+        // LLM 执行失败，降级到规则引擎
+      }
+    }
+
+    // 降级到规则引擎
+    const compressed = this.compressLongFacts()
+    const mergeResult = this.mergeOverlappingFacts()
+    const reclassified = this.reclassifyFacts()
+
+    return this.buildDreamReport(mergeResult.merged, compressed, reclassified, mergeResult.details, true, 'LLM unavailable')
+  }
+
+  private buildDreamReport(
+    merged: number, compressed: number, reclassified: number,
+    mergeDetails: Array<{ kept: number; removed: number; similarity: number }>,
+    fallback: boolean, fallbackReason?: string,
+  ): DreamReport {
+    const stats = this.db.prepare(`
+      SELECT COUNT(*) as total,
+             AVG(trust_score) as avg_trust,
+             AVG(length(content)) as avg_length
+      FROM facts
+    `).get() as { total: number; avg_trust: number; avg_length: number }
+
+    const categories: FactCategory[] = ['identity', 'coding_style', 'tool_pref', 'workflow', 'general']
+    const coverage: Record<string, number> = {}
+    for (const cat of categories) {
+      const row = this.db.prepare('SELECT COUNT(*) as c FROM facts WHERE category = ?').get(cat) as { c: number }
+      coverage[cat] = row.c
+    }
+
+    return {
+      merged,
+      compressed,
+      reclassified,
+      deleted: merged,
+      mergeDetails,
+      fallback,
+      fallbackReason,
+      health: {
+        total: stats.total,
+        avg_trust: Math.round((stats.avg_trust ?? 0) * 100) / 100,
+        avg_length: Math.round(stats.avg_length ?? 0),
+        coverage: coverage as Record<FactCategory, number>,
+      },
+    }
+  }
+
+  /** 压缩长 fact：content > 200 字且无 summary 的，自动提取前 2 句作为 summary */
+  compressLongFacts(): number {
+    const rows = this.db.prepare(
+      "SELECT fact_id, content FROM facts WHERE length(content) > 200 AND (summary IS NULL OR summary = '')"
+    ).all() as Array<{ fact_id: number; content: string }>
+
+    let compressed = 0
+    for (const row of rows) {
+      const summary = this.extractSummary(row.content)
+      if (summary) {
+        this.db.prepare('UPDATE facts SET summary = ? WHERE fact_id = ?').run(summary, row.fact_id)
+        compressed++
+      }
+    }
+    return compressed
+  }
+
+  /** 从 content 提取前 2 个完整句子（总长 ≤ 150 字） */
+  private extractSummary(content: string): string | null {
+    const sentences = content.split(/[。\n.]/).map(s => s.trim()).filter(s => s.length > 0)
+    if (sentences.length === 0) return null
+    let summary = sentences[0]
+    if (sentences.length > 1 && summary.length + sentences[1].length <= 148) {
+      summary += '。' + sentences[1]
+    }
+    return summary.length <= 150 ? summary : summary.slice(0, 147) + '...'
+  }
+
   /** 获取数据库连接（供 FactRetriever 直接使用） */
   get connection(): Database.Database {
     return this.db

package/src/types.ts

@@ -55,7 +55,7 @@ export interface RetrieverOptions {
 
 /** fact_store 工具调用参数 */
 export interface FactStoreArgs {
-  action: 'add' | 'search' | 'probe' | 'related' | 'reason' | 'contradict' | 'update' | 'remove' | 'list' | 'learn' | 'audit'
+  action: 'add' | 'search' | 'probe' | 'related' | 'reason' | 'contradict' | 'update' | 'remove' | 'list' | 'learn' | 'audit' | 'dream'
   content?: string | string[]
   query?: string
   entity?: string
@@ -82,3 +82,43 @@ export interface SecurityScanResult {
   hasPii: boolean
   injectionAttempts: string[]
 }
+
+/** Dream 整理报告 */
+export interface DreamReport {
+  merged: number
+  compressed: number
+  reclassified: number
+  deleted: number
+  mergeDetails: Array<{ kept: number; removed: number; similarity: number }>
+  fallback?: boolean
+  fallbackReason?: string
+  health: {
+    total: number
+    avg_trust: number
+    avg_length: number
+    coverage: Record<FactCategory, number>
+  }
+}
+
+/** 精简搜索结果 */
+export interface CompactFactResult {
+  factId: number
+  display: string
+  category: FactCategory
+  trustScore: number
+  score: number
+}
+
+/** LLM 配置 */
+export interface LLMConfig {
+  baseUrl: string
+  model: string
+  apiKey?: string
+  temperature: number
+}
+
+/** LLM 聊天消息 */
+export interface LLMMessage {
+  role: 'system' | 'user' | 'assistant'
+  content: string
+}

package/tests/dream-engine.test.ts

@@ -0,0 +1,163 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { DreamEngine } from '../src/dream-engine.js'
+import { LLMClient } from '../src/llm-client.js'
+import { MemoryStore } from '../src/store.js'
+import { mkdtempSync, rmSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+
+let store: MemoryStore
+let tmpDir: string
+
+beforeEach(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), 'mnemo-dream-'))
+  store = new MemoryStore(join(tmpDir, 'test.db'))
+})
+
+afterEach(() => {
+  store.close()
+  rmSync(tmpDir, { recursive: true, force: true })
+})
+
+describe('DreamEngine - semanticMerge', () => {
+  it('merges semantically duplicate facts in same category', async () => {
+    store.addFact('用户喜欢使用 VS Code 编辑器写代码', 'tool_pref')
+    store.addFact('用户偏好 Visual Studio Code 作为开发工具', 'tool_pref')
+
+    const mockChatJSON = vi.fn().mockResolvedValueOnce({
+      merges: [{ kept: 1, removed: 2, reason: '都描述偏好VS Code编辑器' }],
+    })
+    const mockClient = { chatJSON: mockChatJSON, isAvailable: vi.fn().mockResolvedValue(true) } as unknown as LLMClient
+    const eng = new DreamEngine(mockClient, store)
+    const result = await eng.semanticMerge()
+
+    expect(result.merged).toBe(1)
+    expect(result.details.length).toBe(1)
+    expect(result.details[0].reason).toBe('都描述偏好VS Code编辑器')
+  })
+
+  it('skips batch when LLM returns invalid JSON', async () => {
+    store.addFact('一些事实内容', 'general')
+
+    const mockClient = {
+      chatJSON: vi.fn().mockRejectedValue(new Error('invalid json')),
+      isAvailable: vi.fn().mockResolvedValue(true),
+    } as unknown as LLMClient
+    const eng = new DreamEngine(mockClient, store)
+    const result = await eng.semanticMerge()
+
+    expect(result.merged).toBe(0)
+  })
+
+  it('protects high-trust facts from deletion', async () => {
+    const id1 = store.addFact('高信任事实内容', 'general')
+    store.recordFeedback(id1, true)
+    store.recordFeedback(id1, true)
+    store.recordFeedback(id1, true)
+    store.recordFeedback(id1, true)
+    store.recordFeedback(id1, true)
+    store.recordFeedback(id1, true)
+    store.recordFeedback(id1, true)
+    store.recordFeedback(id1, true)
+    store.recordFeedback(id1, true)
+    store.recordFeedback(id1, true)
+
+    const id2 = store.addFact('另一个事实内容', 'general')
+
+    const mockChatJSON = vi.fn().mockResolvedValueOnce({
+      merges: [{ kept: id2, removed: id1, reason: '重复' }],
+    })
+    const mockClient = { chatJSON: mockChatJSON, isAvailable: vi.fn().mockResolvedValue(true) } as unknown as LLMClient
+    const eng = new DreamEngine(mockClient, store)
+    const result = await eng.semanticMerge()
+
+    expect(result.merged).toBe(0)
+  })
+})
+
+describe('DreamEngine - smartCompress', () => {
+  it('generates summary for long facts without summary', async () => {
+    const longContent = '这是一段很长的记忆内容。'.repeat(20) // >200 chars
+    store.addFact(longContent, 'general')
+
+    const summary = '这是一段关于长内容的简洁摘要'
+    const mockChatJSON = vi.fn().mockResolvedValueOnce({ summaries: [{ fact_id: 1, summary }] })
+    const mockClient = { chatJSON: mockChatJSON, isAvailable: vi.fn().mockResolvedValue(true) } as unknown as LLMClient
+    const eng = new DreamEngine(mockClient, store)
+    const result = await eng.smartCompress()
+
+    expect(result).toBe(1)
+  })
+
+  it('skips facts that already have summary', async () => {
+    const longContent = '这是一段很长的记忆内容。'.repeat(20)
+    const id = store.addFact(longContent, 'general')
+    store.connection.prepare('UPDATE facts SET summary = ? WHERE fact_id = ?').run('已有摘要', id)
+
+    const mockChatJSON = vi.fn()
+    const mockClient = { chatJSON: mockChatJSON, isAvailable: vi.fn().mockResolvedValue(true) } as unknown as LLMClient
+    const eng = new DreamEngine(mockClient, store)
+    const result = await eng.smartCompress()
+
+    expect(result).toBe(0)
+    expect(mockChatJSON).not.toHaveBeenCalled()
+  })
+
+  it('truncates summary longer than 150 chars', async () => {
+    const longContent = '这是一段很长的记忆内容。'.repeat(20)
+    store.addFact(longContent, 'general')
+
+    const tooLongSummary = 'a'.repeat(200)
+    const mockChatJSON = vi.fn().mockResolvedValueOnce({ summaries: [{ fact_id: 1, summary: tooLongSummary }] })
+    const mockClient = { chatJSON: mockChatJSON, isAvailable: vi.fn().mockResolvedValue(true) } as unknown as LLMClient
+    const eng = new DreamEngine(mockClient, store)
+    await eng.smartCompress()
+
+    const fact = store.listFacts('general', 0, 10)[0]
+    expect(fact.summary!.length).toBeLessThanOrEqual(150)
+  })
+})
+
+describe('DreamEngine - smartReclassify', () => {
+  it('moves general facts to correct category via LLM', async () => {
+    store.addFact('用户编码规范要求文件不超过500行', 'general')
+
+    const mockChatJSON = vi.fn().mockResolvedValueOnce({
+      reclassify: [{ fact_id: 1, to: 'coding_style' }],
+    })
+    const mockClient = { chatJSON: mockChatJSON, isAvailable: vi.fn().mockResolvedValue(true) } as unknown as LLMClient
+    const eng = new DreamEngine(mockClient, store)
+    const result = await eng.smartReclassify()
+
+    expect(result).toBe(1)
+    const fact = store.listFacts('coding_style', 0, 10)[0]
+    expect(fact).toBeDefined()
+    expect(fact.content).toContain('编码规范')
+  })
+
+  it('ignores invalid category from LLM', async () => {
+    store.addFact('一些内容', 'general')
+
+    const mockChatJSON = vi.fn().mockResolvedValueOnce({
+      reclassify: [{ fact_id: 1, to: 'invalid_category' }],
+    })
+    const mockClient = { chatJSON: mockChatJSON, isAvailable: vi.fn().mockResolvedValue(true) } as unknown as LLMClient
+    const eng = new DreamEngine(mockClient, store)
+    const result = await eng.smartReclassify()
+
+    expect(result).toBe(0)
+  })
+
+  it('skips when LLM says keep general', async () => {
+    store.addFact('一些杂项内容', 'general')
+
+    const mockChatJSON = vi.fn().mockResolvedValueOnce({
+      reclassify: [{ fact_id: 1, to: 'general' }],
+    })
+    const mockClient = { chatJSON: mockChatJSON, isAvailable: vi.fn().mockResolvedValue(true) } as unknown as LLMClient
+    const eng = new DreamEngine(mockClient, store)
+    const result = await eng.smartReclassify()
+
+    expect(result).toBe(0)
+  })
+})

package/tests/llm-client.test.ts

@@ -0,0 +1,105 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { LLMClient } from '../src/llm-client.js'
+import type { LLMConfig, LLMMessage } from '../src/types.js'
+
+const mockConfig: LLMConfig = {
+  baseUrl: 'http://localhost:11434/v1',
+  model: 'test-model',
+  temperature: 0.1,
+}
+
+function mockFetchResponse(body: unknown, ok = true, status = 200) {
+  return vi.fn().mockResolvedValue({
+    ok,
+    status,
+    json: () => Promise.resolve(body),
+    text: () => Promise.resolve(JSON.stringify(body)),
+  })
+}
+
+describe('LLMClient', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  describe('chat', () => {
+    it('sends request and returns text content', async () => {
+      const mockResp = {
+        choices: [{ message: { content: 'Hello from LLM' } }],
+      }
+      globalThis.fetch = mockFetchResponse(mockResp)
+
+      const client = new LLMClient(mockConfig)
+      const messages: LLMMessage[] = [{ role: 'user', content: 'Hi' }]
+      const result = await client.chat(messages)
+
+      expect(result).toBe('Hello from LLM')
+      expect(globalThis.fetch).toHaveBeenCalledWith(
+        'http://localhost:11434/v1/chat/completions',
+        expect.objectContaining({
+          method: 'POST',
+          headers: expect.objectContaining({ 'Content-Type': 'application/json' }),
+        }),
+      )
+    })
+
+    it('includes Authorization header when apiKey is set', async () => {
+      const configWithKey = { ...mockConfig, apiKey: 'sk-test-key' }
+      globalThis.fetch = mockFetchResponse({
+        choices: [{ message: { content: 'ok' } }],
+      })
+
+      const client = new LLMClient(configWithKey)
+      await client.chat([{ role: 'user', content: 'test' }])
+
+      const callArgs = (globalThis.fetch as ReturnType<typeof vi.fn>).mock.calls[0][1] as RequestInit
+      expect(callArgs.headers).toHaveProperty('Authorization', 'Bearer sk-test-key')
+    })
+
+    it('throws on connection failure', async () => {
+      globalThis.fetch = vi.fn().mockRejectedValue(new Error('ECONNREFUSED'))
+      const client = new LLMClient(mockConfig)
+      await expect(client.chat([{ role: 'user', content: 'test' }])).rejects.toThrow('ECONNREFUSED')
+    })
+
+    it('throws on non-ok HTTP status', async () => {
+      globalThis.fetch = mockFetchResponse({ error: 'bad request' }, false, 400)
+      const client = new LLMClient(mockConfig)
+      await expect(client.chat([{ role: 'user', content: 'test' }])).rejects.toThrow('400')
+    })
+
+    it('extracts JSON from markdown code fence', async () => {
+      const jsonBody = { result: [1, 2] }
+      const fenced = '```json\n' + JSON.stringify(jsonBody) + '\n```'
+      globalThis.fetch = mockFetchResponse({
+        choices: [{ message: { content: fenced } }],
+      })
+
+      const client = new LLMClient(mockConfig)
+      const result = await client.chatJSON([{ role: 'user', content: 'test' }])
+      expect(result).toEqual(jsonBody)
+    })
+
+    it('throws on invalid JSON response in chatJSON', async () => {
+      globalThis.fetch = mockFetchResponse({
+        choices: [{ message: { content: 'not json at all' } }],
+      })
+      const client = new LLMClient(mockConfig)
+      await expect(client.chatJSON([{ role: 'user', content: 'test' }])).rejects.toThrow()
+    })
+  })
+
+  describe('isAvailable', () => {
+    it('returns true when service is reachable', async () => {
+      globalThis.fetch = mockFetchResponse({ data: [] })
+      const client = new LLMClient(mockConfig)
+      expect(await client.isAvailable()).toBe(true)
+    })
+
+    it('returns false when service is unreachable', async () => {
+      globalThis.fetch = vi.fn().mockRejectedValue(new Error('fail'))
+      const client = new LLMClient(mockConfig)
+      expect(await client.isAvailable()).toBe(false)
+    })
+  })
+})

package/tests/resource.test.ts

@@ -21,42 +21,44 @@ afterEach(() => {
 })
 
 describe('ResourceManager', () => {
-  it('returns empty array for empty category', () => {
-    const facts = manager.getFacts('identity')
-    expect(facts).toEqual([])
+  it('returns empty markdown for empty category', () => {
+    const text = readResource('identity')
+    expect(text).toContain('身份与行为设定')
+    expect(text).not.toContain('## 你的身份')
   })
 
-  it('returns facts ordered by trust score', () => {
+  it('formats identity facts as instructions', () => {
+    store.addFact('AI角色设定：大名暖暖，身份是用户的编程助手', 'identity')
+    const text = readResource('identity')
+    expect(text).toContain('你的身份')
+    expect(text).toContain('暖暖')
+  })
+
+  it('formats non-identity facts as reference', () => {
     store.addFact('用户偏好深色主题', 'tool_pref')
-    store.addFact('用户喜欢 VS Code', 'tool_pref')
-    const facts = manager.getFacts('tool_pref')
-    expect(facts.length).toBe(2)
-    // listFacts returns trust_score DESC, first fact added gets default trust
-    expect(facts.length).toBeGreaterThan(0)
+    const text = readResource('tool_pref')
+    expect(text).toContain('工具偏好')
+    expect(text).toContain('深色主题')
   })
 
   it('caches results', () => {
     store.addFact('测试事实', 'general')
-    manager.getFacts('general')
+    readResource('general')
+    expect(manager.cacheSize()).toBe(1)
+    readResource('general')
     expect(manager.cacheSize()).toBe(1)
-    // Second call should hit cache
-    const facts2 = manager.getFacts('general')
-    expect(facts2.length).toBe(1)
   })
 
-  it('invalidates cache on write', () => {
+  it('invalidates cache', () => {
     store.addFact('测试事实', 'general')
-    manager.getFacts('general')
+    readResource('general')
     expect(manager.cacheSize()).toBe(1)
     manager.invalidate()
     expect(manager.cacheSize()).toBe(0)
   })
-
-  it('limits to top 10 facts', () => {
-    for (let i = 0; i < 15; i++) {
-      store.addFact(`事实 ${i}`, 'general')
-    }
-    const facts = manager.getFacts('general')
-    expect(facts.length).toBe(10)
-  })
 })
+
+function readResource(category: string): string {
+  const result = (manager as any).readCategory(category)
+  return result.contents[0].text
+}