@morningljn/mnemo 0.2.1 → 0.3.0

package/src/store.ts

@@ -15,6 +15,9 @@ import { mkdirSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { SCHEMA } from './schema.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
@@ -875,7 +878,7 @@ export class MemoryStore {
             const tokensB = this.tokenizeForDedup(rows[j].content)
             const sim = this.jaccardSimilarity(tokensA, tokensB)
 
-            if (sim > 0.6) {
+            if (sim > 0.4) {
               const aHighFreq = rows[i].retrieval_count > 100
               const bHighFreq = rows[j].retrieval_count > 100
 
@@ -914,14 +917,14 @@ export class MemoryStore {
         { keywords: ['偏好', 'VS Code', '编辑器', 'IDE', '快捷键'], target: 'tool_pref' },
       ]
 
+      // 只从 general 分类移动，避免已分类 fact 被反复震荡
       const rows = this.db.prepare(
-        'SELECT fact_id, content, category FROM facts'
+        "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.target === row.category) continue
           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++
@@ -933,16 +936,43 @@ export class MemoryStore {
     })()
   }
 
-  /** 执行完整 dream cycle：备份 → 压缩 → 合并 → 重分类 → 报告 */
+  /** 执行完整 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,
@@ -958,11 +988,13 @@ export class MemoryStore {
     }
 
     return {
-      merged: mergeResult.merged,
+      merged,
       compressed,
       reclassified,
-      deleted: mergeResult.merged,
-      mergeDetails: mergeResult.details,
+      deleted: merged,
+      mergeDetails,
+      fallback,
+      fallbackReason,
       health: {
         total: stats.total,
         avg_trust: Math.round((stats.avg_trust ?? 0) * 100) / 100,

package/src/types.ts

@@ -90,6 +90,8 @@ export interface DreamReport {
   reclassified: number
   deleted: number
   mergeDetails: Array<{ kept: number; removed: number; similarity: number }>
+  fallback?: boolean
+  fallbackReason?: string
   health: {
     total: number
     avg_trust: number
@@ -106,3 +108,17 @@ export interface CompactFactResult {
   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/store.test.ts

@@ -309,16 +309,16 @@ describe('dream - merge', () => {
 })
 
 describe('dream - reclassify', () => {
-  it('moves miscategorized facts by keywords', () => {
-    const id = store.addFact('编码规范：文件不超过 500 行', 'identity')
+  it('moves miscategorized facts from general to correct category', () => {
+    const id = store.addFact('编码规范：文件不超过 500 行', 'general')
     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')
+  it('skips already categorized facts', () => {
+    store.addFact('编码规范：文件不超过 500 行', 'coding_style')
     const result = store.reclassifyFacts()
     expect(result).toBe(0)
   })
@@ -331,7 +331,7 @@ describe('dream - runDream', () => {
     // 重叠 fact（触发合并）
     store.addFact('用户偏好使用 TypeScript 开发前端代码', 'coding_style')
     // 分类错误 fact（触发重分类）
-    store.addFact('编码规范：文件不超过 500 行', 'identity')
+    store.addFact('编码规范：文件不超过 500 行', 'general')
 
     const report = await store.runDream({ skipBackup: true })
     expect(report.compressed).toBeGreaterThanOrEqual(0)
@@ -339,5 +339,6 @@ describe('dream - runDream', () => {
     expect(report.reclassified).toBeGreaterThanOrEqual(0)
     expect(report.health.total).toBeGreaterThanOrEqual(1)
     expect(report.health.coverage).toBeTruthy()
+    expect(report.fallback).toBe(true) // 测试环境无 Ollama，应降级到规则引擎
   })
 })