@morningljn/mnemo 0.1.4 → 0.2.1

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
+}

package/tests/retriever.test.ts

@@ -53,3 +53,56 @@ describe('FactRetriever', () => {
     expect(results.length).toBeGreaterThan(0)
   })
 })
+
+describe('static weights (no dynamic)', () => {
+  it('uses same weights for short and long queries', () => {
+    store.addFact('用户偏好 VS Code 编辑器', 'tool_pref')
+    const shortResults = retriever.search('VS Code')
+    const longResults = retriever.search('为什么 VS Code 编辑器总是报错说找不到模块')
+    // Both should return the same fact — static weights don't change by query length
+    expect(shortResults.some(r => r.content.includes('VS Code'))).toBe(true)
+    expect(longResults.some(r => r.content.includes('VS Code'))).toBe(true)
+  })
+})
+
+describe('length penalty', () => {
+  it('penalizes long facts without summary', () => {
+    const longContent = '用户偏好 ' + '详细说明'.repeat(200) // ~800 chars
+    store.addFact(longContent, 'tool_pref')
+    store.addFact('用户偏好 VS Code', 'tool_pref')
+    const results = retriever.search('用户偏好')
+    // Short fact should rank higher
+    if (results.length >= 2) {
+      const shortFact = results.find(r => r.content === '用户偏好 VS Code')
+      const longFact = results.find(r => r.content.length > 500)
+      if (shortFact && longFact) {
+        expect(shortFact.score).toBeGreaterThan(longFact.score)
+      }
+    }
+  })
+
+  it('does not penalize long facts with short summary', () => {
+    // 长内容包含搜索词（确保 FTS5 能匹配），同时设置短 summary
+    const longContent = '用户偏好的详细内容' + '补充说明'.repeat(200)
+    const id = store.addFact(longContent, 'general')
+    store.connection.prepare('UPDATE facts SET summary = ? WHERE fact_id = ?').run('用户偏好', id)
+    // 短事实也包含搜索词，作为对比
+    store.addFact('用户偏好 VS Code', 'tool_pref')
+    const results = retriever.search('用户偏好')
+    const summaryFact = results.find(r => r.factId === id)
+    // 有 summary 的事实应该被找到（不会被 length penalty 过度惩罚）
+    expect(summaryFact).toBeTruthy()
+    // summary 事实的 score 应该合理（不会被 content 长度拖累）
+    if (summaryFact) {
+      expect(summaryFact.score).toBeGreaterThan(0)
+    }
+  })
+})
+
+describe('no relevance gate', () => {
+  it('returns results even with low scores', () => {
+    store.addFact('完全不相关关于天气', 'general')
+    const results = retriever.search('天气')
+    expect(results.length).toBeGreaterThanOrEqual(1)
+  })
+})

package/tests/store.test.ts

@@ -102,3 +102,242 @@ describe('MemoryStore', () => {
     })
   })
 })
+
+describe('schema migration', () => {
+  it('has summary column on facts table', () => {
+    const cols = store.connection.pragma('table_info(facts)') as Array<{ name: string }>
+    const colNames = cols.map(c => c.name)
+    expect(colNames).toContain('summary')
+    expect(colNames).toContain('last_retrieved_at')
+  })
+
+  it('has retrieval_log table', () => {
+    const tables = store.connection.prepare(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name='retrieval_log'"
+    ).get()
+    expect(tables).toBeTruthy()
+  })
+
+  it('summary defaults to null', () => {
+    const id = store.addFact('test summary fact', 'general')
+    const row = store.connection.prepare('SELECT summary FROM facts WHERE fact_id = ?').get(id) as { summary: string | null }
+    expect(row.summary).toBeNull()
+  })
+})
+
+describe('logRetrieval', () => {
+  it('writes retrieval log with results', () => {
+    const id = store.addFact('test fact for logging', 'general')
+    store.logRetrieval('test query', [{ id, score: 0.8 }])
+    const rows = store.connection.prepare('SELECT * FROM retrieval_log').all() as Array<any>
+    expect(rows.length).toBe(1)
+    expect(rows[0].query).toBe('test query')
+    expect(JSON.parse(rows[0].results)).toEqual([{ id, score: 0.8 }])
+  })
+
+  it('updates last_retrieved_at for returned facts', () => {
+    const id = store.addFact('test fact for timestamp', 'general')
+    store.logRetrieval('query', [{ id, score: 0.5 }])
+    const row = store.connection.prepare('SELECT last_retrieved_at FROM facts WHERE fact_id = ?').get(id) as any
+    expect(row.last_retrieved_at).not.toBeNull()
+  })
+
+  it('prunes log to max entries', () => {
+    for (let i = 0; i < 12; i++) {
+      store.logRetrieval(`query ${i}`, [])
+    }
+    store.pruneRetrievalLog(10)
+    const count = (store.connection.prepare('SELECT COUNT(*) as c FROM retrieval_log').get() as any).c
+    expect(count).toBe(10)
+  })
+})
+
+describe('runLearning', () => {
+  it('demotes moderate retrieval low helpful facts', () => {
+    const id = store.addFact('demote me', 'general')
+    store.connection.prepare('UPDATE facts SET retrieval_count = 50, helpful_count = 1, trust_score = 1.0 WHERE fact_id = ?').run(id)
+    const result = store.runLearning()
+    const row = store.connection.prepare('SELECT trust_score FROM facts WHERE fact_id = ?').get(id) as any
+    expect(row.trust_score).toBeLessThan(1.0)
+    expect(result.demoted).toBeGreaterThanOrEqual(1)
+  })
+
+  it('protects high frequency facts from demotion', () => {
+    const id = store.addFact('高频角色设定', 'identity')
+    store.connection.prepare('UPDATE facts SET retrieval_count = 200, helpful_count = 2, trust_score = 0.9 WHERE fact_id = ?').run(id)
+    store.runLearning()
+    const row = store.connection.prepare('SELECT trust_score FROM facts WHERE fact_id = ?').get(id) as any
+    expect(row.trust_score).toBe(0.9)
+  })
+
+  it('still demotes moderate frequency facts with low trust', () => {
+    const id = store.addFact('中频低信任', 'general')
+    store.connection.prepare('UPDATE facts SET retrieval_count = 50, helpful_count = 0, trust_score = 0.3 WHERE fact_id = ?').run(id)
+    store.runLearning()
+    const row = store.connection.prepare('SELECT trust_score FROM facts WHERE fact_id = ?').get(id) as any
+    expect(row.trust_score).toBeLessThan(0.3)
+  })
+
+  it('promotes high helpful rate facts', () => {
+    const id = store.addFact('promote me', 'general')
+    store.connection.prepare('UPDATE facts SET retrieval_count = 50, helpful_count = 20, trust_score = 0.5 WHERE fact_id = ?').run(id)
+    store.runLearning()
+    const row = store.connection.prepare('SELECT trust_score FROM facts WHERE fact_id = ?').get(id) as any
+    expect(row.trust_score).toBeGreaterThan(0.5)
+  })
+
+  it('does not adjust facts with low retrieval count', () => {
+    const id = store.addFact('new fact', 'general')
+    store.connection.prepare('UPDATE facts SET retrieval_count = 5, helpful_count = 0, trust_score = 0.8 WHERE fact_id = ?').run(id)
+    store.runLearning()
+    const row = store.connection.prepare('SELECT trust_score FROM facts WHERE fact_id = ?').get(id) as any
+    expect(row.trust_score).toBe(0.8)
+  })
+
+  it('ages facts not retrieved for 60 days', () => {
+    const id = store.addFact('old fact', 'general')
+    store.connection.prepare("UPDATE facts SET last_retrieved_at = datetime('now', '-61 days'), trust_score = 0.8 WHERE fact_id = ?").run(id)
+    store.runLearning()
+    const row = store.connection.prepare('SELECT trust_score FROM facts WHERE fact_id = ?').get(id) as any
+    expect(row.trust_score).toBeLessThan(0.8)
+  })
+
+  it('protects new facts with null last_retrieved_at from aging', () => {
+    const id = store.addFact('brand new fact', 'general')
+    store.connection.prepare('UPDATE facts SET trust_score = 0.5, last_retrieved_at = NULL WHERE fact_id = ?').run(id)
+    store.runLearning()
+    const row = store.connection.prepare('SELECT trust_score FROM facts WHERE fact_id = ?').get(id) as any
+    expect(row.trust_score).toBe(0.5)
+  })
+
+  it('returns long_facts report', () => {
+    const id = store.addFact('x'.repeat(600), 'general')
+    const result = store.runLearning()
+    expect(result.long_facts.length).toBeGreaterThanOrEqual(1)
+    expect(result.long_facts.some((f: any) => f.id === id)).toBe(true)
+  })
+})
+
+describe('runAudit', () => {
+  it('returns quality report without modifying data', () => {
+    const id = store.addFact('a'.repeat(600), 'general')
+    store.connection.prepare('UPDATE facts SET retrieval_count = 100, helpful_count = 1 WHERE fact_id = ?').run(id)
+    const before = (store.connection.prepare('SELECT trust_score FROM facts WHERE fact_id = ?').get(id) as any).trust_score
+    const report = store.runAudit()
+    const after = (store.connection.prepare('SELECT trust_score FROM facts WHERE fact_id = ?').get(id) as any).trust_score
+    expect(before).toBe(after)
+    expect(report.total_facts).toBeGreaterThanOrEqual(1)
+    expect(report.long_without_summary.length).toBeGreaterThanOrEqual(1)
+  })
+})
+
+describe('dream - backup', () => {
+  it('creates backup before dream', async () => {
+    store.addFact('test fact for backup', 'general')
+    const result = await store.backupDatabase()
+    expect(result).toBeTruthy()
+    expect(result).toContain('dream-')
+    expect(result).toContain('.db')
+  })
+})
+
+describe('dream - compress', () => {
+  it('generates summary for long facts without summary', () => {
+    const longContent = '用户偏好使用 TypeScript 开发前端项目。偏好 React 框架进行组件化开发。' + '额外补充说明'.repeat(50)
+    store.addFact(longContent, 'coding_style')
+    const result = store.compressLongFacts()
+    expect(result).toBeGreaterThanOrEqual(1)
+    const row = store.connection.prepare('SELECT summary FROM facts WHERE content = ?').get(longContent) as any
+    expect(row.summary).toBeTruthy()
+    expect(row.summary.length).toBeLessThanOrEqual(150)
+    expect(row.summary).toContain('TypeScript')
+  })
+
+  it('skips facts with existing summary', () => {
+    const longContent = 'x'.repeat(300)
+    const id = store.addFact(longContent, 'general')
+    store.connection.prepare('UPDATE facts SET summary = ? WHERE fact_id = ?').run('existing summary', id)
+    const result = store.compressLongFacts()
+    expect(result).toBe(0)
+    const row = store.connection.prepare('SELECT summary FROM facts WHERE fact_id = ?').get(id) as any
+    expect(row.summary).toBe('existing summary')
+  })
+
+  it('skips short facts', () => {
+    store.addFact('short fact', 'general')
+    const result = store.compressLongFacts()
+    expect(result).toBe(0)
+  })
+})
+
+describe('dream - merge', () => {
+  it('merges overlapping facts in same category', () => {
+    store.addFact('用户偏好使用 TypeScript 编写前端代码', 'coding_style')
+    store.addFact('用户偏好使用 TypeScript 编写后端代码', 'coding_style')
+    const result = store.mergeOverlappingFacts()
+    expect(result.merged).toBeGreaterThanOrEqual(1)
+    expect(result.details.length).toBeGreaterThanOrEqual(1)
+  })
+
+  it('protects high frequency facts from deletion', () => {
+    const id1 = store.addFact('用户偏好使用 TypeScript 编写前端代码', 'coding_style')
+    const id2 = store.addFact('用户偏好使用 TypeScript 编写前端代码扩展', 'coding_style')
+    store.connection.prepare('UPDATE facts SET retrieval_count = 200 WHERE fact_id = ?').run(id1)
+    const result = store.mergeOverlappingFacts()
+    const kept = store.connection.prepare('SELECT fact_id FROM facts WHERE fact_id = ?').get(id1) as any
+    expect(kept).toBeTruthy()
+  })
+
+  it('does not merge facts across categories', () => {
+    store.addFact('用户偏好使用 TypeScript 编写前端代码', 'coding_style')
+    store.addFact('用户偏好使用 TypeScript 编写前端代码', 'general')
+    const result = store.mergeOverlappingFacts()
+    expect(result.merged).toBe(0)
+  })
+
+  it('does not merge when both facts are high frequency', () => {
+    const id1 = store.addFact('高频测试事实 AAA 长内容匹配', 'coding_style')
+    const id2 = store.addFact('高频测试事实 BBB 长内容匹配', 'coding_style')
+    store.connection.prepare('UPDATE facts SET retrieval_count = 200 WHERE fact_id IN (?, ?)').run(id1, id2)
+    const result = store.mergeOverlappingFacts()
+    // Both facts should still exist
+    const row1 = store.connection.prepare('SELECT fact_id FROM facts WHERE fact_id = ?').get(id1) as any
+    const row2 = store.connection.prepare('SELECT fact_id FROM facts WHERE fact_id = ?').get(id2) as any
+    expect(row1).toBeTruthy()
+    expect(row2).toBeTruthy()
+  })
+})
+
+describe('dream - reclassify', () => {
+  it('moves miscategorized facts by keywords', () => {
+    const id = store.addFact('编码规范：文件不超过 500 行', 'identity')
+    const result = store.reclassifyFacts()
+    expect(result).toBeGreaterThanOrEqual(1)
+    const row = store.connection.prepare('SELECT category FROM facts WHERE fact_id = ?').get(id) as any
+    expect(row.category).toBe('coding_style')
+  })
+
+  it('skips correctly categorized facts', () => {
+    store.addFact('用户偏好使用 VS Code 编辑器', 'tool_pref')
+    const result = store.reclassifyFacts()
+    expect(result).toBe(0)
+  })
+})
+
+describe('dream - runDream', () => {
+  it('runs full dream cycle and returns report', async () => {
+    // 长文 fact（触发压缩）
+    store.addFact('用户偏好使用 TypeScript 开发前端。使用 React 框架。' + 'x'.repeat(250), 'coding_style')
+    // 重叠 fact（触发合并）
+    store.addFact('用户偏好使用 TypeScript 开发前端代码', 'coding_style')
+    // 分类错误 fact（触发重分类）
+    store.addFact('编码规范：文件不超过 500 行', 'identity')
+
+    const report = await store.runDream({ skipBackup: true })
+    expect(report.compressed).toBeGreaterThanOrEqual(0)
+    expect(report.merged).toBeGreaterThanOrEqual(0)
+    expect(report.reclassified).toBeGreaterThanOrEqual(0)
+    expect(report.health.total).toBeGreaterThanOrEqual(1)
+    expect(report.health.coverage).toBeTruthy()
+  })
+})