@morningljn/mnemo 0.1.3 → 0.2.0

package/src/types.ts

@@ -8,9 +8,11 @@ export interface Fact {
   category: FactCategory
   tags: string
   keywords: string
+  summary: string | null
   trustScore: number
   retrievalCount: number
   helpfulCount: number
+  lastRetrievedAt: string | null
   createdAt: string
   updatedAt: string
 }
@@ -53,7 +55,7 @@ export interface RetrieverOptions {
 
 /** fact_store 工具调用参数 */
 export interface FactStoreArgs {
-  action: 'add' | 'search' | 'probe' | 'related' | 'reason' | 'contradict' | 'update' | 'remove' | 'list'
+  action: 'add' | 'search' | 'probe' | 'related' | 'reason' | 'contradict' | 'update' | 'remove' | 'list' | 'learn' | 'audit'
   content?: string | string[]
   query?: string
   entity?: string
@@ -61,6 +63,7 @@ export interface FactStoreArgs {
   fact_id?: number | number[]
   category?: string
   tags?: string
+  summary?: string
   trust_delta?: number
   min_trust?: number
   limit?: number

package/tests/refine.test.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect } from 'vitest'
+import { refineQuery } from '../src/refine.js'
+
+describe('refineQuery', () => {
+  it('filters action words from Chinese query', () => {
+    const result = refineQuery('帮我用 TypeScript 重构 auth 模块')
+    expect(result).not.toBeNull()
+    expect(result!.query).toContain('TypeScript')
+    expect(result!.query).toContain('auth')
+    expect(result!.query).not.toContain('帮我')
+    expect(result!.query).not.toContain('重构')
+  })
+
+  it('returns null for pure operation commands', () => {
+    expect(refineQuery('运行测试')).toBeNull()
+    expect(refineQuery('git status')).toBeNull()
+    expect(refineQuery('创建文件')).toBeNull()
+  })
+
+  it('extracts quoted Chinese entities', () => {
+    const result = refineQuery('我喜欢「深色主题」')
+    expect(result).not.toBeNull()
+    expect(result!.entityTokens).toContain('深色主题')
+    expect(result!.query).toContain('深色主题')
+  })
+
+  it('extracts book title entities', () => {
+    const result = refineQuery('读了《设计模式》这本书')
+    expect(result).not.toBeNull()
+    expect(result!.entityTokens).toContain('设计模式')
+  })
+
+  it('extracts capitalized English phrases', () => {
+    const result = refineQuery('使用 Visual Studio Code 编辑器')
+    expect(result).not.toBeNull()
+    expect(result!.entityTokens).toContain('Visual Studio Code')
+  })
+
+  it('returns null for empty string', () => {
+    expect(refineQuery('')).toBeNull()
+    expect(refineQuery('   ')).toBeNull()
+  })
+
+  it('preserves meaningful Chinese tokens', () => {
+    const result = refineQuery('用户偏好深色主题')
+    expect(result).not.toBeNull()
+    expect(result!.query).toContain('用户')
+    expect(result!.query).toContain('偏好')
+    expect(result!.query).toContain('深色')
+    expect(result!.query).toContain('主题')
+  })
+})

package/tests/resource.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { MemoryStore } from '../src/store.js'
+import { ResourceManager } from '../src/resources.js'
+import { mkdtempSync, rmSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+
+let store: MemoryStore
+let manager: ResourceManager
+let tmpDir: string
+
+beforeEach(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), 'mnemo-test-'))
+  store = new MemoryStore(join(tmpDir, 'test.db'))
+  manager = new ResourceManager(store)
+})
+
+afterEach(() => {
+  store.close()
+  rmSync(tmpDir, { recursive: true, force: true })
+})
+
+describe('ResourceManager', () => {
+  it('returns empty array for empty category', () => {
+    const facts = manager.getFacts('identity')
+    expect(facts).toEqual([])
+  })
+
+  it('returns facts ordered by trust score', () => {
+    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)
+  })
+
+  it('caches results', () => {
+    store.addFact('测试事实', 'general')
+    manager.getFacts('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', () => {
+    store.addFact('测试事实', 'general')
+    manager.getFacts('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)
+  })
+})

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,115 @@ 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 high retrieval low helpful facts', () => {
+    const id = store.addFact('demote me', 'general')
+    store.connection.prepare('UPDATE facts SET retrieval_count = 100, helpful_count = 2, 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('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)
+  })
+})