@morningljn/mnemo 0.2.0 → 0.3.0

package/src/dream-engine.ts

@@ -0,0 +1,162 @@
+import type { FactCategory, LLMMessage } from './types.js'
+import type { LLMClient } from './llm-client.js'
+import type { MemoryStore } from './store.js'
+
+const BATCH_SIZE = 20
+const MAX_DELETE_RATIO = 0.1
+const TRUST_DELETE_LIMIT = 0.8
+const RETRIEVAL_DELETE_LIMIT = 100
+
+export class DreamEngine {
+  constructor(private llm: LLMClient, private store: MemoryStore) {}
+
+  async semanticMerge(): Promise<{
+    merged: number
+    details: Array<{ kept: number; removed: number; reason: string }>
+  }> {
+    const categories: FactCategory[] = ['identity', 'coding_style', 'tool_pref', 'workflow', 'general']
+    let merged = 0
+    const details: Array<{ kept: number; removed: number; reason: string }> = []
+
+    const totalFacts = this.store.getTotalCount()
+    const maxDeletes = Math.max(1, Math.floor(totalFacts * MAX_DELETE_RATIO))
+
+    for (const cat of categories) {
+      const facts = this.store.listFacts(cat, 0, 200)
+      if (facts.length < 2) continue
+
+      for (let i = 0; i < facts.length; i += BATCH_SIZE) {
+        const batch = facts.slice(i, i + BATCH_SIZE)
+        const factList = batch.map(f => `[${f.factId}] ${f.content}`).join('\n')
+
+        const messages: LLMMessage[] = [
+          {
+            role: 'system',
+            content: `你是一个记忆整理助手。分析以下同一分类(${cat})的记忆条目，找出语义重复的条目对。
+只输出JSON，格式：{"merges": [{"kept": 保留的fact_id, "removed": 删除的fact_id, "reason": "原因"}]}
+如果没有语义重复的条目，输出：{"merges": []}
+规则：
+- 保留内容更完整、信息量更大的条目
+- 用词不同但意思相同的条目应合并（如"喜欢VS Code"和"偏好Visual Studio Code"）
+- 不要合并只是主题相关但内容不同的条目`,
+          },
+          { role: 'user', content: factList },
+        ]
+
+        try {
+          const result = await this.llm.chatJSON<{ merges: Array<{ kept: number; removed: number; reason: string }> }>(messages)
+          if (!result?.merges || !Array.isArray(result.merges)) continue
+
+          for (const merge of result.merges) {
+            if (merged >= maxDeletes) break
+            if (!merge.kept || !merge.removed) continue
+
+            const toRemove = this.store.listFacts(cat, 0, 200).find(f => f.factId === merge.removed)
+            if (!toRemove) continue
+            if (toRemove.trustScore > TRUST_DELETE_LIMIT) continue
+            if (toRemove.retrievalCount > RETRIEVAL_DELETE_LIMIT) continue
+
+            const toKeep = this.store.listFacts(cat, 0, 200).find(f => f.factId === merge.kept)
+            if (!toKeep) continue
+
+            this.store.removeFact(merge.removed)
+            details.push({ kept: merge.kept, removed: merge.removed, reason: merge.reason })
+            merged++
+          }
+        } catch {
+          continue
+        }
+      }
+    }
+
+    return { merged, details }
+  }
+
+  async smartCompress(): Promise<number> {
+    const rows = this.store.connection.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 }>
+
+    if (rows.length === 0) return 0
+
+    let compressed = 0
+
+    for (let i = 0; i < rows.length; i += BATCH_SIZE) {
+      const batch = rows.slice(i, i + BATCH_SIZE)
+      const factList = batch.map(f => `[${f.fact_id}] ${f.content}`).join('\n\n---\n\n')
+
+      const messages: LLMMessage[] = [
+        {
+          role: 'system',
+          content: `你是一个记忆摘要助手。为每条记忆生成简洁的摘要（≤150字）。
+摘要应保留核心信息：谁/什么/关键决策/关键数据。去除示例、过程描述、冗余细节。
+输出JSON：{"summaries": [{"fact_id": 数字, "summary": "摘要内容"}]}`,
+        },
+        { role: 'user', content: factList },
+      ]
+
+      try {
+        const result = await this.llm.chatJSON<{ summaries: Array<{ fact_id: number; summary: string }> }>(messages)
+        if (!result?.summaries || !Array.isArray(result.summaries)) continue
+
+        for (const item of result.summaries) {
+          if (!item.fact_id || !item.summary) continue
+          const truncated = item.summary.length > 150 ? item.summary.slice(0, 147) + '...' : item.summary
+          this.store.connection.prepare('UPDATE facts SET summary = ? WHERE fact_id = ?').run(truncated, item.fact_id)
+          compressed++
+        }
+      } catch {
+        continue
+      }
+    }
+
+    return compressed
+  }
+
+  async smartReclassify(): Promise<number> {
+    const rows = this.store.connection.prepare(
+      "SELECT fact_id, content FROM facts WHERE category = 'general'"
+    ).all() as Array<{ fact_id: number; content: string }>
+
+    if (rows.length === 0) return 0
+
+    const validCategories = ['identity', 'coding_style', 'tool_pref', 'workflow']
+    let reclassified = 0
+
+    for (let i = 0; i < rows.length; i += BATCH_SIZE) {
+      const batch = rows.slice(i, i + BATCH_SIZE)
+      const factList = batch.map(f => `[${f.fact_id}] ${f.content}`).join('\n')
+
+      const messages: LLMMessage[] = [
+        {
+          role: 'system',
+          content: `你是一个记忆分类助手。分析以下记忆条目，判断它们应该属于哪个分类。
+可选分类：identity（身份/角色）、coding_style（编码规范）、tool_pref（工具偏好）、workflow（工作流）
+如果记忆不属于以上任何分类，保持 general。
+输出JSON：{"reclassify": [{"fact_id": 数字, "to": "分类名"}]}
+不需要重新分类的条目不要输出。`,
+        },
+        { role: 'user', content: factList },
+      ]
+
+      try {
+        const result = await this.llm.chatJSON<{ reclassify: Array<{ fact_id: number; to: string }> }>(messages)
+        if (!result?.reclassify || !Array.isArray(result.reclassify)) continue
+
+        for (const item of result.reclassify) {
+          if (!item.fact_id || !item.to) continue
+          if (!validCategories.includes(item.to)) continue
+
+          this.store.connection.prepare(
+            "UPDATE facts SET category = ?, updated_at = datetime('now', 'localtime') WHERE fact_id = ?"
+          ).run(item.to, item.fact_id)
+          reclassified++
+        }
+      } catch {
+        continue
+      }
+    }
+
+    return reclassified
+  }
+}

package/src/dream.ts

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+import { MemoryStore } from './store.js'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+
+const dbPath = join(homedir(), '.mnemo', 'facts.db')
+const store = new MemoryStore(dbPath)
+
+try {
+  console.log('[mnemo dream] 开始整理记忆库...\n')
+  const report = await store.runDream()
+  console.log(JSON.stringify(report, null, 2))
+  console.log(`\n[mnemo dream] 完成: merged=${report.merged} compressed=${report.compressed} reclassified=${report.reclassified} deleted=${report.deleted}`)
+} catch (err) {
+  console.error('[mnemo dream] error:', err)
+  process.exit(1)
+} finally {
+  store.close()
+}

package/src/init.ts

@@ -19,32 +19,12 @@ const CLAUDE_MD_PATH = join(CLAUDE_DIR, 'CLAUDE.md')
 const SETTINGS_PATH = join(CLAUDE_DIR, 'settings.json')
 
 const MEMORY_RULES = `
-# 记忆系统使用规则
 
-你有 mnemo 记忆工具（fact_store / fact_feedback），必须按以下规则使用：
+# mnemo 记忆系统
 
-## 规则 1：会话预热（自动）
-会话启动时，mnemo-mcp 的 MCP Resource 会自动注入全局记忆到 system context。
-你不需要主动调用 fact_store(search) 来获取高频记忆。
-
-## 规则 2：按需补充查询
-仅在以下情况调用 \`fact_store(action="search")\`：
-- 用户消息涉及个人偏好/习惯/工具选择且预热中未覆盖
-- 用户明确查询记忆（"我之前说过什么""按我的习惯"）
-- 技术选型时需要确认用户偏好
-
-不触发查询的情况：
-- 纯操作指令（"运行测试""git commit"）
-- 通用技术问题（"Promise 怎么用"）
-- 代码审查/解释请求
-
-## 规则 3：写入记忆
-用户说"记住"、"记下来"时，调用 \`fact_store(action="add", content="...", category="...")\`。
-- 先 search 检查是否已有相似事实，有则 update
-- category：identity / coding_style / tool_pref / workflow / general
-
-## 规则 4：反馈强化
-成功使用某条记忆时，调用 \`fact_feedback(action="helpful", fact_id=...)\`。
+- 身份问题（"你是谁"等）→ 先 fact_store(search, query="角色设定")，按设定回答
+- 用户说"记住"→ fact_store(add)，先 search 去重
+- 成功使用记忆 → fact_feedback(helpful, fact_id)
 `
 
 const MCP_TOOLS = [

package/src/llm-client.ts

@@ -0,0 +1,59 @@
+import type { LLMConfig, LLMMessage } from './types.js'
+
+export class LLMClient {
+  constructor(private config: LLMConfig) {}
+
+  async chat(messages: LLMMessage[], options?: { temperature?: number }): Promise<string> {
+    const url = `${this.config.baseUrl}/chat/completions`
+    const headers: Record<string, string> = { 'Content-Type': 'application/json' }
+    if (this.config.apiKey) {
+      headers['Authorization'] = `Bearer ${this.config.apiKey}`
+    }
+
+    const resp = await fetch(url, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({
+        model: this.config.model,
+        messages,
+        temperature: options?.temperature ?? this.config.temperature,
+        stream: false,
+      }),
+    })
+
+    if (!resp.ok) {
+      throw new Error(`LLM request failed: ${resp.status} ${await resp.text()}`)
+    }
+
+    const data = (await resp.json()) as {
+      choices: Array<{ message: { content: string } }>
+    }
+    return data.choices[0]?.message?.content ?? ''
+  }
+
+  async chatJSON<T = unknown>(messages: LLMMessage[]): Promise<T> {
+    const text = await this.chat(messages)
+    try {
+      return JSON.parse(text)
+    } catch {
+      const match = text.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/)
+      if (match) {
+        return JSON.parse(match[1].trim())
+      }
+      throw new Error(`LLM response is not valid JSON: ${text.slice(0, 200)}`)
+    }
+  }
+
+  async isAvailable(): Promise<boolean> {
+    try {
+      const url = `${this.config.baseUrl}/models`
+      const resp = await fetch(url, {
+        method: 'GET',
+        signal: AbortSignal.timeout(3000),
+      })
+      return resp.ok
+    } catch {
+      return false
+    }
+  }
+}

package/src/resources.ts

@@ -1,6 +1,9 @@
 /**
  * MCP Resource manager for mnemo-mcp.
- * Exposes per-category memory summaries as MCP Resources for session warmup injection.
+ * Exposes per-category memory as MCP Resources for session warmup injection.
+ *
+ * identity → 指令格式（Claude 应遵循的行为设定）
+ * 其他     → 参考格式（供 Claude 查阅的用户偏好）
  */
 
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
@@ -8,7 +11,7 @@ import type { MemoryStore } from './store.js'
 import type { FactCategory } from './types.js'
 
 const CATEGORIES: FactCategory[] = ['identity', 'coding_style', 'tool_pref', 'workflow', 'general']
-const RESOURCE_LIMIT = 10
+const RESOURCE_LIMIT = 15
 
 export interface ResourceFact {
   fact_id: number
@@ -17,13 +20,12 @@ export interface ResourceFact {
 }
 
 export class ResourceManager {
-  private cache = new Map<FactCategory, ResourceFact[]>()
+  private cache = new Map<FactCategory, string>()
 
   constructor(
     private store: MemoryStore,
   ) {}
 
-  /** Register all category resources with the MCP server */
   registerResources(server: McpServer): void {
     for (const category of CATEGORIES) {
       const uri = `mnemo://global/${category}`
@@ -32,46 +34,100 @@ export class ResourceManager {
         uri,
         {
           description: `${category} category global facts (top ${RESOURCE_LIMIT} by trust)`,
-          mimeType: 'application/json',
+          mimeType: 'text/markdown',
         },
         async () => this.readCategory(category),
       )
     }
   }
 
-  /** Read handler for a specific category */
-  private readCategory(category: FactCategory): { contents: Array<{ uri: string; mimeType: string; text: string }> } {
-    const facts = this.getFacts(category)
+  /** Read handler for a specific category (public for server instructions) */
+  readCategory(category: FactCategory): { contents: Array<{ uri: string; mimeType: string; text: string }> } {
+    const text = this.getFormattedFacts(category)
     return {
       contents: [{
         uri: `mnemo://global/${category}`,
-        mimeType: 'application/json',
-        text: JSON.stringify(facts, null, 2),
+        mimeType: 'text/markdown',
+        text,
       }],
     }
   }
 
-  /** Get facts for a category — with caching */
-  getFacts(category: FactCategory): ResourceFact[] {
+  private getFormattedFacts(category: FactCategory): string {
     const cached = this.cache.get(category)
     if (cached) return cached
 
-    const facts = this.store.listFacts(category, 0.0, RESOURCE_LIMIT).map(f => ({
-      fact_id: f.factId,
-      content: f.content,
-      trust_score: f.trustScore,
-    }))
+    const facts = this.store.listFacts(category, 0.0, RESOURCE_LIMIT)
+    const text = category === 'identity'
+      ? this.formatAsInstructions(facts)
+      : this.formatAsReference(facts, category)
 
-    this.cache.set(category, facts)
-    return facts
+    this.cache.set(category, text)
+    return text
+  }
+
+  /**
+   * identity 类事实格式化为指令——Claude 应直接遵循这些设定。
+   * 角色设定排在最前面，用祈使句。
+   */
+  private formatAsInstructions(facts: ReturnType<MemoryStore['listFacts']>): string {
+    const lines: string[] = ['# 身份与行为设定', '', '以下是你的身份设定和用户偏好，请直接遵循：', '']
+
+    // 角色/身份相关的 fact 排在最前面
+    const roleFacts = facts.filter(f =>
+      f.content.includes('角色设定') ||
+      f.content.includes('你是') ||
+      f.content.includes('身份是') ||
+      f.content.includes('你扮演')
+    )
+    const otherFacts = facts.filter(f => !roleFacts.includes(f))
+
+    if (roleFacts.length > 0) {
+      lines.push('## 你的身份')
+      for (const f of roleFacts) {
+        // 把描述性语句转为指令
+        const content = f.content
+          .replace(/^AI角色设定[：:]/, '')
+          .replace(/^你是/, '')
+          .trim()
+        lines.push(`- ${content}`)
+      }
+      lines.push('')
+    }
+
+    if (otherFacts.length > 0) {
+      lines.push('## 用户信息')
+      for (const f of otherFacts) {
+        lines.push(`- ${f.content}`)
+      }
+    }
+
+    return lines.join('\n')
+  }
+
+  /**
+   * 非 identity 类事实格式化为参考——供 Claude 查阅但不强制遵循。
+   */
+  private formatAsReference(facts: ReturnType<MemoryStore['listFacts']>, category: string): string {
+    const title: Record<string, string> = {
+      coding_style: '编码风格偏好',
+      tool_pref: '工具偏好',
+      workflow: '工作流偏好',
+      general: '通用知识',
+    }
+    const lines: string[] = [`# ${title[category] ?? category}`, '']
+
+    for (const f of facts) {
+      lines.push(`- ${f.content}`)
+    }
+
+    return lines.join('\n')
   }
 
-  /** Invalidate all caches — call after any write operation */
   invalidate(): void {
     this.cache.clear()
   }
 
-  /** Get cache entry count for debugging */
   cacheSize(): number {
     return this.cache.size
   }

package/src/retriever.ts

@@ -437,15 +437,19 @@ export class FactRetriever {
     const ftsParts: string[] = []
 
     for (const word of parts) {
-      ftsParts.push(`"${word}"`)
-      // 对中文部分追加 bigram
-      const cnChars = word.match(/[\u4e00-\u9fff]+/g)
+      const cnChars = word.match(/[一-鿿]+/g)
       if (cnChars) {
+        // 中文部分：trigram tokenizer 需要至少 3 字符
         for (const seg of cnChars) {
-          for (let i = 0; i < seg.length - 1; i++) {
-            ftsParts.push(seg.slice(i, i + 2))
+          if (seg.length >= 3) ftsParts.push(seg)
+          // 提取 trigram（3 字符子串）
+          for (let i = 0; i <= seg.length - 3; i++) {
+            ftsParts.push(seg.slice(i, i + 3))
           }
         }
+      } else {
+        // 非中文部分：用引号包裹（短语匹配），至少 1 字符
+        if (word.length >= 1) ftsParts.push(`"${word}"`)
       }
     }
 

package/src/schema.ts

@@ -46,9 +46,9 @@ CREATE INDEX IF NOT EXISTS idx_entities_name  ON entities(name);
 CREATE INDEX IF NOT EXISTS idx_fact_entities_entity ON fact_entities(entity_id);
 CREATE INDEX IF NOT EXISTS idx_retrieval_log_ts ON retrieval_log(timestamp);
 
--- FTS5 全文索引（含 summary 列）
+-- FTS5 全文索引（trigram tokenizer 支持中文子串匹配）
 CREATE VIRTUAL TABLE IF NOT EXISTS 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');
 
 -- FTS5 同步触发器：插入
 CREATE TRIGGER IF NOT EXISTS facts_ai AFTER INSERT ON facts BEGIN

package/src/server.ts

@@ -9,7 +9,7 @@ import { MemoryStore } from './store.js'
 import { FactRetriever } from './retriever.js'
 import { ResourceManager } from './resources.js'
 import { fullSecurityScan } from './security.js'
-import type { FactStoreArgs, FactFeedbackArgs, FactCategory } from './types.js'
+import type { FactStoreArgs, FactFeedbackArgs, FactCategory, ScoredFact, CompactFactResult } from './types.js'
 
 const FACT_STORE_DESCRIPTION = `结构化事实记忆系统（SQLite+FTS5 索引）。支持读写。
 
@@ -27,7 +27,7 @@ const FACT_STORE_DESCRIPTION = `结构化事实记忆系统（SQLite+FTS5 索引
 写入时先 search 检查是否已存在相似事实。identity/coding_style/tool_pref/workflow/general → 全局库，project → 项目库。`
 
 const factStoreSchema = {
-  action: z.enum(['add', 'search', 'probe', 'related', 'reason', 'contradict', 'update', 'remove', 'list', 'learn', 'audit']),
+  action: z.enum(['add', 'search', 'probe', 'related', 'reason', 'contradict', 'update', 'remove', 'list', 'learn', 'audit', 'dream']),
   content: z.union([z.string(), z.array(z.string())]).optional().describe("事实内容（'add' 必需，支持批量）"),
   summary: z.string().optional().describe('超长事实的摘要（检索用 summary 匹配）'),
   query: z.string().optional().describe("搜索查询（'search' 必需）"),
@@ -52,6 +52,16 @@ function resolveCategory(category?: string): FactCategory {
   return valid.includes(category as FactCategory) ? (category as FactCategory) : 'general'
 }
 
+function toCompactResult(f: ScoredFact): CompactFactResult {
+  return {
+    factId: f.factId,
+    display: f.summary ?? (f.content.length > 100 ? f.content.slice(0, 100) + '...' : f.content),
+    category: f.category,
+    trustScore: Math.round(f.trustScore * 100) / 100,
+    score: Math.round(f.score * 1000) / 1000,
+  }
+}
+
 const minTrust = 0.3
 
 // -- Initialize store + retriever --
@@ -76,7 +86,25 @@ process.nextTick(() => {
 })
 
 // -- MCP Server --
-const server = new McpServer({ name: 'mnemo-mcp', version: '0.1.0' })
+// 动态生成 instructions：将 identity resource 中的角色设定作为 system prompt 指令注入
+function buildInstructions(): string {
+  try {
+    const rm = new ResourceManager(store)
+    const result = rm.readCategory('identity')
+    const identityText = result.contents[0]?.text ?? ''
+    if (identityText.length > 10) {
+      return identityText
+    }
+  } catch {
+    // fallback：无 identity 数据时不注入
+  }
+  return ''
+}
+
+const server = new McpServer(
+  { name: 'mnemo-mcp', version: '0.1.0' },
+  { instructions: buildInstructions() },
+)
 
 // -- MCP Resources: 会话预热注入 --
 const resourceManager = new ResourceManager(store)
@@ -136,26 +164,30 @@ server.tool(
         case 'search': {
           if (!a.query) return { content: [{ type: 'text' as const, text: JSON.stringify({ error: 'Missing required argument: query' }) }] }
           const results = retriever.search(a.query, { category: a.category ? category : undefined, minTrust: a.min_trust ?? minTrust, limit: a.limit ?? 10 })
-          return { content: [{ type: 'text' as const, text: JSON.stringify({ results, count: results.length }) }] }
+          const compact = results.map(toCompactResult)
+          return { content: [{ type: 'text' as const, text: JSON.stringify({ results: compact, count: compact.length }) }] }
         }
 
         case 'probe': {
           if (!a.entity) return { content: [{ type: 'text' as const, text: JSON.stringify({ error: 'Missing required argument: entity' }) }] }
           const results = retriever.probe(a.entity, { minTrust: a.min_trust ?? minTrust, limit: a.limit ?? 10 })
-          return { content: [{ type: 'text' as const, text: JSON.stringify({ results, count: results.length }) }] }
+          const compact = results.map(toCompactResult)
+          return { content: [{ type: 'text' as const, text: JSON.stringify({ results: compact, count: compact.length }) }] }
         }
 
         case 'related': {
           if (!a.entity) return { content: [{ type: 'text' as const, text: JSON.stringify({ error: 'Missing required argument: entity' }) }] }
           const results = retriever.related(a.entity, { minTrust: a.min_trust ?? minTrust, limit: a.limit ?? 10 })
-          return { content: [{ type: 'text' as const, text: JSON.stringify({ results, count: results.length }) }] }
+          const compact = results.map(toCompactResult)
+          return { content: [{ type: 'text' as const, text: JSON.stringify({ results: compact, count: compact.length }) }] }
         }
 
         case 'reason': {
           const entities = a.entities ?? []
           if (entities.length === 0) return { content: [{ type: 'text' as const, text: JSON.stringify({ error: "reason requires 'entities' list" }) }] }
           const results = retriever.reason(entities, { minTrust: a.min_trust ?? minTrust, limit: a.limit ?? 10 })
-          return { content: [{ type: 'text' as const, text: JSON.stringify({ results, count: results.length }) }] }
+          const compact = results.map(toCompactResult)
+          return { content: [{ type: 'text' as const, text: JSON.stringify({ results: compact, count: compact.length }) }] }
         }
 
         case 'contradict': {
@@ -194,6 +226,13 @@ server.tool(
           return { content: [{ type: 'text' as const, text: JSON.stringify(report) }] }
         }
 
+        case 'dream': {
+          const report = await store.runDream()
+          retriever.getCache().clear()
+          resourceManager.invalidate()
+          return { content: [{ type: 'text' as const, text: JSON.stringify(report) }] }
+        }
+
         case 'list': {
           const facts = store.listFacts(category, a.min_trust ?? 0.0, a.limit ?? 10)
           return { content: [{ type: 'text' as const, text: JSON.stringify({ facts, count: facts.length }) }] }