@try-works/dsh-memory 0.1.19 → 0.1.20

package/src/fts.js

@@ -1,166 +1,166 @@
-// FTS5 index + query builder (node:sqlite). Derived artifact — regenerable, gitignored.
-import { DatabaseSync } from 'node:sqlite'
-import { existsSync, mkdirSync, readFileSync } from 'node:fs'
-import { join, relative, sep } from 'node:path'
-import { indexedFiles } from './files.js'
-
-export const STOPWORDS = new Set([
-  'a', 'an', 'the', 'is', 'are', 'was', 'were', 'be', 'been', 'being', 'am',
-  'of', 'to', 'in', 'on', 'at', 'for', 'by', 'with', 'about', 'into', 'from',
-  'and', 'or', 'not', 'but', 'if', 'then', 'so', 'than', 'too', 'very',
-  'this', 'that', 'these', 'those', 'it', 'its', 'i', 'you', 'he', 'she', 'we', 'they',
-  'do', 'does', 'did', 'have', 'has', 'had', 'will', 'would', 'can', 'could', 'should',
-  'what', 'who', 'whom', 'when', 'where', 'why', 'how', 'which', 'there', 'here',
-])
-
-export function indexPath(root) { return join(root, 'index', 'memory.fts.sqlite') }
-
-/**
- * OR of phrase-prefix queries over letter/number tokens (drop stopwords + <2 char terms).
- * Tokens align with FTS5 unicode61, which treats _ . / - as separators.
- */
-export function buildFtsQuery(input) {
-  const terms = String(input ?? '').match(/[\p{L}\p{N}]+/gu) ?? []
-  const words = terms.filter((w) => w.length >= 2 && !STOPWORDS.has(w.toLowerCase()))
-  if (words.length === 0) return null
-  return words.map((w) => '"' + w + '"*').join(' OR ')
-}
-
-/**
- * Scripts written without spaces (CJK and similar) cannot be searched as words: the unicode61
- * tokenizer treats a whole run as ONE token, so a substring never matches. Those queries take
- * the substring (trigram) index instead.
- */
-const NO_SPACE_SCRIPT = new RegExp('[' + String.fromCharCode(0x3040) + '-' + String.fromCharCode(0x30ff)
-  + String.fromCharCode(0x3400) + '-' + String.fromCharCode(0x4dbf)
-  + String.fromCharCode(0x4e00) + '-' + String.fromCharCode(0x9fff)
-  + String.fromCharCode(0xf900) + '-' + String.fromCharCode(0xfaff)
-  + String.fromCharCode(0xac00) + '-' + String.fromCharCode(0xd7af) + ']')
-
-/** True when a query needs substring matching rather than word matching. */
-export function needsSubstring(input) { return NO_SPACE_SCRIPT.test(String(input ?? '')) }
-
-/**
- * A trigram MATCH expression. The trigram tokenizer matches inside a phrase, so the query is
- * quoted; it needs at least three characters, and shorter input cannot be matched at all.
- * @returns the expression, or null when it cannot match.
- */
-export function buildTrigramQuery(input) {
-  const text = String(input ?? '').trim().split('"').join(' ').replace(/\s+/g, ' ')
-  if (text.length < 3) return null
-  return '"' + text + '"'
-}
-
-/**
- * Create both indexes when missing. The word table serves normal queries; the trigram table
- * serves substring queries (no-space scripts), which the word tokenizer cannot express.
- */
-function ensureTables(db) {
-  db.exec('CREATE VIRTUAL TABLE IF NOT EXISTS mem_fts USING fts5(file, line, section, content)')
-  try { db.exec("CREATE VIRTUAL TABLE IF NOT EXISTS " + SUBSTRING_TABLE + " USING fts5(file, line, section, content, tokenize='trigram')") }
-  catch { /* a build without trigram still works, just without substring search */ }
-}
-
-/**
- * A LIKE pattern for queries too short for the trigram index. CJK words are frequently only
- * two characters - 内存, 系统 - and the trigram tokenizer cannot express fewer than three, so
- * those would otherwise be unsearchable. The pattern is escaped so user input cannot inject
- * wildcards, and a bounded scan is acceptable for a personal store.
- * @returns the pattern, or null when the query is unusable.
- */
-export function buildLikeQuery(input) {
-  const text = String(input ?? '').trim()
-  if (text === '') return null
-  const escaped = text.replace(/[\\%_]/g, (ch) => '\\' + ch)
-  return '%' + escaped + '%'
-}
-
-/** The trigram (substring) table name. */
-export const SUBSTRING_TABLE = 'mem_fts_tri'
-
-/** Rebuild the FTS index from the committed layer files. file is root-relative (git-portable). */
-/** Insert every non-empty line of one file, tracking its section headings. */
-function indexFile(db, root, file) {
-  const insert = db.prepare('INSERT INTO mem_fts (file, line, section, content) VALUES (?, ?, ?, ?)')
-  const insertTri = db.prepare('INSERT INTO ' + SUBSTRING_TABLE + ' (file, line, section, content) VALUES (?, ?, ?, ?)')
-  const rel = relative(root, file).replace(/\\/g, '/')
-  const lines = readFileSync(file, 'utf8').split('\n')
-  let section = ''
-  let rows = 0
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i]
-    const h = line.match(/^##\s+(.+)$/)
-    if (h) section = h[1].trim()
-    if (line.trim() === '') continue
-    insert.run(rel, i + 1, section, line)
-    insertTri.run(rel, i + 1, section, line)
-    rows++
-  }
-  return rows
-}
-
-/** A root-relative path, always with forward slashes. */
-function relOf(root, file) { return relative(root, file).replace(/\\/g, '/') }
-
-/**
- * Index just the files a write touched. A full rebuild re-reads and re-tokenizes the whole
- * store, which costs seconds once the store has a few hundred entries - and it used to run on
- * every single write. This keeps one write O(that file).
- * @param files - absolute paths to (re)index.
- * @returns the number of lines inserted.
- */
-export function updateIndex(root, files) {
-  const list = [...new Set(files)].filter(Boolean)
-  if (list.length === 0) return { rows: 0, files: 0 }
-  mkdirSync(join(root, 'index'), { recursive: true })
-  const db = new DatabaseSync(indexPath(root))
-  ensureTables(db)
-  // Rows survive a rename or a delete unless something removes them explicitly, and a ghost
-  // hit points at a file that no longer exists. Purge first, then re-insert what was asked for.
-  purgeMissing(db, root)
-  const drop = db.prepare('DELETE FROM mem_fts WHERE file = ?')
-  let dropTri
-  try { dropTri = db.prepare('DELETE FROM ' + SUBSTRING_TABLE + ' WHERE file = ?') } catch { dropTri = undefined }
-  let rows = 0
-  for (const file of list) {
-    drop.run(relOf(root, file))
-    if (dropTri) try { dropTri.run(relOf(root, file)) } catch {}
-    try { rows += indexFile(db, root, file) } catch {}
-  }
-  db.close()
-  return { rows, files: list.length }
-}
-
-/**
- * Delete index rows whose file no longer exists on disk. Cheap enough to run on every
- * incremental update, and it is the only thing that notices a rename or a delete.
- * @returns how many stale file rows were removed.
- */
-export function purgeMissing(db, root) {
-  let removed = 0
-  for (const table of ['mem_fts', SUBSTRING_TABLE]) {
-    let files
-    try { files = db.prepare('SELECT DISTINCT file FROM ' + table).all() } catch { continue }
-    for (const row of files) {
-      // Stored paths are root-relative and forward-slashed.
-      const absolute = join(root, String(row.file).split('/').join(sep))
-      if (existsSync(absolute)) continue
-      try { db.prepare('DELETE FROM ' + table + ' WHERE file = ?').run(row.file); removed += 1 } catch {}
-    }
-  }
-  return removed
-}
-
-/** Rebuild the whole index. The repair path when it is missing or suspected stale. */
-export function buildIndex(root) {
-  const dbPath = indexPath(root)
-  mkdirSync(join(root, 'index'), { recursive: true })
-  const db = new DatabaseSync(dbPath)
-  db.exec('DROP TABLE IF EXISTS mem_fts')
-  db.exec('DROP TABLE IF EXISTS ' + SUBSTRING_TABLE)
-  ensureTables(db)
-  let rows = 0
-  for (const file of indexedFiles(root)) rows += indexFile(db, root, file)
-  db.close()
-  return { dbPath, rows }
-}
+// FTS5 index + query builder (node:sqlite). Derived artifact — regenerable, gitignored.
+import { DatabaseSync } from 'node:sqlite'
+import { existsSync, mkdirSync, readFileSync } from 'node:fs'
+import { join, relative, sep } from 'node:path'
+import { indexedFiles } from './files.js'
+
+export const STOPWORDS = new Set([
+  'a', 'an', 'the', 'is', 'are', 'was', 'were', 'be', 'been', 'being', 'am',
+  'of', 'to', 'in', 'on', 'at', 'for', 'by', 'with', 'about', 'into', 'from',
+  'and', 'or', 'not', 'but', 'if', 'then', 'so', 'than', 'too', 'very',
+  'this', 'that', 'these', 'those', 'it', 'its', 'i', 'you', 'he', 'she', 'we', 'they',
+  'do', 'does', 'did', 'have', 'has', 'had', 'will', 'would', 'can', 'could', 'should',
+  'what', 'who', 'whom', 'when', 'where', 'why', 'how', 'which', 'there', 'here',
+])
+
+export function indexPath(root) { return join(root, 'index', 'memory.fts.sqlite') }
+
+/**
+ * OR of phrase-prefix queries over letter/number tokens (drop stopwords + <2 char terms).
+ * Tokens align with FTS5 unicode61, which treats _ . / - as separators.
+ */
+export function buildFtsQuery(input) {
+  const terms = String(input ?? '').match(/[\p{L}\p{N}]+/gu) ?? []
+  const words = terms.filter((w) => w.length >= 2 && !STOPWORDS.has(w.toLowerCase()))
+  if (words.length === 0) return null
+  return words.map((w) => '"' + w + '"*').join(' OR ')
+}
+
+/**
+ * Scripts written without spaces (CJK and similar) cannot be searched as words: the unicode61
+ * tokenizer treats a whole run as ONE token, so a substring never matches. Those queries take
+ * the substring (trigram) index instead.
+ */
+const NO_SPACE_SCRIPT = new RegExp('[' + String.fromCharCode(0x3040) + '-' + String.fromCharCode(0x30ff)
+  + String.fromCharCode(0x3400) + '-' + String.fromCharCode(0x4dbf)
+  + String.fromCharCode(0x4e00) + '-' + String.fromCharCode(0x9fff)
+  + String.fromCharCode(0xf900) + '-' + String.fromCharCode(0xfaff)
+  + String.fromCharCode(0xac00) + '-' + String.fromCharCode(0xd7af) + ']')
+
+/** True when a query needs substring matching rather than word matching. */
+export function needsSubstring(input) { return NO_SPACE_SCRIPT.test(String(input ?? '')) }
+
+/**
+ * A trigram MATCH expression. The trigram tokenizer matches inside a phrase, so the query is
+ * quoted; it needs at least three characters, and shorter input cannot be matched at all.
+ * @returns the expression, or null when it cannot match.
+ */
+export function buildTrigramQuery(input) {
+  const text = String(input ?? '').trim().split('"').join(' ').replace(/\s+/g, ' ')
+  if (text.length < 3) return null
+  return '"' + text + '"'
+}
+
+/**
+ * Create both indexes when missing. The word table serves normal queries; the trigram table
+ * serves substring queries (no-space scripts), which the word tokenizer cannot express.
+ */
+function ensureTables(db) {
+  db.exec('CREATE VIRTUAL TABLE IF NOT EXISTS mem_fts USING fts5(file, line, section, content)')
+  try { db.exec("CREATE VIRTUAL TABLE IF NOT EXISTS " + SUBSTRING_TABLE + " USING fts5(file, line, section, content, tokenize='trigram')") }
+  catch { /* a build without trigram still works, just without substring search */ }
+}
+
+/**
+ * A LIKE pattern for queries too short for the trigram index. CJK words are frequently only
+ * two characters - 内存, 系统 - and the trigram tokenizer cannot express fewer than three, so
+ * those would otherwise be unsearchable. The pattern is escaped so user input cannot inject
+ * wildcards, and a bounded scan is acceptable for a personal store.
+ * @returns the pattern, or null when the query is unusable.
+ */
+export function buildLikeQuery(input) {
+  const text = String(input ?? '').trim()
+  if (text === '') return null
+  const escaped = text.replace(/[\\%_]/g, (ch) => '\\' + ch)
+  return '%' + escaped + '%'
+}
+
+/** The trigram (substring) table name. */
+export const SUBSTRING_TABLE = 'mem_fts_tri'
+
+/** Rebuild the FTS index from the committed layer files. file is root-relative (git-portable). */
+/** Insert every non-empty line of one file, tracking its section headings. */
+function indexFile(db, root, file) {
+  const insert = db.prepare('INSERT INTO mem_fts (file, line, section, content) VALUES (?, ?, ?, ?)')
+  const insertTri = db.prepare('INSERT INTO ' + SUBSTRING_TABLE + ' (file, line, section, content) VALUES (?, ?, ?, ?)')
+  const rel = relative(root, file).replace(/\\/g, '/')
+  const lines = readFileSync(file, 'utf8').split('\n')
+  let section = ''
+  let rows = 0
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+    const h = line.match(/^##\s+(.+)$/)
+    if (h) section = h[1].trim()
+    if (line.trim() === '') continue
+    insert.run(rel, i + 1, section, line)
+    insertTri.run(rel, i + 1, section, line)
+    rows++
+  }
+  return rows
+}
+
+/** A root-relative path, always with forward slashes. */
+function relOf(root, file) { return relative(root, file).replace(/\\/g, '/') }
+
+/**
+ * Index just the files a write touched. A full rebuild re-reads and re-tokenizes the whole
+ * store, which costs seconds once the store has a few hundred entries - and it used to run on
+ * every single write. This keeps one write O(that file).
+ * @param files - absolute paths to (re)index.
+ * @returns the number of lines inserted.
+ */
+export function updateIndex(root, files) {
+  const list = [...new Set(files)].filter(Boolean)
+  if (list.length === 0) return { rows: 0, files: 0 }
+  mkdirSync(join(root, 'index'), { recursive: true })
+  const db = new DatabaseSync(indexPath(root))
+  ensureTables(db)
+  // Rows survive a rename or a delete unless something removes them explicitly, and a ghost
+  // hit points at a file that no longer exists. Purge first, then re-insert what was asked for.
+  purgeMissing(db, root)
+  const drop = db.prepare('DELETE FROM mem_fts WHERE file = ?')
+  let dropTri
+  try { dropTri = db.prepare('DELETE FROM ' + SUBSTRING_TABLE + ' WHERE file = ?') } catch { dropTri = undefined }
+  let rows = 0
+  for (const file of list) {
+    drop.run(relOf(root, file))
+    if (dropTri) try { dropTri.run(relOf(root, file)) } catch {}
+    try { rows += indexFile(db, root, file) } catch {}
+  }
+  db.close()
+  return { rows, files: list.length }
+}
+
+/**
+ * Delete index rows whose file no longer exists on disk. Cheap enough to run on every
+ * incremental update, and it is the only thing that notices a rename or a delete.
+ * @returns how many stale file rows were removed.
+ */
+export function purgeMissing(db, root) {
+  let removed = 0
+  for (const table of ['mem_fts', SUBSTRING_TABLE]) {
+    let files
+    try { files = db.prepare('SELECT DISTINCT file FROM ' + table).all() } catch { continue }
+    for (const row of files) {
+      // Stored paths are root-relative and forward-slashed.
+      const absolute = join(root, String(row.file).split('/').join(sep))
+      if (existsSync(absolute)) continue
+      try { db.prepare('DELETE FROM ' + table + ' WHERE file = ?').run(row.file); removed += 1 } catch {}
+    }
+  }
+  return removed
+}
+
+/** Rebuild the whole index. The repair path when it is missing or suspected stale. */
+export function buildIndex(root) {
+  const dbPath = indexPath(root)
+  mkdirSync(join(root, 'index'), { recursive: true })
+  const db = new DatabaseSync(dbPath)
+  db.exec('DROP TABLE IF EXISTS mem_fts')
+  db.exec('DROP TABLE IF EXISTS ' + SUBSTRING_TABLE)
+  ensureTables(db)
+  let rows = 0
+  for (const file of indexedFiles(root)) rows += indexFile(db, root, file)
+  db.close()
+  return { dbPath, rows }
+}

package/src/git.js

@@ -1,53 +1,53 @@
-// Git operations + sync scheduling. The runner is injectable so the logic is
-// unit-testable without a git binary; the plugin injects ctx.subprocess.
-export function commitMessage(scope, summary) {
-  return 'memory(' + (scope || 'store') + '): ' + (summary || 'update') + ' [dsh-memory]'
-}
-
-export class GitRunner {
-  /** @param {(argv: string[], opts?: {cwd?: string}) => Promise<{code?: number|null, stdout?: string, stderr?: string}>} run */
-  constructor(run) { this.run = run }
-  init(cwd) { return this.run(['init'], { cwd }) }
-  remoteGet(cwd) { return this.run(['remote', 'get-url', 'origin'], { cwd }) }
-  remoteAdd(cwd, url) { return this.run(['remote', 'add', 'origin', url], { cwd }) }
-  remoteSet(cwd, url) { return this.run(['remote', 'set-url', 'origin', url], { cwd }) }
-  add(cwd, paths) { return this.run(['add', '--', ...paths], { cwd }) }
-  addAll(cwd) { return this.run(['add', '-A'], { cwd }) }
-  commit(cwd, msg) { return this.run(['commit', '-m', msg], { cwd }) }
-  pull(cwd, branch) { return this.run(['pull', '--rebase', '--autostash', 'origin', branch], { cwd }) }
-  push(cwd, branch) { return this.run(['push', 'origin', branch], { cwd }) }
-  statusPorcelain(cwd) { return this.run(['status', '--porcelain'], { cwd }) }
-}
-
-/**
- * Classify a git run result. Sync used to swallow every failure with a bare
- * `.catch()`, which let a rebase conflict diverge the store with no signal at all.
- * @returns {{ok: boolean, conflicted?: boolean, reason?: string}}
- */
-export function classifyGitResult(result) {
-  if (!result) return { ok: false, reason: 'git produced no result' }
-  if (result.code === 0) return { ok: true }
-  const stdout = String(result.stdout ?? '')
-  const stderr = String(result.stderr ?? '')
-  const combined = stdout + ' ' + stderr
-  const conflicted = /conflict|automatic merge failed|needs merge|could not apply/i.test(combined)
-  const reason = (stderr.trim() || stdout.trim() || 'exit code ' + String(result.code)).slice(0, 400)
-  return { ok: false, conflicted, reason }
-}
-
-/** Debounced local commit + hourly remote sync, with an injectable clock. */
-export class SyncScheduler {
-  constructor({ commitDebounceMs = 10000, syncIntervalMs = 3600000, now = () => Date.now() } = {}) {
-    this.commitDebounceMs = commitDebounceMs
-    this.syncIntervalMs = syncIntervalMs
-    this.now = now
-    this.dirty = false
-    this.lastCommitAt = 0
-    this.lastSyncAt = 0
-  }
-  markDirty() { this.dirty = true }
-  shouldCommit() { return this.dirty && (this.now() - this.lastCommitAt) >= this.commitDebounceMs }
-  committed() { this.dirty = false; this.lastCommitAt = this.now() }
-  shouldSync() { return (this.now() - this.lastSyncAt) >= this.syncIntervalMs }
-  synced() { this.lastSyncAt = this.now() }
-}
+// Git operations + sync scheduling. The runner is injectable so the logic is
+// unit-testable without a git binary; the plugin injects ctx.subprocess.
+export function commitMessage(scope, summary) {
+  return 'memory(' + (scope || 'store') + '): ' + (summary || 'update') + ' [dsh-memory]'
+}
+
+export class GitRunner {
+  /** @param {(argv: string[], opts?: {cwd?: string}) => Promise<{code?: number|null, stdout?: string, stderr?: string}>} run */
+  constructor(run) { this.run = run }
+  init(cwd) { return this.run(['init'], { cwd }) }
+  remoteGet(cwd) { return this.run(['remote', 'get-url', 'origin'], { cwd }) }
+  remoteAdd(cwd, url) { return this.run(['remote', 'add', 'origin', url], { cwd }) }
+  remoteSet(cwd, url) { return this.run(['remote', 'set-url', 'origin', url], { cwd }) }
+  add(cwd, paths) { return this.run(['add', '--', ...paths], { cwd }) }
+  addAll(cwd) { return this.run(['add', '-A'], { cwd }) }
+  commit(cwd, msg) { return this.run(['commit', '-m', msg], { cwd }) }
+  pull(cwd, branch) { return this.run(['pull', '--rebase', '--autostash', 'origin', branch], { cwd }) }
+  push(cwd, branch) { return this.run(['push', 'origin', branch], { cwd }) }
+  statusPorcelain(cwd) { return this.run(['status', '--porcelain'], { cwd }) }
+}
+
+/**
+ * Classify a git run result. Sync used to swallow every failure with a bare
+ * `.catch()`, which let a rebase conflict diverge the store with no signal at all.
+ * @returns {{ok: boolean, conflicted?: boolean, reason?: string}}
+ */
+export function classifyGitResult(result) {
+  if (!result) return { ok: false, reason: 'git produced no result' }
+  if (result.code === 0) return { ok: true }
+  const stdout = String(result.stdout ?? '')
+  const stderr = String(result.stderr ?? '')
+  const combined = stdout + ' ' + stderr
+  const conflicted = /conflict|automatic merge failed|needs merge|could not apply/i.test(combined)
+  const reason = (stderr.trim() || stdout.trim() || 'exit code ' + String(result.code)).slice(0, 400)
+  return { ok: false, conflicted, reason }
+}
+
+/** Debounced local commit + hourly remote sync, with an injectable clock. */
+export class SyncScheduler {
+  constructor({ commitDebounceMs = 10000, syncIntervalMs = 3600000, now = () => Date.now() } = {}) {
+    this.commitDebounceMs = commitDebounceMs
+    this.syncIntervalMs = syncIntervalMs
+    this.now = now
+    this.dirty = false
+    this.lastCommitAt = 0
+    this.lastSyncAt = 0
+  }
+  markDirty() { this.dirty = true }
+  shouldCommit() { return this.dirty && (this.now() - this.lastCommitAt) >= this.commitDebounceMs }
+  committed() { this.dirty = false; this.lastCommitAt = this.now() }
+  shouldSync() { return (this.now() - this.lastSyncAt) >= this.syncIntervalMs }
+  synced() { this.lastSyncAt = this.now() }
+}