dsh-lite-memory 0.18.19 → 0.18.26

package/test/state.test.mjs

@@ -23,6 +23,11 @@ const test = (name, fn) => {
 };
 
 const dirs = [];
+/** Windows 会把同一个临时目录报成 8.3 短名或长名；按目录的文件 ID 判断是不是同一处。 */
+const pathId = (target) => {
+  const stat = fs.statSync(target, { bigint: true });
+  return `${stat.dev}:${stat.ino}`;
+};
 const fresh = (label) => {
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), `lm-state-${label}-`));
   dirs.push(dir);
@@ -218,9 +223,7 @@ test('S01 仓库根与子目录共用一份记忆', () => {
   const atSub = scopeOf(sub);
   assert.equal(atSub.key, atRoot.key);
   assert.equal(atSub.dir, atRoot.dir);
-  /* Windows reports the temp root as an 8.3 short name on one side and the long
-     name on the other; compare what both of them resolve to. */
-  assert.equal(fs.realpathSync(resolveRoot(sub).root), fs.realpathSync(repo));
+  assert.equal(pathId(resolveRoot(sub).root), pathId(repo));
 });
 
 test('S02 符号链接、非 Git 目录、嵌套仓库各归各的', () => {
@@ -251,7 +254,7 @@ test('S03 配置的项目根只覆盖自己的子树，不吞别的目录', () =
   fs.mkdirSync(path.dirname(config), { recursive: true });
   fs.writeFileSync(config, JSON.stringify({ projectRoot: root }));
   try {
-    assert.equal(resolveRoot(sub).root, fs.realpathSync(root));
+    assert.equal(pathId(resolveRoot(sub).root), pathId(root));
     assert.equal(resolveRoot(sub).source, 'configured');
     assert.equal(scopeOf(sub).key, scopeOf(root).key);
     assert.notEqual(resolveRoot(outside).source, 'configured');
@@ -327,7 +330,7 @@ test('S10 旧库迁移：正文、归档、旧标题一起搬进状态', () => {
   const loaded = load(scope).state;
   assert.equal(loaded.entries.length, 4);
   assert.equal(loaded.migration.fromVersion, 1);
-  assert.equal(bodyOf(scope, 'mem_111111111111'), '第一步跑测试\n第二步改版本号');
+  assert.equal(bodyOf(scope, 'mem_111111111111').replace(/\r\n/g, '\n'), '第一步跑测试\n第二步改版本号');
   const archived = loaded.entries.find((entry) => entry.id === 'mem_444444444444');
   assert.equal(archived.status, 'archived');
   assert.equal(archived.current.body, '归档正文');

package/test/store.test.mjs

@@ -142,6 +142,26 @@ test('same title with a different when is a second entry', () => {
   assert.equal(again.record.id, b.record.id);
 });
 
+test('expired or superseded records do not block a new same-title save', () => {
+  const scope = fresh('stale-merge');
+  const first = upsert(scope, { title: '旧结论', summary: '这条已经过期', topicKey: 'old-topic', body: '旧' });
+  const expired = loadIndex(scope);
+  expired.entries.find((row) => row.id === first.record.id).validUntil = new Date(Date.now() - 1000).toISOString();
+  saveIndex(scope, expired);
+  const next = upsert(scope, { title: '旧结论', summary: '新结论应该另存', topicKey: 'old-topic', body: '新' });
+  assert.equal(next.needsResolution, false);
+  assert.equal(next.merged, false);
+  assert.notEqual(next.record.id, first.record.id);
+
+  const second = upsert(scope, { title: '被取代的结论', summary: '已经被新版本取代', body: '旧' });
+  const superseded = loadIndex(scope);
+  superseded.entries.find((row) => row.id === second.record.id).supersededBy = 'later';
+  saveIndex(scope, superseded);
+  const replacement = upsert(scope, { title: '被取代的结论', summary: '沿同名标题重写', body: '新' });
+  assert.equal(replacement.needsResolution, false);
+  assert.notEqual(replacement.record.id, second.record.id);
+});
+
 test('oversized body is rejected, old data untouched', () => {
   const scope = fresh('oversize');
   const big = 'x'.repeat(LIMITS.entryBytes + 1);
@@ -1069,6 +1089,24 @@ test('归属路由：本机痕迹的「通用流程」留在项目层，干净
   assert.equal(evidencePath.chosenScope, 'project', '依据本身是本机文件不算普适证据');
   assert.equal(evidencePath.reasonCode, 'machine_bound_procedure');
 
+  const scopedProcedure = store.routeScope({
+    title: 'npm 操作走 dsh-npm', summary: '本机 npm 命令用包装脚本',
+    body: '本机 npm 一律用 dsh-npm；裸 npm 报 ENEEDAUTH 不是缺凭据',
+    memoryClass: 'portable_procedure',
+    conditions: [{ key: 'machine', value: 'macOS 桌面机' }],
+  }, { project });
+  assert.equal(scopedProcedure.chosenScope, 'global', '声明了机器条件的本机流程可进全局层');
+  assert.equal(scopedProcedure.reasonCode, 'machine_scoped_procedure');
+
+  const scopedExplicit = store.routeScope({
+    title: 'npm 操作走 dsh-npm', summary: '本机 npm 命令用包装脚本',
+    body: '本机 npm 一律用 dsh-npm；裸 npm 报 ENEEDAUTH 不是缺凭据',
+    memoryClass: 'portable_procedure', scope: 'global',
+    conditions: [{ key: 'machine', value: 'macOS 桌面机' }],
+  }, { project });
+  assert.equal(scopedExplicit.chosenScope, 'global');
+  assert.equal(scopedExplicit.reasonCode, 'explicit');
+
   const unconfirmed = store.routeScope({
     title: '部署脚本', summary: '本机部署脚本', body: 'bash /tmp/deploy.sh',
     memoryClass: 'portable_procedure', scope: 'global',
@@ -1091,12 +1129,21 @@ test('归属路由：本机痕迹的「通用流程」留在项目层，干净
   assert.equal(modelGlobalFact.chosenScope, 'project', '模型自填 global 不能把项目事实送进全局层');
   assert.equal(modelGlobalFact.reasonCode, 'model_global_project_fact');
 
-  const modelGlobalProcedure = store.routeScope({
+  /** 显式 global 是用户要的那一层：没 evidenceRef 也只代表模型没补依据，不能把它降回项目层。 */
+  const userGlobalProcedure = store.routeScope({
     title: '提交前跑测试', summary: '提交前跑测试', body: 'pnpm test',
     memoryClass: 'portable_procedure', scope: 'global',
   }, { project });
-  assert.equal(modelGlobalProcedure.chosenScope, 'project', '模型自填 global 少了依据也不能进全局层');
-  assert.equal(modelGlobalProcedure.reasonCode, 'unbound_evidence');
+  assert.equal(userGlobalProcedure.chosenScope, 'global');
+  assert.equal(userGlobalProcedure.reasonCode, 'explicit');
+
+  /** 没显式 scope 时，memoryClass 只是提案：缺可搬依据的流程仍留在项目层。 */
+  const classOnlyProcedure = store.routeScope({
+    title: '提交前跑测试', summary: '提交前跑测试', body: 'pnpm test',
+    memoryClass: 'portable_procedure',
+  }, { project });
+  assert.equal(classOnlyProcedure.chosenScope, 'project', '没有显式 scope 又缺依据，不能自己搬去全局层');
+  assert.equal(classOnlyProcedure.reasonCode, 'unbound_evidence');
 });
 
 test('几百条归档的正文不进热状态，下一次保存照样能过', () => {

package/view.js

@@ -309,17 +309,37 @@ function wordsOf(text) {
   } catch {
     for (const word of plainText.split(/[^\p{L}\p{N}]+/u)) if (word && !STOPWORDS.has(word)) out.push(word);
   }
-  /** 本机 ICU 缺中文词典时整句会被切成单字；补上二元组，别让「这」这种单字当整词。 */
-  if (!/[a-z]/i.test(plainText) && out.some((word) => [...word].length === 1)) {
-    const chars = plainText.replace(/[^\p{L}\p{N}]+/gu, '');
-    for (let i = 0; i + 1 < chars.length; i += 1) {
-      const gram = chars.slice(i, i + 2);
-      if (!STOPWORDS.has(gram)) out.push(gram);
+  /** 本机 ICU 缺中文词典时中文会被切成单字；只在出现单字时才补中文二元组，别让二元组把查询的实词数量撑大。 */
+  if (out.some((word) => [...word].length === 1 && /[\u4e00-\u9fff]/.test(word))) {
+    for (const run of plainText.split(/[^\u4e00-\u9fff]+/)) {
+      for (let i = 0; i + 1 < run.length; i += 1) {
+        const gram = run.slice(i, i + 2);
+        if (!STOPWORDS.has(gram)) out.push(gram);
+      }
     }
   }
   return out.slice(0, 48);
 }
 
+/** 只取切词给出的多字实词：本机 ICU 切成单字时返回空，说明这句子没有可靠词边界。 */
+function contentWordsOf(text) {
+  const plainText = plain(text, 400).toLowerCase();
+  const out = [];
+  try {
+    const segmenter = new Intl.Segmenter('zh', { granularity: 'word' });
+    for (const part of segmenter.segment(plainText)) {
+      const word = part.segment.trim();
+      if ([...word].length < 2 || !/[\p{L}\p{N}]/u.test(word)) continue;
+      if (!STOPWORDS.has(word)) out.push(word);
+    }
+  } catch {
+    for (const word of plainText.split(/[^\p{L}\p{N}]+/u)) {
+      if ([...word].length >= 2 && !STOPWORDS.has(word)) out.push(word);
+    }
+  }
+  return out;
+}
+
 /** 纯英文查询按整词判断：git 不该命中 digital。自动召回和手动搜索共用这一条。 */
 export const asciiWordsOf = (text) => plain(text, 400).toLowerCase().match(/[a-z][a-z0-9_-]{1,}/g) || [];
 export const wordIn = (pool, word) => new RegExp(`(^|[^a-z0-9])${word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}($|[^a-z0-9])`).test(pool);
@@ -357,14 +377,22 @@ export function matchScore(record, query, corpus = null) {
     return { score: 1000, hints: ['id'] };
   }
   const grams = gramsOf(raw);
-  const words = wordsOf(raw);
+  /** 本机切词会同时给出整词和补的二元组，去重后同一个词才只算一次。 */
+  const words = [...new Set(wordsOf(raw))];
   const hints = [];
   let score = 0;
+  /** 英文按整词比对：纯英文二元组只在该词整体出现时才计数，中英混排也一样。 */
+  const ascii = asciiWordsOf(raw);
+  const englishIn = (text) => ascii.some((word) => wordIn(plain(text, 400).toLowerCase(), word));
   const hit = (text, weight) => {
     if (!text) return 0;
     const pool = gramsOf(text);
+    const wholeEnglish = englishIn(text);
     let shared = 0;
-    for (const gram of grams) if (pool.has(gram)) shared += 1;
+    for (const gram of grams) {
+      if (/^[a-z0-9]+$/.test(gram) && !wholeEnglish) continue;
+      if (pool.has(gram)) shared += 1;
+    }
     if (shared === 0) return 0;
     return (shared / Math.max(1, Math.min(grams.size, 12))) * weight;
   };
@@ -402,21 +430,38 @@ export function matchScore(record, query, corpus = null) {
     const df = corpus.df.get(text) || 0;
     return df > Math.max(3, corpus.total * 0.15);
   };
-  let titleWordHit = false;
-  let keywordWordHit = false;
-  /** 标题里同时命中的不同实词：两个以上独立概念都落在标题，比只沾一个词更说明在说同一件事。 */
+  /**
+   * 查询里有两个以上实词时，只沾上一个不算在说同一件事。
+   * 「启动服务器」只碰到「启动失败」里的「启动」，不能把改包名的记忆带进自动提示。
+   * 单实词查询（「发版」「样式」）不设这个门槛。
+   */
+  const distinctContent = [...new Set(contentWordsOf(raw).filter((word) => /[\u4e00-\u9fff]/.test(word) && !common(word)))];
+  const keywordWords = new Set();
   const titleWords = new Set();
   for (const word of words) {
     if ([...word].length < 2) continue;
     const plainWord = word.toLowerCase();
     if (common(plainWord)) continue;
-    if (keywordTexts.some((text) => plain(text, 400).toLowerCase().includes(plainWord))) { keywordWordHit = true; continue; }
+    if (keywordTexts.some((text) => plain(text, 400).toLowerCase().includes(plainWord))) {
+      keywordWords.add(plainWord);
+      continue;
+    }
     if (plain(record.title, 400).toLowerCase().includes(plainWord)
       || (record.aliases || []).some((name) => plain(name, 400).toLowerCase().includes(plainWord))) {
-      titleWordHit = true;
       titleWords.add(plainWord);
     }
   }
+  const wholeText = [record.title, (record.aliases || []).join(' '), (record.tags || []).join(' '),
+    (record.triggers || []).join(' '), record.summary, record.when, record.body]
+    .map((text) => plain(text, 400).toLowerCase()).filter(Boolean).join('\n');
+  const matchedContent = distinctContent.filter((word) => wholeText.includes(word)).length;
+  const enoughContent = distinctContent.length < 2 || matchedContent >= 2;
+  if (!enoughContent) {
+    keywordWords.clear();
+    titleWords.clear();
+  }
+  const titleWordHit = titleWords.size > 0;
+  const keywordWordHit = keywordWords.size > 0;
   if (!keywordWordHit && titleWordHit) { score += WEIGHT.title; hints.push('title'); }
   if (keywordWordHit) { score += WEIGHT.keywords; hints.push('keyword'); }
   if (titleWords.size >= 2) { score += WEIGHT.coverage; hints.push('coverage'); }
@@ -437,7 +482,6 @@ export function matchScore(record, query, corpus = null) {
   const whenScore = hit(record.when, WEIGHT.when);
   if (whenScore > 0) score += whenScore;
   /** 纯英文查询必须整词命中，别让语料里的字面巧合把不相关的记忆带进自动提示。 */
-  const ascii = asciiWordsOf(raw);
   if (ascii.length && !/[\u4e00-\u9fff]/.test(raw)) {
     const pool = [record.title, (record.aliases || []).join(' '), ...(record.tags || []), ...(record.triggers || []), record.summary, record.when]
       .filter(Boolean).join('\n').toLowerCase();
@@ -563,14 +607,14 @@ export function toModelView(record, purpose, extra = {}) {
   if (purpose === 'search') {
     const view = pick(record, ['id', 'title', 'summary', 'when', 'revision']);
     view.scope = scope;
-    if (record.origin === 'project_evolution') view.origin = 'project_evolution';
+    if (record.origin === 'project_evolution' || record.origin === 'model_drafted') view.origin = record.origin;
     if (extra.status && extra.status !== 'ok') view.state = extra.status;
     return view;
   }
   if (purpose === 'read') {
     const view = pick(record, ['id', 'title', 'summary', 'when', 'kind', 'revision', 'body']);
     view.scope = scope;
-    if (record.origin === 'project_evolution') view.origin = 'project_evolution';
+    if (record.origin === 'project_evolution' || record.origin === 'model_drafted') view.origin = record.origin;
     if (Array.isArray(record.conditions) && record.conditions.length) view.conditions = record.conditions;
     if (record.selection && record.selection.mode === 'complete') view.selection = record.selection.artifactKey;
     const related = linksOf(record).length;
@@ -649,6 +693,75 @@ export function textOfMessage(message) {
 }
 
 /** 最后一句真人说的话；goal 轮次、压缩摘要、时间快照、后台任务回执都不算。 */
+/** 续说一句（「继续」「然后呢」）本身没有检索线索：沿用上一轮原话，别让自动提醒在这一轮断掉。 */
+export function isContinuationQuery(text) {
+  const raw = plain(text, 40).trim().toLowerCase().replace(/[\s\u3002\uff01\uff1f?!\uff0c,\u3001\u2026~\uff5e]+/gu, '');
+  if (!raw || [...raw].length > 8) return false;
+  return /^(继续|接着|然后|然后呢|还有|还有呢|往下|说下去|goon|continue|next|more)$/.test(raw);
+}
+
+/**
+ * 动作侧检索词：用户这句话没提，但「刚才在动什么」往往就写在上一轮助手的话和工具名里。
+ * 预防型记忆（先重载再重启、改插件后别用 Cmd+R）约束的是下一步动作，
+ * 只拿用户原话查，词面永远在错的一侧。这里只取少量最近的实词和工具名，避免长文稀释命中。
+ */
+const ACTION_NOISE = new Set(['const', 'function', 'return', 'import', 'export', 'from', 'async', 'await', 'true', 'false', 'null', 'undefined', 'string', 'number', 'object']);
+export function actionTerms(messages, options = {}) {
+  if (!Array.isArray(messages)) return '';
+  const limit = Number.isInteger(options.limit) && options.limit > 0 ? options.limit : 16;
+  const terms = [];
+  const seen = new Set();
+  const push = (word) => {
+    const text = String(word || '').trim().toLowerCase();
+    if ([...text].length < 2 || ACTION_NOISE.has(text) || seen.has(text)) return;
+    seen.add(text);
+    terms.push(text);
+  };
+  const scan = (message) => {
+    const content = message?.content;
+    if (!Array.isArray(content)) return '';
+    let text = '';
+    for (const part of content) {
+      if (!part || typeof part !== 'object') continue;
+      if (part.type === 'tool-call' || part.type === 'tool_call') {
+        if (typeof part.name === 'string') push(part.name);
+        const input = part.input || part.arguments || part.args;
+        if (input && typeof input === 'object') {
+          for (const value of Object.values(input)) {
+            if (typeof value === 'string' && /[./_-]/.test(value)) {
+              for (const piece of value.split(/[^\p{L}\p{N}_.-]+/u)) push(piece);
+            }
+          }
+        }
+        continue;
+      }
+      if (part.type === 'text' && typeof part.text === 'string') text += `${part.text}\n`;
+    }
+    return text;
+  };
+  let assistants = 0;
+  let previousHuman = false;
+  for (let i = messages.length - 1; i >= 0 && terms.length < limit; i -= 1) {
+    const message = messages[i];
+    if (!message) continue;
+    if (message.role === 'assistant') {
+      const text = scan(message);
+      if (!text) continue;
+      assistants += 1;
+      for (const word of contentWordsOf(text)) push(word);
+      for (const word of asciiWordsOf(text)) push(word);
+      if (assistants >= 2) break;
+    } else if (message.role === 'user' && !previousHuman && message?.source?.kind !== 'goal') {
+      const text = scan(message);
+      if (!text) continue;
+      previousHuman = true;
+      for (const word of contentWordsOf(text)) push(word);
+      for (const word of asciiWordsOf(text)) push(word);
+    }
+  }
+  return terms.slice(0, limit).join(' ');
+}
+
 export function newestUserQuery(messages) {
   if (!Array.isArray(messages)) return '';
   for (let i = messages.length - 1; i >= 0; i -= 1) {