@yolk_vat-y/dsh-project-memory 0.3.1 → 0.3.3

package/src/enhancer.js

@@ -0,0 +1,444 @@
+import { createHash } from 'node:crypto'
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { createRequire } from 'node:module'
+import { linkEntries } from './link.js'
+
+const require = createRequire(import.meta.url)
+
+let ts = null
+let tsPath = null
+let tsVersion = null
+
+function acceptTsVersion(mod) {
+  if (mod && mod.version && (mod.version.startsWith('6.') || mod.version.startsWith('7.'))) {
+    console.warn(`[dsh-project-memory] TypeScript ${mod.version} 不受支持，回退到 L1 正则。请使用 TS 5.x 获得增强类型。`)
+    return null
+  }
+  return mod
+}
+
+export function initTypeScript(config) {
+  if (config?.enableTypeScript === false) return null
+  if (ts) return ts
+
+  // 1. 配置指定路径
+  if (config?.tsPath) {
+    try {
+      const req = createRequire(config.tsPath)
+      const mod = acceptTsVersion(req(config.tsPath))
+      if (mod) {
+        ts = mod
+        tsPath = config.tsPath
+        tsVersion = mod.version
+        return ts
+      }
+    } catch (e) {
+      console.warn(`[dsh-project-memory] tsPath 无效: ${config.tsPath}`)
+    }
+  }
+
+  // 2. 从用户项目 cwd 向上查找 node_modules/typescript
+  try {
+    const req = createRequire(process.cwd() + '/')
+    const mod = acceptTsVersion(req('typescript'))
+    if (mod) {
+      ts = mod
+      tsPath = req.resolve('typescript')
+      tsVersion = mod.version
+      return ts
+    }
+  } catch {}
+
+  // 3. 全局（从插件自身位置解析）
+  try {
+    const mod = acceptTsVersion(require('typescript'))
+    if (mod) {
+      ts = mod
+      tsPath = require.resolve('typescript')
+      tsVersion = mod.version
+      return ts
+    }
+  } catch {}
+
+  ts = null
+  return null
+}
+
+export function getTypeScript() {
+  return ts
+}
+
+export function hasTypeScript() {
+  return ts !== null
+}
+
+export function getTsPath() {
+  return tsPath
+}
+
+export function getTsVersion() {
+  return tsVersion
+}
+
+const PRIORITY = {
+  ACTIVE: 0,
+  RECENT: 1,
+  BATCH: 2,
+  BACKLOG: 3
+}
+
+const enhanceQueue = []
+let processing = false
+
+function getCacheDirForRoot(root, config) {
+  return join(root, config.memoryDir || '.dsh-project-memory', 'type-cache')
+}
+
+function getCacheKey(content) {
+  const hash = createHash('sha256').update(content).digest('hex').slice(0, 16)
+  return hash
+}
+
+async function loadTypeCache(cacheDir, key) {
+  const file = join(cacheDir, `${key}.json`)
+  if (!existsSync(file)) return null
+  try {
+    const data = JSON.parse(readFileSync(file, 'utf8'))
+    return data
+  } catch {
+    return null
+  }
+}
+
+async function saveTypeCache(cacheDir, key, data) {
+  try {
+    if (!existsSync(cacheDir)) mkdirSync(cacheDir, { recursive: true })
+    const file = join(cacheDir, `${key}.json`)
+    writeFileSync(file, JSON.stringify(data))
+  } catch {}
+}
+
+export function isTypeScriptFile(filePath) {
+  const ext = filePath.slice(filePath.lastIndexOf('.')).toLowerCase()
+  return ext === '.ts' || ext === '.tsx' || ext === '.js' || ext === '.jsx' ||
+         ext === '.mjs' || ext === '.cjs' || ext === '.mts' || ext === '.cts'
+}
+
+export function deepParseWithTS(filePath, content) {
+  if (!ts) return null
+
+  // Create a compiler host that provides the source file from memory
+  const host = {
+    getSourceFile: (fileName, languageVersion, onError) => {
+      if (fileName === filePath) {
+        return ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true)
+      }
+      return undefined
+    },
+    getDefaultLibFileName: (options) => ts.getDefaultLibFileName(options),
+    getDefaultLibLocation: () => ts.getDefaultLibFilePath({}),
+    getCanonicalFileName: (fileName) => fileName,
+    getCurrentDirectory: () => process.cwd(),
+    getNewLine: () => '\n',
+    useCaseSensitiveFileNames: () => true,
+    fileExists: (fileName) => fileName === filePath,
+    readFile: (fileName) => fileName === filePath ? content : undefined,
+    directoryExists: () => true,
+    getDirectories: () => [],
+  }
+
+  const program = ts.createProgram([filePath], {}, host)
+  const sourceFile = program.getSourceFile(filePath)
+  if (!sourceFile) return []
+  const checker = program.getTypeChecker()
+
+  const symbols = []
+
+  function getSignature(node) {
+    try {
+      return checker.getSignatureFromDeclaration(node)
+    } catch {
+      return undefined
+    }
+  }
+
+  function getReturnType(signature) {
+    if (!signature) return null
+    try {
+      return checker.getReturnTypeOfSignature(signature)
+    } catch {
+      return null
+    }
+  }
+
+  function getTypeStr(type) {
+    if (!type) return 'void'
+    try {
+      return checker.typeToString(type)
+    } catch {
+      return 'any'
+    }
+  }
+
+  function getLine(node) {
+    const pos = node.getStart()
+    if (pos < 0) return 1
+    return sourceFile.getLineAndCharacterOfPosition(pos).line + 1
+  }
+
+  function visit(node) {
+    if (ts.isFunctionDeclaration(node) && node.name) {
+      const signature = getSignature(node)
+      const returnType = getReturnType(signature)
+      const typeParams = node.typeParameters?.map(tp => tp.getText()) || []
+      const params = node.parameters.map(p => {
+        const type = p.type ? getTypeStr(checker.getTypeAtLocation(p.type)) : 'any'
+        return `${p.name.getText()}: ${type}`
+      })
+      const returnTypeStr = getTypeStr(returnType)
+      const generics = typeParams.length ? `<${typeParams.join(', ')}>` : ''
+      symbols.push({
+        name: node.name.getText(),
+        kind: 'function',
+        typeSig: `${generics}(${params.join(', ')}): ${returnTypeStr}`,
+        line: getLine(node)
+      })
+    } else if (ts.isMethodDeclaration(node) && node.name) {
+      const signature = getSignature(node)
+      const returnType = getReturnType(signature)
+      const typeParams = node.typeParameters?.map(tp => tp.getText()) || []
+      const params = node.parameters.map(p => {
+        const type = p.type ? getTypeStr(checker.getTypeAtLocation(p.type)) : 'any'
+        return `${p.name.getText()}: ${type}`
+      })
+      const returnTypeStr = getTypeStr(returnType)
+      const generics = typeParams.length ? `<${typeParams.join(', ')}>` : ''
+      symbols.push({
+        name: node.name.getText(),
+        kind: 'method',
+        typeSig: `${generics}(${params.join(', ')}): ${returnTypeStr}`,
+        line: getLine(node)
+      })
+    } else if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+      const parent = node.parent
+      if (parent && (ts.isVariableDeclaration(parent) || ts.isPropertyAssignment(parent) || ts.isPropertyDeclaration(parent))) {
+        const signature = getSignature(node)
+        const returnType = getReturnType(signature)
+        const typeParams = node.typeParameters?.map(tp => tp.getText()) || []
+        const params = node.parameters.map(p => {
+          const type = p.type ? getTypeStr(checker.getTypeAtLocation(p.type)) : 'any'
+          return `${p.name.getText()}: ${type}`
+        })
+        const returnTypeStr = getTypeStr(returnType)
+        const generics = typeParams.length ? `<${typeParams.join(', ')}>` : ''
+        const name = parent.name?.getText() || '(anonymous)'
+        const kind = ts.isArrowFunction(node) ? 'arrow' : 'function'
+        symbols.push({
+          name,
+          kind,
+          typeSig: `${generics}(${params.join(', ')}): ${returnTypeStr}`,
+          line: getLine(node)
+        })
+      }
+    } else if (ts.isClassDeclaration(node) && node.name) {
+      const typeParams = node.typeParameters?.map(tp => tp.getText()) || []
+      const generics = typeParams.length ? `<${typeParams.join(', ')}>` : ''
+      symbols.push({
+        name: node.name.getText(),
+        kind: 'class',
+        typeSig: generics,
+        line: getLine(node)
+      })
+      ts.forEachChild(node, visit)
+    } else if (ts.isInterfaceDeclaration(node)) {
+      const members = node.members.map(m => {
+        // Skip index signatures (m.name is undefined for index signatures like [key: string]: T)
+        if (!m.name) return null
+        const type = m.type ? getTypeStr(checker.getTypeAtLocation(m.type)) : 'any'
+        return `${m.name.getText()}: ${type}`
+      }).filter(Boolean).join('; ')
+      symbols.push({
+        name: node.name.getText(),
+        kind: 'interface',
+        typeSig: `{ ${members} }`,
+        line: getLine(node)
+      })
+    } else if (ts.isTypeAliasDeclaration(node)) {
+      const typeStr = node.type ? getTypeStr(checker.getTypeAtLocation(node.type)) : 'any'
+      symbols.push({
+        name: node.name.getText(),
+        kind: 'type',
+        typeSig: `= ${typeStr}`,
+        line: getLine(node)
+      })
+    } else {
+      ts.forEachChild(node, visit)
+    }
+  }
+
+  const sf = program.getSourceFile(filePath)
+  if (sf) {
+    visit(sf)
+  }
+  return symbols
+}
+
+export function enqueueEnhance(store, relPath, filePath, priority = PRIORITY.BATCH, config, root) {
+  if (!ts) return Promise.resolve()
+
+  let content
+  try {
+    content = readFileSync(filePath, 'utf8')
+  } catch {
+    // File disappeared between detection and enqueue - skip silently
+    return Promise.resolve()
+  }
+  const cacheKey = getCacheKey(content)
+
+  // Dedupe by (relPath, contentHash) - if same content, skip; if different, replace
+  const existingIdx = enhanceQueue.findIndex(q => q.relPath === relPath)
+  if (existingIdx >= 0) {
+    const existing = enhanceQueue[existingIdx]
+    if (existing.cacheKey === cacheKey) {
+      // Same content, just update priority if higher
+      if (priority < existing.priority) {
+        enhanceQueue[existingIdx].priority = priority
+        enhanceQueue.sort((a, b) => a.priority - b.priority)
+      }
+      return existing.promise
+    } else {
+      // Content changed - replace the task
+      enhanceQueue[existingIdx] = { relPath, filePath, priority, cacheKey, promise: null }
+      // Will create new promise below
+    }
+  }
+
+  const p = (async () => {
+    try {
+      const content = readFileSync(filePath, 'utf8')
+      const cacheKey = getCacheKey(content)
+      const cacheDir = getCacheDirForRoot(root || process.cwd(), config)
+      const cached = await loadTypeCache(cacheDir, cacheKey)
+      if (cached) {
+        // Cache hit: persist via store.commit
+        await store.commit(fn => applyEnhancedSymbols(fn, relPath, cached.symbols))
+        return
+      }
+
+      const enhanced = deepParseWithTS(filePath, content)
+      if (enhanced?.length) {
+        await saveTypeCache(cacheDir, cacheKey, { symbols: enhanced })
+        await store.commit(fn => applyEnhancedSymbols(fn, relPath, enhanced))
+      }
+    } catch (err) {
+      console.warn(`[dsh-project-memory] enhance failed for ${relPath}: ${err.message}`)
+    } finally {
+      // Remove only this task's own queue entry (not a newer one for the same relPath)
+      const idx = enhanceQueue.findIndex(q => q.promise === p)
+      if (idx >= 0) enhanceQueue.splice(idx, 1)
+    }
+  })()
+
+  // Update or add to queue
+  const existingIdx2 = enhanceQueue.findIndex(q => q.relPath === relPath)
+  if (existingIdx2 >= 0) {
+    enhanceQueue[existingIdx2] = { relPath, filePath, priority, cacheKey, promise: p }
+  } else {
+    enhanceQueue.push({ relPath, filePath, priority, cacheKey, promise: p })
+  }
+  enhanceQueue.sort((a, b) => a.priority - b.priority)
+
+  scheduleProcess()
+  return p
+}
+
+function scheduleProcess() {
+  if (processing) return
+  processing = true
+
+  const processNext = async () => {
+    while (enhanceQueue.length > 0) {
+      const task = enhanceQueue.shift()
+      try {
+        await task.promise
+      } catch (err) {
+        console.warn(`[dsh-project-memory] enhance task failed: ${err.message}`)
+      }
+      await new Promise(r => setImmediate(r))
+    }
+    processing = false
+  }
+
+  processNext()
+}
+
+function applyEnhancedSymbols(fn, relPath, enhanced) {
+  // Store entries in fn.entries[relPath], not fn.files[relPath].entries
+  const existingEntries = fn.entries[relPath] || []
+  // L1 entries carry title "name (kind)" + sourceLine but no name/line fields
+  const nameOf = e => (e.title || '').replace(/\s*\([^)]*\)\s*$/, '')
+  const enhancedByLine = new Map(enhanced.map(s => [s.line, s]))
+  const existingKeys = new Set(existingEntries.map(e => `${nameOf(e)}#${e.sourceLine}`))
+
+  // Upgrade L1 entries in place only when TS found the same symbol on the same line
+  const mergedEntries = existingEntries.map(e => {
+    const enh = enhancedByLine.get(e.sourceLine)
+    if (!enh || nameOf(e) !== enh.name) return e
+    return {
+      ...e,
+      text: `${enh.name}${enh.typeSig} -- ${relPath}:${enh.line}`,
+      typeSig: enh.typeSig,
+      enhanced: true
+    }
+  })
+
+  // Add enhanced symbols that L1 missed; keep ids unique even when several
+  // symbols share one line (e.g. one-line class + method)
+  const usedIds = new Set(existingEntries.map(e => e.id))
+  const newEntries = []
+  for (const s of enhanced) {
+    if (existingKeys.has(`${s.name}#${s.line}`)) continue
+    const base = `${relPath.replace(/[\/:\s]/g, '_')}#${s.line}`
+    let id = base
+    if (usedIds.has(id)) id = `${base}-${s.kind}`
+    for (let n = 2; usedIds.has(id); n++) id = `${base}-${s.kind}-${n}`
+    usedIds.add(id)
+    newEntries.push({
+      id,
+      sourcePath: relPath,
+      sourceLine: s.line,
+      type: 'symbol',
+      title: `${s.name} (${s.kind})`,
+      keywords: [s.name, s.kind],
+      text: `${s.name}${s.typeSig} -- ${relPath}:${s.line}`,
+      enhanced: true
+    })
+  }
+
+  // Write to store.entries via setEntries so the shard is marked dirty and persisted
+  fn.setEntries(relPath, [...mergedEntries, ...newEntries])
+
+  // Refresh doc<->symbol links for newly added symbols
+  if (newEntries.length) linkEntries(fn)
+
+  // Also update fn.files metadata
+  if (fn.files[relPath]) {
+    fn.files[relPath].enhanced = true
+  }
+}
+
+export function onFileObserved(store, relPath, filePath, config, root) {
+  if (!isTypeScriptFile(filePath)) return
+  enqueueEnhance(store, relPath, filePath, PRIORITY.ACTIVE, config, root)
+}
+
+export function onFileChanged(store, relPath, filePath, config, root) {
+  if (!isTypeScriptFile(filePath)) return
+  enqueueEnhance(store, relPath, filePath, PRIORITY.RECENT, config, root)
+}
+
+export function onFileIndexed(store, relPath, filePath, config, root) {
+  if (!isTypeScriptFile(filePath)) return
+  enqueueEnhance(store, relPath, filePath, PRIORITY.BATCH, config, root)
+}

package/src/index.js

@@ -8,6 +8,7 @@ import { watchRepoTool } from './tools/watch-repo.js'
 import { statsTool } from './tools/stats.js'
 import { WatchManager } from './watch.js'
 import { setupLazyIndexing } from './lazy.js'
+import { initTypeScript } from './enhancer.js'
 
 export const name = 'dsh-project-memory'
 export const inject = ['llm', 'tools']
@@ -25,9 +26,16 @@ export const Config = Schema.object({
   autoIndexOnFirstUse: Schema.boolean().default(false),
   watch: Schema.boolean().default(true),
   watchInterval: Schema.number().default(15),
+  tsPath: Schema.string(),
+  enableTypeScript: Schema.boolean().default(true),
 })
 
 export function apply(ctx, config) {
+  // Initialize TypeScript enhancer if enabled
+  if (config.enableTypeScript !== false) {
+    initTypeScript(config)
+  }
+
   const watchManager = new WatchManager(ctx, config)
   if (config.watch) {
     watchManager.restorePersisted()

package/src/lazy.js

@@ -6,6 +6,7 @@ import { buildDocEntries } from './doc-pipeline.js'
 import { scanSymbols } from './symbols.js'
 import { linkEntries } from './link.js'
 import { ProjectMemoryStore } from './store.js'
+import { onFileObserved } from './enhancer.js'
 
 const STRONG_MARKERS = ['.git', '.hg', '.svn']
 
@@ -87,6 +88,7 @@ export async function indexFile(ctx, config, filePath, watchManager = null) {
   const existing = store.fileRecord(rel)
   let hash
   let size
+  let entries
   try {
     if (isSupportedCode(ext) && config.maxFileSizeMb && statSync(filePath).size > config.maxFileSizeMb * 1024 * 1024) {
       return false
@@ -102,9 +104,9 @@ export async function indexFile(ctx, config, filePath, watchManager = null) {
     store.addWatch(root)
   }
 
-  let entries
   if (isSupportedCode(ext)) {
     entries = scanSymbols(rel, filePath, readFileSync(filePath, 'utf8'))
+    onFileObserved(store, rel, filePath, config, root)
     return store.commit((s) => {
       s.markFile(rel, { sha256: hash, size, type: 'code', indexedAt: new Date().toISOString() })
       s.setEntries(rel, entries)

package/src/llm.js

@@ -96,10 +96,15 @@ export async function expandQuery(llm, query, count = 6) {
 export async function extractDocEntry(llm, chunk, sourcePath) {
   const system =
     'You are a project-documentation indexer. Given a chunk of a project document, ' +
-    'return a STRICT JSON object with exactly three fields: ' +
-    '"title" (short section title, string), "summary" (2-4 sentence dense summary of what this section covers, ' +
-    'mentioning concrete names, decisions and constraints), "keywords" (array of 5-10 searchable strings: ' +
-    'cover the document\'s own language AND English equivalents, so a query in either language can match). ' +
+    'return a STRICT JSON object with exactly four fields: ' +
+    '"title" (short section title, string), ' +
+    '"summary" (3-5 sentence dense summary of what this section covers, ' +
+    'mentioning concrete names, decisions, constraints, and key technical details), ' +
+    '"blindSpots" (string describing what this summary does NOT cover, ' +
+    'e.g. "未覆盖：部署细节、性能基准、v0.2 前 API", empty string if none), ' +
+    '"keywords" (array of 5-10 searchable strings: ' +
+    'cover the document\'s own language AND English equivalents, ' +
+    'so a query in either language can match). ' +
     'Do not include markdown fences, do not add commentary, output only the JSON object.'
 
   const user =
@@ -109,6 +114,7 @@ export async function extractDocEntry(llm, chunk, sourcePath) {
   const fallback = () => ({
     title: chunk.title || sourcePath,
     summary: summarizeText(chunk.text),
+    blindSpots: '',
     keywords: tokenize(chunk.title).slice(0, 5),
   })
 
@@ -121,7 +127,8 @@ export async function extractDocEntry(llm, chunk, sourcePath) {
     const kw = Array.isArray(parsed.keywords) ? parsed.keywords.map(String).filter((k) => k).slice(0, 8) : []
     return {
       title: typeof parsed.title === 'string' && parsed.title.trim() ? parsed.title.trim() : chunk.title || sourcePath,
-      summary: summarizeText(parsed.summary),
+      summary: summarizeText(parsed.summary.trim()),
+      blindSpots: typeof parsed.blindSpots === 'string' ? parsed.blindSpots.trim() : '',
       keywords: kw.length ? kw : tokenize(chunk.title).slice(0, 5),
     }
   } catch {