@yolk_vat-y/dsh-project-memory 0.3.0 → 0.3.2

package/src/symbols.js

@@ -1,6 +1,6 @@
 import { readFileSync } from 'node:fs'
 
-const JS_LIKE = new Set(['.js', '.mjs', '.cjs', '.ts', '.jsx', '.tsx'])
+const JS_LIKE = new Set(['.js', '.mjs', '.cjs', '.ts', '.mts', '.cts', '.jsx', '.tsx'])
 const PYTHON = new Set(['.py'])
 const GO = new Set(['.go'])
 const RUST = new Set(['.rs'])
@@ -96,19 +96,121 @@ function balanceDelta(text) {
   return delta
 }
 
+function extractTypeSignature(line) {
+  let sig = ''
+  
+  // 1. Generics: <T, U extends Base> - but NOT the return type generics like Promise<T>
+  // Match generics that appear BEFORE the first ( (function params) or => (arrow)
+  // For: function foo<T>(a: T): R
+  // For: const foo = <T>(a: T): R =>
+  // For: class Foo<T> { method() }
+  const beforeParams = line.split(/\(|=>/)[0]
+  const genericMatch = beforeParams.match(/<[^<>]*(?:<[^<>]*>[^<>]*)*>/)
+  if (genericMatch) sig += genericMatch[0]
+  
+  // 2. Parameters: (a: string, b: number) - handle nested parentheses
+  let paramMatch = null
+  const parenIdx = line.indexOf('(')
+  if (parenIdx >= 0) {
+    let depth = 0
+    for (let i = parenIdx; i < line.length; i++) {
+      if (line[i] === '(') depth++
+      else if (line[i] === ')') {
+        depth--
+        if (depth === 0) {
+          paramMatch = line.slice(parenIdx, i + 1)
+          // 3. Return type: ONLY after the closing ) of params
+          const afterParams = line.slice(i + 1)
+          // Match return type including nested generics, stop at { ; => 
+          const retMatch = afterParams.match(/^\s*:\s*([^{;=]+)/)
+          if (retMatch) sig += paramMatch + `: ${retMatch[1].trim()}`
+          else sig += paramMatch
+          break
+        }
+      }
+    }
+  }
+  
+  // 3b. Arrow function without parens: foo = (x): R => or foo = x: R =>
+  if (!paramMatch) {
+    const arrowMatch = line.match(/=>/)
+    if (arrowMatch) {
+      const afterArrow = line.slice(arrowMatch.index + 2)
+      const retMatch = afterArrow.match(/^\s*([^{;=]+)/)
+      if (retMatch) sig += `: ${retMatch[1].trim()}`
+    }
+  }
+  
+  return sig
+}
+
+function extractInterfaceOrType(line) {
+  // interface User { name: string; age: number }
+  const ifaceMatch = line.match(/^interface\s+(\w+)\s*(?:extends\s+[^{]+)?\s*\{([^}]*)\}/)
+  if (ifaceMatch) {
+    return `{ ${ifaceMatch[2].trim()} }`
+  }
+  // type UserMap = Map<string, User>
+  const typeMatch = line.match(/^type\s+(\w+)\s*=\s*([^;{]+)/)
+  if (typeMatch) {
+    return `= ${typeMatch[2].trim()}`
+  }
+  return ''
+}
+
+function extractOverloads(masked, startIdx) {
+  const overloads = []
+  for (let i = startIdx; i < masked.length; i++) {
+    const text = masked[i].trim()
+    if (!text) continue
+    
+    // Skip comments
+    if (text.startsWith('//') || text.startsWith('/*')) continue
+    
+    // Check for function declaration (with or without export/async/default)
+    const fnMatch = text.match(/^(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s+\w+\s*/)
+    if (!fnMatch) break
+    
+    // Extract ONLY the signature part (generics + params + return), NOT the function name
+    const sig = extractTypeSignature(text)
+    if (sig) overloads.push(sig)
+    
+    // If it has a body {, it's the implementation - stop
+    if (text.includes('{')) break
+  }
+  return overloads
+}
+
 function matchJsLike(line) {
+  // export default async function foo<T>(a: T): Promise<T> { ... }
   let m = line.match(/^export\s+(?:default\s+)?(?:async\s+)?(?:function\s+([A-Za-z_$][\w$]*)|class\s+([A-Za-z_$][\w$]*))/)
   if (m) return { name: m[1] || m[2], kind: m[1] ? 'function' : 'class' }
-  m = line.match(/^(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)\s*\(/)
+  
+  // export async function foo<T>(a: T): Promise<T> { ... }
+  // Handle optional generics: function name<T>(...
+  m = line.match(/^(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)\s*(?:<[^<>]*>)?\s*\(/)
   if (m) return { name: m[1], kind: 'function' }
+  
+  // export class Foo { ... }
   m = line.match(/^(?:export\s+)?class\s+([A-Za-z_$][\w$]*)/)
   if (m) return { name: m[1], kind: 'class' }
+  
+  // export const foo = (a: T): Promise<T> => { ... }
   m = line.match(/^(?:export\s+)?const\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?\(/)
   if (m) return { name: m[1], kind: 'function' }
+  
+  // export const foo = async (a: T): Promise<T> => { ... }
   m = line.match(/^(?:export\s+)?const\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>/)
   if (m) return { name: m[1], kind: 'function' }
-  m = line.match(/^(?:export\s+)?(?:async\s+)?function\s*\(/) // anonymous
+  
+  // export function (multi-line, name on next line)
+  m = line.match(/^(?:export\s+)?(?:async\s+)?function\s*$/)
+  if (m) return { name: '(pending)', kind: 'function' }
+  
+  // anonymous function
+  m = line.match(/^(?:export\s+)?(?:async\s+)?function\s*\(/)
   if (m) return { name: '(anonymous)', kind: 'function' }
+  
   return null
 }
 
@@ -120,41 +222,87 @@ const JS_NON_METHOD = new Set([
   'new', 'delete', 'typeof', 'instanceof', 'void', 'await', 'yield', 'with',
 ])
 
-function scanJsLike(masked, filePath, rawLines) {
+function scanJsLike(masked, relPath, rawLines) {
   const symbols = []
   let prevOpensBlock = false
   for (let i = 0; i < masked.length; i++) {
-    const text = masked[i].trim()
-    if (!text) continue
+    const rawText = rawLines[i].trim()
+    const maskedText = masked[i].trim()
+    if (!rawText) continue
+    
     let matched = null
-    if (prevOpensBlock) {
-      const method = text.match(/^([A-Za-z_$][\w$]*)\s*(?:<[^<>]*>)?\s*\(([^()]*)\)\s*(?::\s*[^={]{1,80})?\{/)
-      if (method && !JS_NON_METHOD.has(method[1])) matched = { name: method[1], kind: 'method' }
+    let joinedText = null
+    
+    // Check for interface / type alias first (on raw line, not masked)
+    const ifaceSig = extractInterfaceOrType(rawText)
+    if (ifaceSig) {
+      const nameMatch = rawText.match(/^(?:export\s+)?(?:interface|type)\s+(\w+)/)
+      if (nameMatch) {
+        matched = { name: nameMatch[1], kind: 'interface', typeSig: ifaceSig }
+      }
     }
-    if (!matched) matched = matchJsLike(text)
-    if (!matched && JS_DECL_START.test(text)) {
-      let joined = text
+    
+    if (!matched) {
+      // Check for method inside class (prev line ends with {)
+      if (prevOpensBlock) {
+        const method = maskedText.match(/^([A-Za-z_$][\w$]*)\s*(?:<[^<>]*>)?\s*\(([^()]*)\)\s*(?::\s*[^={]{1,80})?\{/)
+        if (method && !JS_NON_METHOD.has(method[1])) matched = { name: method[1], kind: 'method' }
+      }
+      
+      // Regular declarations - try initial match
+      if (!matched) matched = matchJsLike(maskedText)
+    }
+    
+    // Multi-line declaration joining (only when no initial match, or when match is pending)
+    if ((!matched || (matched && matched.name === '(pending)')) && JS_DECL_START.test(maskedText)) {
+      // No initial match, or pending match - do joining to find/resolve one
+      let joined = maskedText
       let extra = 0
-      for (let j = i + 1; j < masked.length && extra < 3; j++) {
+      let declMatched = null
+      for (let j = i + 1; j < masked.length && extra < 5; j++) {
         const tail = masked[j].trim()
         if (!tail) continue
         joined += ' ' + tail
         extra++
-        matched = matchJsLike(joined)
-        if (matched) {
-          i = j
+        if (!declMatched) declMatched = matchJsLike(joined)
+        if (/[{};]/.test(tail)) {
+          if (declMatched && declMatched.name !== '(pending)') {
+            matched = declMatched
+            i = j
+            joinedText = joined
+          }
           break
         }
-        if (/[{};]/.test(tail)) break
       }
+      if (!matched && declMatched && declMatched.name !== '(pending)') {
+        matched = declMatched
+        joinedText = joined
+      }
+    }
+    
+    if (matched) {
+      // Extract type signature: use joined text if multi-line, else raw line
+      if (matched.kind !== 'interface') {
+        const sourceForType = joinedText || rawText
+        const typeSig = extractTypeSignature(sourceForType)
+        if (typeSig) matched.typeSig = typeSig
+      }
+      
+      // Extract overloads for function declarations
+      if (matched.kind === 'function' && (joinedText || rawText).startsWith('function')) {
+        const overloads = extractOverloads(masked, i)
+        if (overloads.length > 1) matched.overloads = overloads
+      }
+      
+      symbols.push(buildSymbol(matched, relPath, rawLines[i], i + 1))
     }
-    if (matched) symbols.push(buildSymbol(matched, filePath, rawLines[i], i + 1))
+    
     prevOpensBlock = masked[i].trim().endsWith('{')
   }
   return symbols
 }
 
-function scanPython(masked, filePath, rawLines) {
+function scanPython(masked, relPath, rawLines) {
   const symbols = []
   let depth = 0
   for (let i = 0; i < masked.length; i++) {
@@ -169,7 +317,7 @@ function scanPython(masked, filePath, rawLines) {
     const cls = fn ? null : text.match(/^class\s+(\w+)\s*[(:]/)
     if (fn) matched = { name: fn[1], kind: 'function' }
     else if (cls) matched = { name: cls[1], kind: 'class' }
-    if (matched) symbols.push(buildSymbol(matched, filePath, rawLines[i], i + 1))
+    if (matched) symbols.push(buildSymbol(matched, relPath, rawLines[i], i + 1))
     depth += delta
   }
   return symbols
@@ -208,24 +356,87 @@ function matchShell(line) {
   return m ? { name: m[1], kind: 'function' } : null
 }
 
-function buildSymbol(matched, filePath, rawLine, lineNo) {
+function extractParamsAndReturn(line) {
+  const trimmed = line.trim()
+  
+  // Try to extract params and return type from function declaration
+  // Matches: function name(params): returnType { or => returnType {
+  const funcMatch = line.match(/function\s+([A-Za-z_$][\w$]*)\s*(\([^)]*\))\s*(?::\s*([^{]+))?\s*\{/)
+  if (funcMatch) {
+    const params = funcMatch[2] || '()'
+    const returnType = funcMatch[3] ? `: ${funcMatch[3].trim()}` : ''
+    return `${funcMatch[1]}${params}${returnType}`
+  }
+  
+  // Arrow function: const name = (params): returnType => {
+  const arrowMatch = line.match(/const\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s+)?\(([^)]*)\)\s*:\s*([^=]+)\s*=>/)
+  if (arrowMatch) {
+    return `${arrowMatch[1]}(${arrowMatch[2]}): ${arrowMatch[3].trim()}`
+  }
+  
+  // Arrow function without explicit return type: const name = (params) => {
+  const arrowSimple = line.match(/const\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s+)?\(([^)]*)\)\s*=>/)
+  if (arrowMatch) {
+    return `${arrowMatch[1]}(${arrowMatch[2]})`
+  }
+  
+  // Class method: methodName(params): returnType {
+  const methodMatch = line.match(/^\s*([A-Za-z_$][\w$]*)\s*(?:<[^<>]*>)?\s*\(([^()]*)\)\s*(?::\s*([^{]+))?\s*\{/)
+  if (methodMatch) {
+    const returnType = methodMatch[3] ? `: ${methodMatch[3].trim()}` : ''
+    return `${methodMatch[1]}(${methodMatch[2] || ''})${returnType}`
+  }
+  
+  // Constructor
+  const constructorMatch = line.match(/constructor\s*\(([^)]*)\)/)
+  if (constructorMatch) {
+    return `constructor(${constructorMatch[1]})`
+  }
+  
+  // Fallback: try to extract from the raw line
+  const declMatch = line.match(/(function|const|let|var)\s+([A-Za-z_$][\w$]*)/)
+  if (declMatch) {
+    return declMatch[0]
+  }
+  
+  // Fallback: return the raw line trimmed
+  return ''
+}
+
+function buildSymbol(matched, relPath, rawLine, lineNo) {
+  // Use pre-extracted type signature if available, otherwise fall back to extractParamsAndReturn
+  let typeSig = matched.typeSig || extractParamsAndReturn(rawLine)
+  
+  // Add overloads if present
+  const overloadPart = matched.overloads?.length
+    ? ` | overloads: ${matched.overloads.join('; ')}`
+    : ''
+  
+  // For interface/type, typeSig already includes the full signature without name
+  // For others, typeSig is just the generics+params+return
+  const prefix = matched.kind === 'interface' ? '' : matched.name
+  
+  // Build one-line identity: name<Generics>(params): ReturnType — file.ts:lineNo
+  const identity = `${prefix}${typeSig}${overloadPart} — ${relPath}:${lineNo}`
+
   return {
-    id: `${String(filePath).replace(/[\\/:\s]/g, '_')}#${lineNo}`,
-    sourcePath: filePath,
+    id: `${String(relPath).replace(/[\\/:\s]/g, '_')}#${lineNo}`,
+    sourcePath: relPath,
     sourceLine: lineNo,
     type: 'symbol',
     title: `${matched.name} (${matched.kind})`,
-    summary: `${matched.kind} "${matched.name}" declared at ${filePath}:${lineNo}`,
     keywords: [matched.name, matched.kind],
-    text: String(rawLine).trim().slice(0, 200),
+    text: identity,
   }
 }
 
-export function scanSymbols(filePath, content) {
-  const ext = filePath.slice(filePath.lastIndexOf('.'))
+export function scanSymbols(a, b, c) {
+  // Backward compatible: old signature (filePath, content) or new (relPath, filePath, content)
+  const [relPath, filePath, content] = c === undefined ? [a, a, b] : [a, b, c]
+  const ext = relPath.slice(relPath.lastIndexOf('.'))
   const lines = content.split(/\r?\n/)
-  if (JS_LIKE.has(ext)) return scanJsLike(maskTokens(lines, JS_MASKER), filePath, lines)
-  if (PYTHON.has(ext)) return scanPython(maskTokens(lines, PY_MASKER), filePath, lines)
+  if (JS_LIKE.has(ext)) return scanJsLike(maskTokens(lines, JS_MASKER), relPath, lines)
+  if (PYTHON.has(ext)) return scanPython(maskTokens(lines, PY_MASKER), relPath, lines)
 
   let masker = null
   if (GO.has(ext)) masker = GO_MASKER
@@ -247,7 +458,7 @@ export function scanSymbols(filePath, content) {
     else if (/^(?:def|func|fn|function)\s+(\w+)/.test(line)) {
       matched = { name: line.match(/^(?:def|func|fn|function)\s+(\w+)/)[1], kind: 'function' }
     }
-    if (matched) symbols.push(buildSymbol(matched, filePath, raw, i + 1))
+    if (matched) symbols.push(buildSymbol(matched, relPath, raw, i + 1))
   }
   return symbols
 }

package/src/tools/index-doc.js

@@ -42,7 +42,7 @@ export function indexDocTool(ctx, config) {
         return `Skipped (unchanged): ${rel}\nAlready indexed with ${(store.entries[rel] || []).length} entry/entries.`
       }
 
-      const entries = await buildDocEntries(ctx.llm, filePath, {
+      const entries = await buildDocEntries(ctx.llm, rel, filePath, {
         chunkChars: config.chunkChars,
         maxChunks: config.maxChunksPerFile,
         maxFileSizeMb: config.maxFileSizeMb,

package/src/tools/index-repo.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 { onFileIndexed, isTypeScriptFile } from '../enhancer.js'
 
 export async function indexRepository(ctx, config, root, { reindex = false } = {}) {
   const memoryDir = memoryRootFor(root, config.memoryDir)
@@ -47,7 +48,7 @@ export async function indexRepository(ctx, config, root, { reindex = false } = {
       let entries
       if (isSupportedCode(ext)) {
         const content = readFileSync(filePath, 'utf8')
-        entries = scanSymbols(filePath, content)
+        entries = scanSymbols(rel, filePath, content)
         fileUpdates.push({ rel, expectedHash: existing?.sha256, hash, size, entries, type: 'code' })
         updated++
       } else {
@@ -57,7 +58,7 @@ export async function indexRepository(ctx, config, root, { reindex = false } = {
           skipped++
           continue
         }
-        entries = await buildDocEntries(ctx.llm, filePath, {
+        entries = await buildDocEntries(ctx.llm, rel, filePath, {
           chunkChars: config.chunkChars,
           maxChunks: config.maxChunksPerFile,
           maxFileSizeMb: config.maxFileSizeMb,
@@ -77,7 +78,7 @@ export async function indexRepository(ctx, config, root, { reindex = false } = {
   }
 
   // Second pass: single commit with all updates
-  return store.commit((s) => {
+  const report = store.commit((s) => {
     for (const update of fileUpdates) {
       const result = s.applyFileUpdate(update.rel, update)
       if (result.skipped) {
@@ -105,6 +106,18 @@ export async function indexRepository(ctx, config, root, { reindex = false } = {
     }
     return report
   })
+
+  // Trigger TS enhancement for code files (TS/JS only)
+  for (const update of fileUpdates) {
+    if (update.type === 'code') {
+      const filePath = path.join(root, update.rel)
+      if (isTypeScriptFile(filePath)) {
+        onFileIndexed(store, update.rel, filePath, config, root)
+      }
+    }
+  }
+
+  return report
 }
 
 export function indexRepoTool(ctx, config) {

package/src/tools/query-memory.js

@@ -1,10 +1,15 @@
 import { defineTool } from '@deepseek-ai/dsh-tools'
+import path from 'node:path'
 import { memoryRootFor, resolveIndexRoot } from '../util/fs.js'
 import { ProjectMemoryStore, storeOverview } from '../store.js'
 import { expandQuery } from '../llm.js'
 import { rankEntriesMergedScored, rankExperienceScored } from '../util/search.js'
 import { truncate } from '../util/text.js'
 
+function toAbs(root, rel) {
+  return path.isAbsolute(rel) ? rel : path.join(root, rel)
+}
+
 export function queryMemoryTool(ctx, config) {
   return defineTool({
     name: 'query_memory',
@@ -59,13 +64,13 @@ export function queryMemoryTool(ctx, config) {
           const top = scored[0].score || 1
           lines.push(`## Memory (${type === 'all' ? 'docs + symbols' : type})`)
           for (const { entry: e, score } of scored) {
-            const source = e.sourceLine ? `${e.sourcePath}:${e.sourceLine}` : e.sourcePath
+            const absSource = e.sourceLine ? `${toAbs(root, e.sourcePath)}:${e.sourceLine}` : toAbs(root, e.sourcePath)
             const rel = Math.round((score / top) * 100)
-            lines.push(`### ${e.title} (score: ${rel})\n- source: ${source}\n- ${e.summary}`)
+            lines.push(`### ${e.title} (score: ${rel})\n- source: ${absSource}\n- ${e.summary}`)
             if (e.type === 'doc' && Array.isArray(e.linkedSymbols) && e.linkedSymbols.length) {
               const refs = e.linkedSymbols.slice(0, 5).map((id) => {
                 const s = symbolById.get(id)
-                return s ? `${s.title} @ ${s.sourcePath}:${s.sourceLine}` : id
+                return s ? `${s.title} @ ${toAbs(root, s.sourcePath)}:${s.sourceLine}` : id
               })
               lines.push(`- references: ${refs.join('; ')}`)
             }
@@ -78,7 +83,7 @@ export function queryMemoryTool(ctx, config) {
           const expTop = scoredExp[0].score || 1
           lines.push(`## Experience (past problems -> solutions)`)
           for (const { item: e, score } of scoredExp) {
-            const source = e.sourceFile ? ` (source: ${e.sourceFile})` : ''
+            const source = e.sourceFile ? ` (source: ${toAbs(root, e.sourceFile)})` : ''
             lines.push(
               `### Problem: ${e.problem} (score: ${Math.round((score / expTop) * 100)}, id: ${e.id})\n- solution: ${e.solution}${source}\n- updated: ${e.updatedAt}`,
             )

package/src/util/fs.js

@@ -85,7 +85,7 @@ export function looksLikeDump(text, maxBytes = 4096) {
 
 export function isSupportedCode(ext) {
   return [
-    '.js', '.mjs', '.cjs', '.ts', '.jsx', '.tsx', '.py', '.java', '.go',
+    '.js', '.mjs', '.cjs', '.ts', '.mts', '.cts', '.jsx', '.tsx', '.py', '.java', '.go',
     '.rs', '.c', '.cpp', '.cc', '.h', '.hpp', '.cs', '.php', '.rb',
     '.swift', '.kt', '.kts', '.sh', '.zsh',
   ].includes(ext)

package/src/watch.js

@@ -5,6 +5,7 @@ import { buildDocEntries } from './doc-pipeline.js'
 import { scanSymbols } from './symbols.js'
 import { linkEntries } from './link.js'
 import { ProjectMemoryStore } from './store.js'
+import { onFileChanged, isTypeScriptFile } from './enhancer.js'
 
 export class WatchManager {
   constructor(ctx, config) {
@@ -95,9 +96,9 @@ export class WatchManager {
       try {
         let entries
         if (isSupportedCode(ext)) {
-          entries = scanSymbols(filePath, readFileSync(filePath, 'utf8'))
+          entries = scanSymbols(rel, filePath, readFileSync(filePath, 'utf8'))
         } else {
-          entries = await buildDocEntries(this.ctx.llm, filePath, {
+          entries = await buildDocEntries(this.ctx.llm, rel, filePath, {
             chunkChars: this.config.chunkChars,
             maxChunks: this.config.maxChunksPerFile,
             maxFileSizeMb: this.config.maxFileSizeMb,
@@ -144,12 +145,15 @@ export class WatchManager {
       }
     })
 
-    // Update snapshot for successfully processed files only, using the
-    // first-pass signature: if the file changed during the compute window
-    // (hash / scanSymbols / LLM summary), the next poll's signature differs
-    // and the file is re-indexed — restoring the pre-refactor self-healing.
+    // Trigger TS enhancement for code files (TS/JS only)
     for (const update of fileUpdates) {
       if (update._skipSnapshot) continue
+      if (update.type === 'code') {
+        const filePath = path.join(root, update.rel)
+        if (isTypeScriptFile(filePath)) {
+          onFileChanged(state.store, update.rel, filePath, this.config, root)
+        }
+      }
       state.snapshot[update.rel] = update._sig
     }
   }