@yolk_vat-y/dsh-project-memory 0.5.10 → 0.5.12

package/scripts/bench-load.mjs

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+/**
+ * 在**独立进程**里量一次 store 冷加载的耗时与常驻内存，输出一行 JSON。
+ *
+ * 为什么要单独一个进程：`scripts/bench.mjs` 在同一个进程里已经有一个 store（索引用的那个），
+ * 再 load 第二个副本量出来的堆是两份的。这里从空进程冷加载，数字才是「一个 store 常驻多少」。
+ * 必须带 `--expose-gc` 运行（bench.mjs 会自己加），否则量不到稳定值。
+ *
+ * 用法：node --expose-gc scripts/bench-load.mjs <storeDir>
+ */
+import { performance } from 'node:perf_hooks'
+
+import { ProjectMemoryStore } from '../src/store.js'
+
+const dir = process.argv[2]
+if (!dir) {
+  console.error('usage: node --expose-gc scripts/bench-load.mjs <storeDir>')
+  process.exit(2)
+}
+
+const gc = typeof global.gc === 'function' ? global.gc : () => {}
+const mb = (n) => Math.round((n / 1048576) * 10) / 10
+const snap = () => {
+  const m = process.memoryUsage()
+  return { heapMb: mb(m.heapUsed), rssMb: mb(m.rss) }
+}
+
+gc()
+const t0 = performance.now()
+const store = new ProjectMemoryStore(dir).load()
+const loadMs = performance.now() - t0
+gc()
+const afterLoad = snap()
+
+// allEntries() 会在内存里物化 searchText（派生字段不落盘），这一步才是查询前的水位
+const entries = store.allEntries()
+gc()
+const afterEntries = snap()
+
+console.log(
+  JSON.stringify({
+    loadMs: Number(loadMs.toFixed(2)),
+    entries: entries.length,
+    afterLoad,
+    afterEntries,
+  }),
+)

package/scripts/bench-synthetic.mjs

@@ -5,7 +5,7 @@
  *   - store.js       : load / commit / addExperience(findSupersede) / removeExperience
  *   - util/search.js : buildBm25 / rankEntriesStreaming / rankExperienceScored
  *   - symbols.js     : scanSymbols（零 token 符号抽取，无 LLM）
- *   - link.js        : linkEntries（doc↔symbol 交叉链接）
+ *   - link.js        : resolveLinkedSymbols（doc↔symbol 交叉链接，读取期解算）
  *   - insight-store.js: GlobalStore read/write + saveInsight（归一化去重）
  *   - similarity.js  : normalizedTokenOverlap（去重阈值判定）
  *
@@ -21,7 +21,6 @@ import { performance } from 'node:perf_hooks'
 import { ProjectMemoryStore } from '../src/store.js'
 import { walkDir, readFileForIndex, relativePath, storeKey, isSupportedCode } from '../src/util/fs.js'
 import { scanSymbols } from '../src/symbols.js'
-import { linkEntries } from '../src/link.js'
 import { rankEntriesStreaming, rankExperienceScored, makeSearchText } from '../src/util/search.js'
 import { GlobalStore, saveInsight, normalizeInsight } from '../src/insight-store.js'
 import { normalizedTokenOverlap } from '../src/similarity.js'
@@ -108,7 +107,6 @@ async function coldIndex(root, config) {
   const report = store.commit((s) => {
     for (const u of fileUpdates) s.applyFileUpdate(u.rel, u)
     for (const rel of Object.keys(s.files)) if (!seen.has(rel)) s.removeFile(rel)
-    linkEntries(s)
     return s.stats()
   })
   return { report, store }
@@ -146,7 +144,7 @@ async function main() {
   console.log(`\n[语料生成] ${FILES} 文件写盘耗时 ${genMs.toFixed(0)} ms`)
 
   // ---------- 1. 冷索引（完整内核管线，无 LLM）----------
-  console.log('\n--- 1. 冷索引 index_repo 内核管线（walk + sha256 + scanSymbols + linkEntries + commit）---')
+  console.log('\n--- 1. 冷索引 index_repo 内核管线（walk + sha256 + scanSymbols + commit）---')
   const idxTimes = []
   let entriesCount = 0
   for (let r = 0; r < 3; r++) {

package/scripts/bench.mjs

@@ -1,11 +1,13 @@
 #!/usr/bin/env node
 /**
- * 独立基准：给一个真实项目路径，量「冷索引 / 冷加载 / 热查询 / 单文件热重索引 / 存储体积」。
+ * 独立基准：给一个真实项目路径，量「冷索引 / 冷加载 / 热查询 / 单文件热重索引 / 存储体积 / 常驻内存」。
  *
  * 特点：
  * - **不需要运行 dsh**，只 import 插件自己的 src 模块，走的就是线上那条索引与检索路径；
  * - **不碰被测项目**：结果写进临时目录，跑完删除（`--keep` 可保留）；
  * - 索引期零模型调用、零网络请求，所以在任何机器上都能复现。
+ * - 常驻内存（load 后 / allEntries() 后）由一个 `--expose-gc` 的子进程量（`scripts/bench-load.mjs`），
+ *   否则同一个进程里已经有索引用的那个 store，量出来是两份。
  *
  * 用法：
  *   node scripts/bench.mjs [projectPath] [--json] [--samples 100] [--no-pdf] [--keep] [--max-files 20000]
@@ -15,10 +17,12 @@
  *   [{ "query": "jwt token validation", "expect": "src/utils/auth.ts" }, ...]
  * `expect` 按子串匹配结果的 sourcePath / title / id（大小写不敏感）。
  */
+import { execFileSync } from 'node:child_process'
 import { cpSync, existsSync, mkdtempSync, readdirSync, rmSync, statSync } from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
 import { performance } from 'node:perf_hooks'
+import { fileURLToPath } from 'node:url'
 
 import { ProjectMemoryStore } from '../src/store.js'
 import { buildDocEntries } from '../src/doc-pipeline.js'
@@ -94,6 +98,7 @@ function stats(xs) {
 
 function dirSize(dir) {
   let bytes = 0
+  let allocated = 0
   let files = 0
   const stack = [dir]
   while (stack.length) {
@@ -108,7 +113,11 @@ function dirSize(dir) {
       if (e.isDirectory()) stack.push(p)
       else {
         try {
-          bytes += statSync(p).size
+          const st = statSync(p)
+          bytes += st.size
+          // 一个源文件一个碎分片 → 每个文件至少占一个块（通常 4 KB），`du` 会明显大于
+          // 内容字节和。两个数都给出来，别把「内容大小」当成「占盘大小」。
+          allocated += st.blocks ? st.blocks * 512 : st.size
           files++
         } catch {
           /* ignore */
@@ -116,7 +125,7 @@ function dirSize(dir) {
       }
     }
   }
-  return { bytes, files }
+  return { bytes, allocated, files }
 }
 
 const kb = (n) => `${(n / 1024).toFixed(1)} KB`
@@ -206,6 +215,16 @@ const onDisk = dirSize(tmpStore)
 const coldDir = `${tmpStore}-cold`
 cpSync(tmpStore, coldDir, { recursive: true })
 const coldLoad = timeSync(() => new ProjectMemoryStore(coldDir).load())
+// 常驻内存必须在独立进程里量：本进程已经拿着索引那个 store，再 load 一个副本得到的是两份
+const memory = (() => {
+  try {
+    const loadScript = path.join(path.dirname(fileURLToPath(import.meta.url)), 'bench-load.mjs')
+    const out = execFileSync(process.execPath, ['--expose-gc', loadScript, coldDir], { encoding: 'utf8' })
+    return JSON.parse(out.trim().split('\n').pop())
+  } catch (err) {
+    return { error: err.message }
+  }
+})()
 
 // ---------- 4. 热查询 / 冷查询 ----------
 const queryPool = entries.filter((e) => typeof e.title === 'string' && e.title.trim().length >= 4)
@@ -328,10 +347,12 @@ const result = {
   store: {
     dir: tmpStore,
     bytes: onDisk.bytes,
+    allocatedBytes: onDisk.allocated,
     files: onDisk.files,
     bytesPerEntry: entries.length ? Math.round(onDisk.bytes / entries.length) : 0,
   },
   coldLoadMs: round(coldLoad.ms),
+  memory,
   query: {
     samples: queries.length,
     idfRebuildMs: round(idfCold.ms),
@@ -363,7 +384,17 @@ if (opts.json) {
   console.log(`  read+hash ${result.index.readHashMs} ms · extract ${result.index.extractMs} ms · commit ${result.index.commitMs} ms`)
   console.log(`  per file  p50 ${result.index.perFileMs.p50} ms · p95 ${result.index.perFileMs.p95} ms`)
   console.log(`  note: read+hash depends on the OS page cache — run it twice and say which run you quote`)
-  console.log(`store     ${mb(result.store.bytes)} · ${result.store.bytesPerEntry} bytes/entry · cold load ${result.coldLoadMs} ms`)
+  console.log(
+    `store     ${mb(result.store.bytes)} content · ${mb(result.store.allocatedBytes)} on disk · ${result.store.bytesPerEntry} bytes/entry · cold load ${result.coldLoadMs} ms`,
+  )
+  if (memory && !memory.error) {
+    console.log(
+      `memory    isolated child: after load heap ${memory.afterLoad.heapMb} MB / RSS ${memory.afterLoad.rssMb} MB` +
+        ` · after allEntries() heap ${memory.afterEntries.heapMb} MB / RSS ${memory.afterEntries.rssMb} MB`,
+    )
+  } else if (memory && memory.error) {
+    console.log(`memory    unavailable (${memory.error})`)
+  }
   console.log(`\n-- query (shipped scorer: IDF cache + streaming BM25 + CJK phrase boost) --`)
   console.log(`idf rebuild (first query after write)  ${result.query.idfRebuildMs} ms`)
   console.log(`cold query (rebuild + rank)            ${result.query.coldMs} ms`)

package/src/audit.js

@@ -8,8 +8,9 @@
 //  - 只在确有决策（本条真的进了上下文）时写一行：dropped 单独出现不写，否则每步刷屏；
 //  - 任何异常（目录不可写、磁盘满、记录序列化失败）一律吞掉，绝不影响宿主请求；
 //  - 单文件超限就地轮转一份 `.1`，不引入新的清理线程或后台任务。
-import { appendFileSync, mkdirSync, renameSync, statSync } from 'node:fs'
+import { appendFileSync, existsSync, mkdirSync, renameSync, statSync } from 'node:fs'
 import path from 'node:path'
+import { hasProjectMarker } from './util/fs.js'
 
 export const AUDIT_FILE = 'injection-audit.jsonl'
 const DEFAULT_MAX_BYTES = 256 * 1024
@@ -75,10 +76,34 @@ export function shadowRecordFrom(input) {
  * 追加一行影子记录。返回是否写入成功（仅供测试断言）。与主审计同约定：任何异常一律吞掉，
  * 绝不影响宿主请求。
  */
-export function appendShadowAudit(memoryDir, record, cfg) {
+
+/**
+ * 审计**只为"已经存在"或"结论明确"的根创建 store 目录**。
+ *
+ * 本插件里会在"什么都没索引过"的空目录里造出 `.dsh-project-memory` 的就是下面那句
+ * `mkdirSync`（`load()` 不建目录，`ensureSelfIgnore()` 也要求目录已存在）。于是任何一次
+ * "**在容器目录里**开会话"都会留下一个只装着审计日志的空 store —— 而那个目录随后还会被
+ * `resolveProjectMemoryRoot()` 当成项目根。审计是旁路，没有 store 就没有可对照的候选。
+ *
+ * 两个放行条件：
+ *   - store 目录已存在 → 真被索引/写过，照旧；
+ *   - 该根**自身带项目标记**（`hasProjectMarker`）→ 是"声明过的项目"，即便还没落过盘，
+ *     也该留下第一步的记录（`rootNotice` 用的是同一个判据，两处口径一致）。
+ * "根是推定的（无标记）且还没有内容"→ 跳过。这正是容器目录的那种情况。
+ *
+ * @param {string} memoryDir `<root>/.dsh-project-memory`
+ * @param {string} [root] 项目根；省略时退回 `path.dirname(memoryDir)`
+ */
+function auditDirReady(memoryDir, root) {
+  if (existsSync(memoryDir)) return true
+  return hasProjectMarker(root || path.dirname(memoryDir))
+}
+
+export function appendShadowAudit(memoryDir, record, cfg, root) {
   const c = cfg || {}
   if (c.enabled === false) return false
   if (!memoryDir || !record) return false
+  if (!auditDirReady(memoryDir, root)) return false
   try {
     mkdirSync(memoryDir, { recursive: true })
     const file = shadowFileFor(memoryDir)
@@ -124,10 +149,11 @@ export function auditRecordFrom(input) {
  * @param {object} record {@link auditRecordFrom} 的产物
  * @param {{enabled?: boolean, maxBytes?: number}} [cfg] {@link cfgAudit} 的产物
  */
-export function appendInjectionAudit(memoryDir, record, cfg) {
+export function appendInjectionAudit(memoryDir, record, cfg, root) {
   const c = cfg || {}
   if (c.enabled === false) return false
   if (!memoryDir || !record) return false
+  if (!auditDirReady(memoryDir, root)) return false
   try {
     mkdirSync(memoryDir, { recursive: true })
     const file = auditFileFor(memoryDir)

package/src/auto-inject.js

@@ -619,7 +619,7 @@ async function injectForStep({ payload, decision, config, cfg, audit, shadow, se
     reasons: built.reasons,
     candidates: built.candidates,
     silence: silence.reason,
-  }), shadow)
+  }), shadow, root)
 
   // 记忆根通告：根是**推定**的（会话工作目录，且该目录没有任何项目标记）时，
   // 第一次注入前告诉模型"记忆现在存在哪、怎么改"。它是状态声明（与常驻任务卡同类），
@@ -648,7 +648,9 @@ async function injectForStep({ payload, decision, config, cfg, audit, shadow, se
   if (built.reasons.length) {
     try {
       if (recordHit({ store, globalStore, ids: built.reasons.map((r) => r.id) })) {
-        store.save()
+        // 只有这个根里真有东西才落盘。否则一次**全局** insight 的命中就会为一个从没被
+        // 索引过的容器目录建出整个 store（`save()` 会 mkdir）。审计侧同样不建，见 audit.js。
+        if (store.hasContent) store.save()
         globalStore.commit()
       }
     } catch {
@@ -667,7 +669,7 @@ async function injectForStep({ payload, decision, config, cfg, audit, shadow, se
     dropped: built.dropped,
     budget: { items: quota.items, chars: quota.chars, lastStep: Number.isFinite(quota.lastStep) ? quota.lastStep : null },
     silence: silence.reason,
-  }), audit)
+  }), audit, root)
 
   return { ...decision, messages: [...decision.messages, injectionMessage(injectedText)] }
 }