@yolk_vat-y/dsh-project-memory 0.5.9 → 0.5.11

package/src/util/fs.js

@@ -209,12 +209,16 @@ export function memoryRootFor(indexRoot, memoryDir) {
 /**
  * 危险根目录：整体扫描/监听它们会直接吃满内存（issue #5 实测把 DSH 撑死的就是
  * 家目录与 `/opt/homebrew`）。判定是**精确匹配**：只拒绝这些目录**本身**，不拒绝
- * 它们的子目录（`~/Library` 拒绝，`~/Library/Mobile Documents/…/MyProj` 照常可用）。
+ * 它们的子目录（`~/Library` 拒绝，`~/Library/Mobile Documents/…/MyProj` 照常可用；
+ * `/tmp` 拒绝，`/tmp/myproj` 照常可用）。
  *
- * 三类都在名单里：
+ * 四类都在名单里：
  *   - 文件系统根（含 Windows 盘符根）；
  *   - 家目录及其所有祖先（`/Users`、`/home`、`/`），以及家目录下的系统型子目录；
- *   - 系统/包管理器前缀（`/usr`、`/opt`、`/opt/homebrew`、`C:\Windows` …）。
+ *   - 每用户私有临时目录与共享/系统临时目录（`/tmp`、`/var/tmp`、`%TEMP%`、
+ *     `%SystemRoot%\Temp` …）——macOS 的 `os.tmpdir()` 是 `/var/folders/…/T`，共享的
+ *     `/tmp` 是**另一个**路径，两者都要拒；
+ *   - 系统/包管理器前缀（`/usr`、`/opt`、`/opt/homebrew`、`C:\Windows` …），按平台分组。
  */
 function safeHomedir() {
   try {
@@ -224,6 +228,13 @@ function safeHomedir() {
   }
 }
 
+/**
+ * POSIX 的**共享/系统**临时目录。刻意与 `os.tmpdir()` 分开列：macOS 上 `os.tmpdir()` 是
+ * `/var/folders/…/T` 这个每用户私有目录，共享的 `/tmp`（→ `/private/tmp`）根本不在名单里，
+ * 于是 `cd /tmp && dsh` 仍会把整个 /tmp 当项目根——和家目录是同一类问题（issue #5 补充发现）。
+ */
+const POSIX_SHARED_TEMP = ['/tmp', '/var/tmp', '/private/tmp', '/private/var/tmp', '/var/folders', '/dev/shm']
+
 /**
  * 危险根集合（判定用，`isUnsafeRoot` 的底座）。
  *
@@ -233,8 +244,11 @@ function safeHomedir() {
  *
  * 系统前缀按平台分组是刻意的：`C:\opt`、`C:\usr` 在 Windows 上是**正常用户目录**，
  * 跨平台套用既会误伤，也会自相矛盾（`/usr/local` 被拒而 `/usr` 放行）。
+ *
+ * @returns {{ unsafe: Set<string>, sharedTemp: Set<string> }} `sharedTemp` 单独返回，只为了让
+ *   拒绝文案能说清"是共享临时目录"而不是笼统的"系统目录"——两套集合由同一次调用产出，不会漂移。
  */
-export function collectUnsafeRoots({
+export function collectUnsafeRootSets({
   platform = process.platform,
   home = safeHomedir(),
   tmp = os.tmpdir(),
@@ -242,7 +256,8 @@ export function collectUnsafeRoots({
   pathApi = path,
 } = {}) {
   const set = new Set()
-  const push = (p) => {
+  const sharedTemp = new Set()
+  const push = (target) => (p) => {
     if (!p || typeof p !== 'string') return
     let abs
     try {
@@ -250,10 +265,23 @@ export function collectUnsafeRoots({
     } catch {
       return
     }
-    set.add(storeKey(abs, platform))
+    target.add(storeKey(abs, platform))
+  }
+  const add = push(set)
+  const addTemp = push(sharedTemp)
+
+  // 每用户私有临时目录 + 共享/系统临时目录，都算"共享临时目录"（拒绝文案上同类）。
+  addTemp(tmp)
+  if (platform === 'win32') {
+    addTemp(env.TEMP)
+    addTemp(env.TMP)
+    if (env.SystemRoot) addTemp(pathApi.join(env.SystemRoot, 'Temp'))
+    if (env.windir) addTemp(pathApi.join(env.windir, 'Temp'))
+  } else {
+    for (const p of POSIX_SHARED_TEMP) addTemp(p)
   }
+  for (const key of sharedTemp) set.add(key)
 
-  push(tmp)
   let homeAbs = null
   try {
     homeAbs = home ? pathApi.resolve(home) : null
@@ -264,19 +292,19 @@ export function collectUnsafeRoots({
     // 家目录 + 它的所有祖先：往上任何一级当根都会把整台机器扫进来。
     let dir = homeAbs
     for (;;) {
-      push(dir)
+      add(dir)
       const parent = pathApi.dirname(dir)
       if (parent === dir) break
       dir = parent
     }
     for (const sub of platform === 'win32' ? ['AppData', 'Application Data'] : ['Library', 'Applications', '.Trash']) {
-      push(pathApi.join(homeAbs, sub))
+      add(pathApi.join(homeAbs, sub))
     }
   }
 
   if (platform === 'win32') {
     for (const name of ['SystemRoot', 'windir', 'ProgramFiles', 'ProgramFiles(x86)', 'ProgramData']) {
-      push(env[name])
+      add(env[name])
     }
   } else {
     // POSIX 系统前缀 + 包管理器/工具链前缀。ARM Mac 的 Homebrew 是 git clone 到
@@ -289,13 +317,20 @@ export function collectUnsafeRoots({
       '/System', '/Library', '/Applications', '/private', '/cores',
       '/home/linuxbrew', '/home/linuxbrew/.linuxbrew', '/nix',
     ]) {
-      push(p)
+      add(p)
     }
   }
-  return set
+  return { unsafe: set, sharedTemp }
+}
+
+/** 兼容入口：只要判定集合。 */
+export function collectUnsafeRoots(opts) {
+  return collectUnsafeRootSets(opts).unsafe
 }
 
-const UNSAFE_DIRS = collectUnsafeRoots()
+const UNSAFE = collectUnsafeRootSets()
+const UNSAFE_DIRS = UNSAFE.unsafe
+const SHARED_TEMP_DIRS = UNSAFE.sharedTemp
 
 /** 判定依据文案：用于拒绝时告诉用户「为什么是它」。 */
 function unsafeReason(abs) {
@@ -309,7 +344,7 @@ function unsafeReason(abs) {
     home = null
   }
   if (home && key === home) return 'your home directory'
-  if (key === storeKey(path.resolve(os.tmpdir()))) return 'the shared temp directory'
+  if (SHARED_TEMP_DIRS.has(key)) return 'the shared temp directory'
   return 'a system directory that is never a project root'
 }
 
@@ -434,11 +469,11 @@ function resolveDir(dir) {
   }
 }
 
-function nearestMarker(absPath, markers) {
+function nearestMarker(absPath, markers, isUnsafe) {
   let dir = path.dirname(absPath)
   for (;;) {
     // 撞到家目录/系统目录边界就停：既不把边界当根，也不再向上（上面只会更宽）。
-    if (isUnsafeRoot(dir)) return null
+    if (isUnsafe(dir)) return null
     for (const marker of markers) {
       if (existsSync(path.join(dir, marker))) return dir
     }
@@ -452,14 +487,18 @@ function nearestMarker(absPath, markers) {
  * 项目根推导（**只认标记与显式声明，绝不从文件路径兜底**）。
  *
  * @param {string} filePath 目标文件（也接受目录内探针文件路径）
- * @param {{ extraRoots?: Iterable<string>, sessionRoot?: string|null }} [opts]
+ * @param {{ extraRoots?: Iterable<string>, sessionRoot?: string|null, isUnsafe?: (dir: string) => boolean }} [opts]
  *   `extraRoots`：显式登记过的根（watch_repo / watchManager）。
  *   `sessionRoot`：会话工作目录，作为**最后**一级推定——仅当文件确实在它里面、
  *   且它是安全目录时采用。
+ *   `isUnsafe`：危险根判定，默认 `isUnsafeRoot`。可注入是为了让"被拒前缀里有一个合法
+ *   `.git`"这条反直觉输入能在任意平台上用一个临时目录复现（`/opt/homebrew` 正是被
+ *   `.git` 主动选中的，不是兜底误判——issue #5 的现场复核结论）。
  * @returns {string|null}
  */
 export function findProjectRoot(filePath, opts = {}) {
   if (typeof filePath !== 'string' || !filePath) return null
+  const isUnsafe = typeof opts.isUnsafe === 'function' ? opts.isUnsafe : isUnsafeRoot
   let abs
   try {
     abs = path.resolve(filePath)
@@ -467,13 +506,13 @@ export function findProjectRoot(filePath, opts = {}) {
     return null
   }
   const explicit = longestRootContaining(opts.extraRoots || [], abs)
-  if (explicit) return isUnsafeRoot(explicit) ? null : explicit
+  if (explicit) return isUnsafe(explicit) ? null : explicit
 
-  const byMarker = nearestMarker(abs, VCS_MARKERS) || nearestMarker(abs, PROJECT_MARKERS)
+  const byMarker = nearestMarker(abs, VCS_MARKERS, isUnsafe) || nearestMarker(abs, PROJECT_MARKERS, isUnsafe)
   if (byMarker) return byMarker
 
   const session = resolveDir(opts.sessionRoot)
-  if (session && !isUnsafeRoot(session) && isInside(session, abs)) return session
+  if (session && !isUnsafe(session) && isInside(session, abs)) return session
   return null
 }
 

package/src/util/search.js

@@ -141,15 +141,10 @@ export function makeSearchText(entry) {
   return weightedFieldText(entry).toLowerCase()
 }
 
-export function rankEntries(entries, query, limit = 8) {
-  const bm25 = buildBm25(entries, weightedFieldText)
-  const scored = bm25.score(query)
-  return scored.slice(0, limit).map((r) => r.doc)
-}
-
-export function rankEntriesMerged(entries, queries, limit = 8) {
-  return rankEntriesMergedScored(entries, queries, limit).map((r) => r.entry)
-}
+// 说明：文档/符号的线上检索走 `rankEntriesStreaming`（recall.js），它不重建整库 BM25，
+// 而是用预物化的 `searchText` + 每 store 缓存的 idf。曾经存在的 `rankEntries` /
+// `rankEntriesMerged`（每次调用都 buildBm25 全库分词，70k 条目实测 p50 1.4s）已删除——
+// 它们在生产路径上没有调用方，留着只会被误用。
 
 export function rankEntriesMergedScored(entries, queries, limit = 8) {
   if (!queries.length) return entries.slice(0, limit).map((entry) => ({ entry, score: 0 }))

package/src/util/text.js

@@ -20,6 +20,22 @@ export function truncate(text, maxChars) {
 
 export const MAX_SUMMARY = 300
 
+/** 符号声明行的上限。未限长的 interface 类型体会把一行撑到几 KB。 */
+export const MAX_DECLARATION = 200
+
+/**
+ * 符号的一行声明：压平空白并限长。实测一个真实 TS 仓库里，未限长的类型体正文让
+ * 符号 `text` 字段达到 5.6MB（而它当前没有任何消费者）；限长后保住"一行声明"的语义，
+ * 又不会把代码层体积从 ~0.5% 推到 30%+。
+ * @param {unknown} text
+ * @param {number} max
+ * @returns {string}
+ */
+export function oneLineDeclaration(text, max = MAX_DECLARATION) {
+  const flat = String(text || '').replace(/\s+/g, ' ').trim()
+  return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat
+}
+
 /** 注入用短摘要：压平空白，按句子边界截断到 max 字符。纯函数，无 LLM。 */
 export function summarizeText(text, max = MAX_SUMMARY) {
   const flat = String(text || '').replace(/\s+/g, ' ').trim()

package/src/watch.js

@@ -79,30 +79,54 @@ export class WatchManager {
     return this.roots.delete(root)
   }
 
-  start(intervalMs = 15000) {
+  start(intervalMs = 30000) {
     if (this.timer) return
-    // NaN/undefined 会让 setInterval 退化成 1ms 轮询（Node 只发一条 TimeoutNaNWarning），
-    // 足以打满事件循环让 agent 无法响应；非法值回退到 15s。
+    // NaN/undefined 会让定时器退化成 1ms 轮询（Node 只发一条 TimeoutNaNWarning），
+    // 足以打满事件循环让 agent 无法响应；非法值回退到默认 30s。
     const raw = Number(intervalMs)
-    const ms = Number.isFinite(raw) ? Math.max(raw, 1000) : 15000
-    this.timer = setInterval(() => this.poll(), ms)
+    this._baseInterval = Number.isFinite(raw) ? Math.max(raw, 1000) : 30000
+    // 空闲退避：连续没有变化的轮次把间隔翻倍，最长 2 分钟一轮；任何变化立刻回到 base。
+    // 轮询本身是 O(树) 的 walkDir + 逐文件 stat（本仓库一轮实测 58–87ms），
+    // 常驻 15s 一轮意味着不管有没有改动都在磨 I/O。
+    this._maxInterval = Math.max(this._baseInterval, Math.min(this._baseInterval * 8, 120000))
+    this._interval = this._baseInterval
+    this._stopped = false
+    this._schedule()
+  }
+
+  _schedule() {
+    this.timer = setTimeout(() => this._tick(), this._interval)
     if (this.timer.unref) this.timer.unref()
   }
 
+  async _tick() {
+    this.timer = null
+    let changed = false
+    try {
+      changed = await this.poll()
+    } catch {
+      // poll() 内部已逐根兜底；这里保证无论发生什么都一定排下一轮，不会静默停掉 watch。
+    }
+    if (this._stopped) return // 轮询期间被 stop() 了，不要再排下一轮
+    this._interval = changed ? this._baseInterval : Math.min(this._interval * 2, this._maxInterval)
+    this._schedule()
+  }
+
   stop() {
-    if (this.timer) clearInterval(this.timer)
+    this._stopped = true
+    if (this.timer) clearTimeout(this.timer)
     this.timer = null
   }
 
   async poll() {
-    // setInterval 不等待上一轮：大仓库/文档 LLM 摘要让一轮 >interval 时，
-    // 轮询会叠加成并发索引，最终打满事件循环。用重入锁让慢轮询自然跳过。
-    if (this._polling) return
+    // 慢轮询期间再次进入直接跳过（递归 setTimeout 下正常不会叠加，保留作防御）。
+    if (this._polling) return false
     this._polling = true
+    let changed = false
     try {
       for (const [root, state] of this.roots) {
         try {
-          await this.pollRoot(root, state)
+          if (await this.pollRoot(root, state)) changed = true
         } catch (err) {
           console.error(`[dsh-project-memory] watch poll failed for ${root}: ${err.message}`)
         }
@@ -110,6 +134,7 @@ export class WatchManager {
     } finally {
       this._polling = false
     }
+    return changed
   }
 
   async pollRoot(root, state) {
@@ -179,14 +204,15 @@ export class WatchManager {
     // 单事务写盘；CAS 失败的条目本轮不落快照，下一轮自然重试。
     // 截断时**不传 unseen**：没扫到的文件不等于被删了，否则一份被上限截掉的树每轮都会
     // 把自己的记忆删掉一半（先删再下轮重新索引，纯粹的抖动）。
-    const { stale } = commitFileUpdates(state.store, {
+    const { stale, removed } = commitFileUpdates(state.store, {
       updates,
       unseen: truncated ? null : seen,
-      link: updates.length > 0,
     })
     const failed = new Set(stale)
+    let applied = 0
     for (const update of updates) {
       if (failed.has(update.rel)) continue
+      applied++
       state.snapshot[update.rel] = signatures.get(update.rel)
       if (update.type !== 'code') continue
       const filePath = path.join(root, update.rel)
@@ -194,5 +220,7 @@ export class WatchManager {
         onFileChanged(state.store, update.rel, filePath, this.config, root)
       }
     }
+    // 有变化 → 下一轮回到 base 间隔；纯空转 → 退避。
+    return applied > 0 || removed > 0
   }
 }