@try-works/dsh-memory 0.1.29 → 0.1.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@try-works/dsh-memory",
-  "version": "0.1.29",
+  "version": "0.1.30",
   "description": "Git-backed, workspace-scoped memory for the DeepSeek Harness (global layer + per-workspace layers)",
   "type": "module",
   "main": "src/index.js",

package/src/inject.js

@@ -1,9 +1,9 @@
 // Session-start injection text: goal + working head + recent learnings + footer,
 // char-capped and scope-aware.
-import { existsSync, readFileSync } from 'node:fs'
+import { existsSync, readdirSync, readFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { layerDir } from './store.js'
-import { buildLedger } from './ledger.js'
+import { buildLedgerFor } from './ledger.js'
 import { readLayerTopics } from './layers.js'
 import { freshnessMarker, readState } from './state.js'
 import { readWorking, workingMarker } from './working.js'
@@ -12,7 +12,11 @@ import { relevanceQuery, selectEntries } from './select.js'
 export function buildInjectionText(store, { scope = 'global', key, goal, maxChars = 3600, subagent = false } = {}) {
   const dir = layerDir(store.root, scope, key)
   // Working memory is the AGENT's intent (task, recent activity, next steps); repository
-  const ledger = buildLedger(store.root)
+  //
+  // Only the two layers this card actually quotes are read. Building the whole ledger here meant
+  // walking every indexed file - ~8,000 of them, history shards included - on every injection,
+  // which measured ~17 s and dwarfed the text it produced.
+  const ledger = buildLedgerFor(store.root, layerFilesFor(dir, ['learnings', 'decisions']))
   const prefix = scope === 'global' ? 'global/' : 'workspaces/' + key + '/'
   // The pools are LISTED here and CHOSEN later, because choosing needs the question, and the
   // question comes from working memory - which is read below.
@@ -106,3 +110,24 @@ export function buildInjectionText(store, { scope = 'global', key, goal, maxChar
   const body = parts.join('\n\n')
   return (body.length <= maxChars ? body : body.slice(0, maxChars)) + '\n\n' + footer
 }
+
+/**
+ * The absolute file paths of the named layer directories in one scope.
+ *
+ * Layer directories are flat (one topic file per entry), so listing them is cheap. This exists
+ * because the injection card quotes only learnings and decisions: reading every OTHER layer -
+ * semantic, episodic, procedural, codebase, history - was the expensive part of the old
+ * whole-store ledger, and none of it could ever appear in the card.
+ * @param dir - the scope directory (a layer dir already), from {@link layerDir}.
+ * @param layers - directory names under it, e.g. 'learnings' and 'decisions'.
+ * @returns absolute paths, in directory order.
+ */
+function layerFilesFor(dir, layers) {
+  const files = []
+  for (const name of layers) {
+    const layerPath = join(dir, name)
+    if (!existsSync(layerPath)) continue
+    for (const file of readdirSync(layerPath)) if (file.endsWith('.md')) files.push(join(layerPath, file))
+  }
+  return files
+}

package/src/ledger.js

@@ -1,19 +1,47 @@
-// Derived entry ledger: per-entry metadata (file, layer, line span, importance,
-// dates) rebuilt from the markdown in one step. Feeds ranking + freshness.
-import { readFileSync } from 'node:fs'
-import { relative } from 'node:path'
-import { indexedFiles, layerOfFile } from './files.js'
-import { parseEntries } from './entry.js'
-
-export function buildLedger(root) {
-  const entries = []
-  for (const file of indexedFiles(root)) {
-    const rel = relative(root, file).replace(/\\/g, '/')
-    const layer = layerOfFile(root, file)
-    if (!layer) continue
-    for (const e of parseEntries(readFileSync(file, 'utf8'))) {
-      entries.push({ ...e, file: rel, layer })
-    }
-  }
-  return entries
-}
+// Derived entry ledger: per-entry metadata (file, layer, line span, importance,
+// dates) rebuilt from the markdown in one step. Feeds ranking + freshness.
+import { readFileSync } from 'node:fs'
+import { isAbsolute, join, relative, sep } from 'node:path'
+import { indexedFiles, layerOfFile } from './files.js'
+import { parseEntries } from './entry.js'
+
+export function buildLedger(root) {
+  const entries = []
+  for (const file of indexedFiles(root)) {
+    const rel = relative(root, file).replace(/\\/g, '/')
+    const layer = layerOfFile(root, file)
+    if (!layer) continue
+    for (const e of parseEntries(readFileSync(file, 'utf8'))) {
+      entries.push({ ...e, file: rel, layer })
+    }
+  }
+  return entries
+}
+
+/**
+ * Build entries for a KNOWN SET of files instead of the whole store.
+ *
+ * The full ledger reads every indexed file, and on this store that is ~8,000 files and ~17 s —
+ * far too expensive for a call that only needs a handful. Both callers below know which files
+ * can possibly matter: ranking needs the files that produced a hit, and the injection card needs
+ * only the two layers it quotes. Reading the rest was pure I/O.
+ * @param files - paths, absolute or root-relative with forward slashes; duplicates are ignored.
+ * @returns the same entry shape as {@link buildLedger}, for the files that resolved to a layer.
+ */
+export function buildLedgerFor(root, files) {
+  const entries = []
+  const seen = new Set()
+  for (const file of files) {
+    if (!file) continue
+    const abs = isAbsolute(file) ? file : join(root, String(file).split('/').join(sep))
+    const rel = relative(root, abs).replace(/\\/g, '/')
+    if (seen.has(rel)) continue
+    seen.add(rel)
+    const layer = layerOfFile(root, abs)
+    if (!layer) continue
+    let text
+    try { text = readFileSync(abs, 'utf8') } catch { continue }
+    for (const e of parseEntries(text)) entries.push({ ...e, file: rel, layer })
+  }
+  return entries
+}

package/src/search.js

@@ -7,7 +7,7 @@
 import { existsSync } from 'node:fs'
 import { DatabaseSync } from 'node:sqlite'
 import { buildFtsQuery, buildIndex, buildLikeQuery, buildTrigramQuery, indexPath, needsSubstring, SUBSTRING_TABLE } from './fts.js'
-import { buildLedger } from './ledger.js'
+import { buildLedgerFor } from './ledger.js'
 import { rankBlend } from './rank.js'
 
 /** Rows pulled from the word index before ranking. */
@@ -67,7 +67,9 @@ export function search(store, query, { limit = 10, scope, key } = {}) {
     if (scope === 'global') filtered = rows.filter((r) => r.file.startsWith('global/'))
     else if (scope === 'workspace') filtered = rows.filter((r) => r.file.startsWith('workspaces/' + (key ?? '') + '/'))
     const hits = filtered.map((r) => ({ file: r.file, line: r.line, section: r.section, snippet: String(r.content).trim() }))
-    return rankBlend(hits, buildLedger(store.root)).slice(0, limit)
+    // Ranking needs importance and recency only for the files that matched. Building the whole
+    // ledger here read ~8,000 files for a handful of hits and made one query cost ~15 s.
+    return rankBlend(hits, buildLedgerFor(store.root, hits.map((h) => h.file))).slice(0, limit)
       .map((h) => ({ file: h.file, line: h.line, section: h.section ?? '', snippet: h.snippet, id: h.id ?? '', score: Math.round(h.score * 1000) / 1000 }))
   } finally {
     db.close()