thincoder 0.12.61 → 0.12.63

package/src/memory/code-index.mjs

@@ -1,219 +0,0 @@
-/**
- * memory/code-index.mjs — code and document chunking, language detection, symbol extraction
- */
-
-import { segmentCJK, CODE_EXTS, DOC_EXTS, SKIP_DIRS, BIG_FILE_LINES } from "./schema.mjs"
-
-/** Infer file language by extension */
-export function detectLanguage(filename) {
-  const ext = filename.slice(filename.lastIndexOf(".")).toLowerCase()
-  const map = {
-    ".mjs": "javascript", ".js": "javascript", ".cjs": "javascript", ".jsx": "jsx",
-    ".ts": "typescript", ".tsx": "tsx", ".mts": "typescript", ".cts": "typescript",
-    ".py": "python", ".rs": "rust", ".go": "go", ".java": "java",
-    ".c": "c", ".h": "c", ".cpp": "cpp", ".hpp": "cpp",
-    ".rb": "ruby", ".swift": "swift", ".kt": "kotlin", ".dart": "dart", ".lua": "lua",
-    ".cs": "csharp", ".fs": "fsharp", ".fsx": "fsharp",
-    ".clj": "clojure", ".cljs": "clojure", ".ex": "elixir", ".exs": "elixir",
-    ".erl": "erlang", ".hrl": "erlang", ".scala": "scala", ".groovy": "groovy",
-    ".pl": "perl", ".pm": "perl", ".r": "r", ".jl": "julia", ".zig": "zig",
-    ".ps1": "powershell", ".proto": "protobuf", ".graphql": "graphql", ".tf": "terraform", ".hcl": "hcl",
-    ".sh": "bash", ".bash": "bash", ".sql": "sql",
-    ".yaml": "yaml", ".yml": "yaml", ".toml": "toml", ".json": "json",
-    ".css": "css", ".html": "html", ".vue": "vue", ".svelte": "svelte",
-    ".md": "markdown", ".mdc": "markdown", ".mdx": "markdown", ".org": "org", ".wiki": "wiki", ".tex": "tex",
-  }
-  return map[ext] ?? ext.slice(1)
-}
-
-/**
- * Extract top-level symbol declarations (functions, classes, const exports, etc.)
- * from JS/TS files using regex. Returns [{ name, line, kind }].
- */
-export function extractSymbols(lines, ext) {
-  const jsish = new Set([".mjs", ".js", ".ts", ".jsx", ".tsx"])
-  if (!jsish.has(ext)) return []
-
-  const symbols = []
-  const text = lines.join("\n")
-  const re = /(?:export\s+)?(?:(?:async\s+)?function\s+(\w+)|class\s+(\w+)|(?:export\s+)?(?:const|let|var)\s+(\w+))/gm
-  let m
-  while ((m = re.exec(text))) {
-    const name = m[1] || m[2] || m[3]
-    if (!name || name[0] !== name[0].toLowerCase() && name.length < 2) continue
-    const line = text.slice(0, m.index).split("\n").length
-    symbols.push({ name, line, kind: m[1] ? "function" : m[2] ? "class" : "variable" })
-  }
-  return symbols
-}
-
-/** Extract top-level def/class from Python files. */
-export function extractPySymbols(lines) {
-  const symbols = []
-  const re = /^(?:async\s+)?(?:def|class)\s+(\w+)/gm
-  const text = lines.join("\n")
-  let m
-  while ((m = re.exec(text))) {
-    symbols.push({ name: m[1], line: text.slice(0, m.index).split("\n").length, kind: text[m.index] === "c" ? "class" : "function" })
-  }
-  return symbols
-}
-
-/**
- * Split a file into code chunks. Small files become a single chunk;
- * large files are split by symbol, with inter-symbol content merged into the preceding symbol chunk.
- * Each chunk includes the JSDoc/docstring before its symbol to improve search quality.
- */
-export function chunkCode(lines, filepath) {
-  const ext = filepath.slice(filepath.lastIndexOf(".")).toLowerCase()
-  const chunks = []
-
-  if (lines.length <= BIG_FILE_LINES) {
-    const doc = extractLeadingDoc(lines, 1, ext)
-    const content = (doc ? doc + "\n" : "") + lines.join("\n").trimEnd()
-    chunks.push({ name: filepath, line_start: 1, line_end: lines.length, content })
-    return chunks
-  }
-
-  const symbols = ext === ".py" ? extractPySymbols(lines) : extractSymbols(lines, ext)
-  if (symbols.length <= 1) {
-    const doc = extractLeadingDoc(lines, 1, ext)
-    const content = (doc ? doc + "\n" : "") + lines.join("\n").trimEnd()
-    chunks.push({ name: filepath, line_start: 1, line_end: lines.length, content })
-    return chunks
-  }
-
-  for (let i = 0; i < symbols.length; i++) {
-    const sym = symbols[i]
-    const start = sym.line
-    const end = i + 1 < symbols.length ? symbols[i + 1].line - 1 : lines.length
-    if (start > end) continue
-    const doc = extractLeadingDoc(lines, start, ext)
-    const body = lines.slice(start - 1, end).join("\n").trimEnd()
-    const content = (doc ? doc + "\n" : "") + body
-    if (!content) continue
-    chunks.push({ name: `${filepath}:${sym.name}`, line_start: start, line_end: end, content })
-  }
-  return chunks
-}
-
-/**
- * Extract the JSDoc/docstring comment preceding a given line.
- * JS/TS: scan backwards for JSDoc block comments or consecutive // comment lines
- * Python: look for a """...""" docstring on the line after the symbol definition
- */
-export function extractLeadingDoc(lines, lineNum, ext) {
-  if (ext === ".py") {
-    if (lineNum >= lines.length) return ""
-    const next = lines[lineNum]
-    const m = next?.match(/^\s*"""(.+?)"""\s*$/)
-    if (m) return m[1].trim()
-    if (/^\s*"""\s*$/.test(next)) {
-      const parts = []
-      for (let i = lineNum + 1; i < lines.length && i < lineNum + 8; i++) {
-        if (/^\s*"""\s*$/.test(lines[i])) break
-        parts.push(lines[i].trim())
-      }
-      const text = parts.join(" ").trim()
-      return text.length > 0 && text.length < 300 ? text : ""
-    }
-    return ""
-  }
-
-  const jsish = new Set([".mjs", ".js", ".ts", ".jsx", ".tsx"])
-  if (!jsish.has(ext)) return ""
-
-  const parts = []
-  let i = lineNum - 2
-  if (i >= 0 && /^\s*\*\/\s*$/.test(lines[i])) {
-    while (i >= 0) {
-      const line = lines[i].trim()
-      if (/^\s*\/\*\*/.test(line)) {
-        parts.unshift(line.replace(/^\s*\/\*\*\s*/, "").replace(/\s*\*\/\s*$/, "").trim())
-        break
-      }
-      parts.unshift(line.replace(/^\s*\*\s?/, "").trim())
-      i--
-    }
-  } else {
-    while (i >= 0 && /^\s*\/\//.test(lines[i])) {
-      parts.unshift(lines[i].replace(/^\s*\/\/\s*/, "").trim())
-      i--
-    }
-  }
-
-  const text = parts.join(" ").trim()
-  return text.length > 0 && text.length < 300 ? text : ""
-}
-
-/** Yield control to the event loop for one tick (allows keyboard input to be processed). Uses setImmediate for lower latency than setTimeout(0). */
-export function yieldTick() {
-  return new Promise((r) => setImmediate(r))
-}
-
-/** Index a single file: delete old chunks → chunk → insert new chunks */
-export function _upsertCodeFile(memory, origin, rel, lines, lang, mtimeMs) {
-  const chunks = chunkCode(lines, rel)
-  memory.db.exec("BEGIN")
-  try {
-    memory.db.prepare(`DELETE FROM code_chunks WHERE origin = ? AND path = ?`).run(origin, rel)
-    const insert = memory.db.prepare(`
-      INSERT INTO code_chunks (origin, path, language, chunk_type, symbol_name, content, line_start, line_end, mtime_ms, seg_content)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `)
-    for (const c of chunks) {
-      const isFile = c.name === rel
-      insert.run(origin, rel, lang, isFile ? "file" : "symbol", isFile ? "" : c.name.slice(rel.length + 1), c.content, c.line_start, c.line_end, mtimeMs, segmentCJK(c.content))
-    }
-    memory.db.exec("COMMIT")
-  } catch (e) {
-    memory.db.exec("ROLLBACK")
-    throw e
-  }
-}
-
-/**
- * Split a markdown file by ## headings. Each ## section is indexed independently,
- * with the heading path as the heading label (e.g. "README.md > Deployment > Docker") for easy retrieval.
- */
-export function chunkMarkdown(lines, filepath) {
-  const chunks = []
-  let start = 1
-  let heading = filepath
-
-  for (let i = 0; i < lines.length; i++) {
-    const m = lines[i].match(/^(#{1,4})\s+(.+)/)
-    if (m) {
-      if (i > start) {
-        chunks.push({ heading, line_start: start, line_end: i, content: lines.slice(start - 1, i).join("\n").trimEnd() })
-      }
-      heading = `${filepath} > ${m[2].trim()}`
-      start = i + 1
-    }
-  }
-  if (start <= lines.length) {
-    chunks.push({ heading, line_start: start, line_end: lines.length, content: lines.slice(start - 1).join("\n").trimEnd() })
-  }
-  return chunks.filter((c) => c.content)
-}
-
-/** Upsert a documentation file's chunks into the doc_chunks table within a transaction */
-export function _upsertDocFile(memory, origin, rel, lines, mtimeMs) {
-  const chunks = chunkMarkdown(lines, rel)
-  const lang = rel.endsWith(".rst") ? "rst" : rel.endsWith(".adoc") ? "asciidoc" : rel.endsWith(".txt") ? "text" : "markdown"
-  memory.db.exec("BEGIN")
-  try {
-    memory.db.prepare(`DELETE FROM doc_chunks WHERE origin = ? AND path = ?`).run(origin, rel)
-    const insert = memory.db.prepare(`
-      INSERT INTO doc_chunks (origin, path, language, heading, content, line_start, line_end, mtime_ms, seg_content)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `)
-    for (const c of chunks) {
-      insert.run(origin, rel, lang, c.heading, c.content, c.line_start, c.line_end, mtimeMs, segmentCJK(c.content))
-    }
-    memory.db.exec("COMMIT")
-  } catch (e) {
-    memory.db.exec("ROLLBACK")
-    throw e
-  }
-}

package/src/memory/code-sync.mjs

@@ -1,413 +0,0 @@
-/**
- * memory/code-sync.mjs — code index sync, retrieval, incremental update
- */
-import { readFile, stat } from "node:fs/promises"
-import { join, relative } from "node:path"
-import { embed, cosine, toBlob, fromBlob } from "../embedding.mjs"
-import { CODE_EXTS, DOC_EXTS, MAX_CODE_FILE_BYTES, MAX_DOC_FILE_BYTES } from "./schema.mjs"
-import { buildFtsQuery, ensureEmbeddings, EMBED_TEXT_MAX_LEN } from "./core.mjs"
-import { detectLanguage, _upsertCodeFile, _upsertDocFile, yieldTick } from "./code-index.mjs"
-import { walkProjectFiles, isSkippedRelPath, extensionOf, createUnlistedTally, MAX_WALK_FILES } from "./file-walk.mjs"
-import { loadConventions } from "../conventions.mjs"
-import { logEvent } from "../log.mjs"
-
-const DIFF_FULL_SYNC_THRESHOLD = 200
-const CODE_EMBED_BATCH = 64
-
-/**
- * Index extension sets = built-in tables ∪ project declaration
- * (`.thincoder/conventions.json` → index.codeExtensions / index.docExtensions;
- * PORTABILITY PO-9/§3.7 — a project may declare extensions this product does not
- * ship a default for). Declaration only ADDS (union), never removes.
- */
-export function indexExtensions(dir) {
-  const conv = loadConventions(dir)
-  return {
-    code: new Set([...CODE_EXTS, ...conv.index.codeExtensions]),
-    doc: new Set([...DOC_EXTS, ...conv.index.docExtensions]),
-  }
-}
-
-/**
- * git-driven incremental indexing: use git diff to find files changed since
- * the last index, and only rebuild FTS5 chunks for those files (vectors are untouched).
- * An order of magnitude faster than full mtime scanning.
- * Returns { updated, removed, skipped } or null (git unavailable).
- */
-export async function gitSync(memory, dir, { onProgress } = {}) {
-  const { execFile: _execFile } = await import("node:child_process")
-  const { code: codeExts, doc: docExts } = indexExtensions(dir)
-  const gitRun = (args) => new Promise((resolve, reject) => {
-    _execFile("git", args, { cwd: dir, encoding: "utf8", timeout: 10000, windowsHide: true }, (err, stdout) => {
-      if (err) reject(err); else resolve(stdout)
-    })
-  })
-  const mergeDiff = (text) => text.trim().split("\n").filter(Boolean)
-
-  let head
-  try { head = (await gitRun(["rev-parse", "HEAD"])).trim() } catch { return null }
-
-  const stored = memory.db.prepare(`SELECT value FROM meta WHERE key = 'last_indexed_commit'`).get()?.value
-  if (!stored) return null
-
-  let diffOut
-  try {
-    const committed = mergeDiff(await gitRun(["diff", "--name-only", "--diff-filter=ACMRTD", stored, "HEAD"]))
-    const dirty = mergeDiff(await gitRun(["diff", "--name-only", "--diff-filter=ACMRTD"]))
-    const lines = [...new Set([...committed, ...dirty])]
-    diffOut = lines
-  } catch {
-    return null
-  }
-
-  if (diffOut.length > DIFF_FULL_SYNC_THRESHOLD) {
-    // diff too large, incremental is useless — fall back to full sync and update anchor
-    await codeSync(memory, dir, { onProgress })
-    const { docSync } = await import("./docs.mjs")
-    await docSync(memory, dir, { onProgress })
-    return { updated: -1, removed: 0, skipped: 0, failed: 0, errors: [], fallback: true }
-  }
-
-  let updated = 0, removed = 0, skipped = 0, failed = 0
-  const errors = []
-  for (let i = 0; i < diffOut.length; i++) {
-    const rel = diffOut[i].replaceAll("\\", "/")
-    const abs = join(dir, rel)
-    const ext = extensionOf(rel)
-
-    if (isSkippedRelPath(rel)) continue
-
-    if (!codeExts.has(ext) && !docExts.has(ext)) { skipped++; continue }
-
-    try {
-      const text = await readFile(abs, "utf8")
-      const lines = text.split("\n")
-      if (codeExts.has(ext)) {
-        const lang = detectLanguage(abs)
-        let mtimeMs = 0
-        try { mtimeMs = Math.floor((await stat(abs)).mtimeMs) } catch { /* new file */ }
-        _upsertCodeFile(memory, dir, rel, lines, lang, mtimeMs)
-      } else {
-        let mtimeMs = 0
-        try { mtimeMs = Math.floor((await stat(abs)).mtimeMs) } catch { /* new file */ }
-        _upsertDocFile(memory, dir, rel, lines, mtimeMs)
-      }
-      updated++
-    } catch (e) {
-      const isDeleted = e.code === "ENOENT"
-      if (isDeleted) {
-        if (codeExts.has(ext)) memory.db.prepare(`DELETE FROM code_chunks WHERE origin = ? AND path = ?`).run(dir, rel)
-        else memory.db.prepare(`DELETE FROM doc_chunks WHERE origin = ? AND path = ?`).run(dir, rel)
-        removed++
-      } else {
-        failed++
-        if (errors.length < 5) errors.push(`${rel}: ${e.message}`)
-      }
-    }
-    await yieldTick()
-    if (onProgress && i % 5 === 0) {
-      onProgress({ phase: "index", current: i + 1, total: diffOut.length, updated, removed, skipped })
-    }
-  }
-
-  if (failed === 0) {
-    memory.db.prepare(`INSERT INTO meta (key, value) VALUES ('last_indexed_commit', ?)
-      ON CONFLICT (key) DO UPDATE SET value = excluded.value`).run(head)
-  }
-
-  onProgress?.({ phase: "done", total: diffOut.length, updated, removed, skipped, failed })
-  return { updated, removed, skipped, failed, errors }
-}
-
-/**
- * List project files matching the given extensions.
- * Preferred source = git (`git ls-files --cached --others --exclude-standard`:
- * tracked + untracked-not-ignored, .gitignore respected). Projects WITHOUT git
- * fall back to a filesystem walk (PORTABILITY FR15/P8) — before, the index was
- * silently empty there. The walk cannot honour .gitignore (no git → no such
- * concept) and skips the shared SKIP_DIRS/dot-directory set instead.
- * Returns { entries, unlisted }: `entries` = { abs, rel } pairs (rel relative to
- * dir); `unlisted` = files whose extension is in NO index list (count + sample),
- * the visible signal behind "my .xyz files are not searchable" (PORTABILITY PO-9).
- * `truncated` = the non-git walk hit its file cap (capped trees are logged, never
- * silently indexed-partial). opts.maxFiles = the walk cap (test seam).
- */
-export async function listProjectFiles(dir, exts, { maxFiles } = {}) {
-  const { execFile: _execFile } = await import("node:child_process")
-  const { join: joinPath } = await import("node:path")
-  const { code, doc } = indexExtensions(dir)
-  const tally = createUnlistedTally(new Set([...code, ...doc]))
-
-  const files = []
-  const finish = (truncated = false) => ({ entries: files, unlisted: tally.result(), truncated })
-
-  // Git listing when available; a non-git project falls through to the walk.
-  let gitTop
-  try {
-    gitTop = (await new Promise((resolve, reject) => {
-      _execFile("git", ["rev-parse", "--show-toplevel"], { cwd: dir, encoding: "utf8", timeout: 5000, windowsHide: true },
-        (err, stdout) => { if (err) reject(err); else resolve(stdout.trim()) })
-    })).replace(/\\/g, "/")
-  } catch {
-    // Not a git repo → filesystem walk (FR15: the index must still be usable).
-    const walked = await walkProjectFiles(dir, exts, { knownExts: new Set([...code, ...doc]), ...(maxFiles !== undefined ? { maxFiles } : {}) })
-    files.push(...walked.files)
-    // The walk's cap must stay visible end-to-end (file-walk.mjs: "never silently
-    // dropped") — a capped listing says so in the log, not only in a discarded flag.
-    if (walked.truncated) {
-      logEvent("index:truncated", { dir, files: walked.files.length, maxFiles: maxFiles ?? MAX_WALK_FILES })
-    }
-    return { entries: files, unlisted: walked.unlisted, truncated: walked.truncated }
-  }
-
-  try {
-    const raw = await new Promise((resolve, reject) => {
-      _execFile("git", ["ls-files", "--cached", "--others", "--exclude-standard"],
-        { cwd: dir, encoding: "utf8", timeout: 15000, windowsHide: true, maxBuffer: 10 * 1024 * 1024 },
-        (err, stdout) => { if (err) reject(err); else resolve(stdout) })
-    })
-    for (const line of raw.trim().split("\n")) {
-      const p = line.trim()
-      if (!p) continue
-      const rel = p.replace(/\\/g, "/")
-      if (isSkippedRelPath(rel)) continue
-      const ext = extensionOf(rel)
-      if (!ext || !exts.has(ext)) { tally.note(rel); continue }
-      files.push({ abs: joinPath(dir, rel), rel })
-    }
-  } catch { /* ls-files failed */ }
-
-  return finish()
-}
-
-
-/**
- * Sync code index: scan all source files under dir → chunk → upsert into code_chunks.
- * Incremental by mtime — only rebuilds chunks for files that have changed.
- */
-export async function codeSync(memory, dir, { onProgress } = {}) {
-  const { code: exts } = indexExtensions(dir)
-  const { entries, unlisted } = await listProjectFiles(dir, exts)
-  const files = [] // { abs, rel, mtimeMs }
-  let overSizeSkipped = 0
-  for (const { abs, rel } of entries) {
-    let st
-    try { st = await stat(abs) } catch { continue }
-    if (st.size > MAX_CODE_FILE_BYTES) { overSizeSkipped++; continue }
-    files.push({ abs, rel, mtimeMs: Math.floor(st.mtimeMs) })
-  }
-
-  const indexed = new Map(
-    memory.db.prepare(`SELECT path, mtime_ms FROM code_chunks WHERE origin = ?`).all(dir).map((r) => [r.path, r.mtime_ms])
-  )
-  const seen = new Set()
-
-  onProgress?.({ phase: "scan", total: files.length, overSizeSkipped })
-
-  let updated = 0, removed = 0, skipped = 0, failed = 0
-  const errors = []
-  for (let i = 0; i < files.length; i++) {
-    const { abs, rel, mtimeMs } = files[i]
-    seen.add(rel)
-
-    if (indexed.get(rel) === mtimeMs) {
-      skipped++
-      continue
-    }
-
-    try {
-      const text = await readFile(abs, "utf8")
-      const lines = text.split("\n")
-      const lang = detectLanguage(abs)
-      _upsertCodeFile(memory, dir, rel, lines, lang, mtimeMs)
-      updated++
-    } catch (e) {
-      failed++
-      if (errors.length < 5) errors.push(`${rel}: ${e.message}`)
-    }
-    await yieldTick()
-
-    if (onProgress && i % 10 === 0) {
-      onProgress({ phase: "index", current: i + 1, total: files.length, updated, removed, skipped, failed })
-    }
-  }
-
-  for (const stale of indexed.keys()) {
-    if (!seen.has(stale)) {
-      memory.db.prepare(`DELETE FROM code_chunks WHERE origin = ? AND path = ?`).run(dir, stale)
-      removed++
-    }
-  }
-
-  onProgress?.({ phase: "done", total: files.length, updated, removed, skipped, failed, overSizeSkipped })
-  markIndexedCommit(memory, dir)
-  if (unlisted.count > 0) {
-    logEvent("index:unlisted", { dir, kind: "code", count: unlisted.count, exts: unlisted.exts.map((e) => e.ext) })
-  }
-  return { updated, removed, skipped, failed, errors, total: files.length, overSizeSkipped, unlistedExts: unlisted }
-}
-
-/** Record current HEAD as the index anchor (gitSync incremental diff baseline); silently skip non-git repos */
-export async function markIndexedCommit(memory, dir) {
-  try {
-    const { execFile } = await import("node:child_process")
-    const head = await new Promise((resolve, reject) => {
-      execFile("git", ["rev-parse", "HEAD"], { cwd: dir, encoding: "utf8", timeout: 5000, windowsHide: true }, (err, stdout) => {
-        if (err) reject(err); else resolve(stdout)
-      })
-    })
-    memory.db.prepare(`INSERT INTO meta (key, value) VALUES ('last_indexed_commit', ?)
-      ON CONFLICT (key) DO UPDATE SET value = excluded.value`).run(head.trim())
-  } catch { /* not a git repo or git unavailable, skip */ }
-}
-
-/**
- * Code search: FTS5(BM25) + optional vector cosine, RRF merged.
- * Falls back to pure FTS when no embedder; falls back to pure vector when ftsQuery is empty and embedder is present.
- */
-export async function codeSearch(memory, query, { limit = 5 } = {}) {
-  const ftsQuery = buildFtsQuery(query)
-  if (!ftsQuery && !memory.embedder) return []
-
-  const ftsOriginFilter = memory.codeOrigin ? `AND c.origin = ?` : ""
-  const vecOriginFilter = memory.codeOrigin ? `AND origin = ?` : ""
-  const originParams = memory.codeOrigin ? [memory.codeOrigin] : []
-
-  const ftsList = ftsQuery ? memory.db.prepare(`
-    SELECT c.rowid, c.path, c.language, c.symbol_name, c.content, c.line_start, c.line_end, bm25(code_chunks_fts) AS rank
-    FROM code_chunks_fts JOIN code_chunks c ON c.rowid = code_chunks_fts.rowid
-    WHERE code_chunks_fts MATCH ? ${ftsOriginFilter}
-    ORDER BY rank LIMIT ?
-  `).all(ftsQuery, ...originParams, Math.max(limit * 4, 20)) : []
-
-  if (!memory.embedder) return ftsList.slice(0, limit)
-
-  try { await ensureEmbeddings(memory) } catch (e) {
-    console.error(`[code] embedding ensure failed, falling back to FTS-only: ${e.message}`)
-    return ftsList.slice(0, limit)
-  }
-  let qvec
-  try { [qvec] = await embed(memory.embedder, [query]) } catch (e) {
-    console.error(`[code] query embedding failed, falling back to FTS-only: ${e.message}`)
-    return ftsList.slice(0, limit)
-  }
-  const rows = memory.db.prepare(`SELECT rowid, embedding FROM code_chunks WHERE embedding IS NOT NULL ${vecOriginFilter}`).all(...originParams)
-  const vecList = rows
-    .map((r) => ({ rowid: r.rowid, score: cosine(qvec, fromBlob(r.embedding)) }))
-    .sort((a, b) => b.score - a.score)
-    .slice(0, Math.max(limit * 4, 20))
-
-  const K = 60
-  const scores = new Map()
-  ftsList.forEach((r, i) => scores.set(r.rowid, (scores.get(r.rowid) ?? 0) + 1 / (K + i + 1)))
-  vecList.forEach((r, i) => scores.set(r.rowid, (scores.get(r.rowid) ?? 0) + 1 / (K + i + 1)))
-
-  const fetchChunk = memory.db.prepare(`
-    SELECT path, language, symbol_name, content, line_start, line_end FROM code_chunks WHERE rowid = ?
-  `)
-  const sorted = [...scores.entries()]
-    .sort((a, b) => b[1] - a[1])
-    .slice(0, limit)
-  return sorted
-    .map(([rowid, score]) => {
-      const chunk = fetchChunk.get(rowid)
-      if (!chunk) return null
-      chunk._score = Math.round(score * 100) / 100
-      return chunk
-    })
-    .filter(Boolean)
-}
-
-/** Lazily backfill missing vectors for code_chunks. Guarded against concurrent calls. */
-let _codeEmbedLock = null
-export function ensureCodeEmbeddings(memory) {
-  if (_codeEmbedLock) return _codeEmbedLock
-  _codeEmbedLock = _runEnsureCodeEmbeddings(memory).finally(() => { _codeEmbedLock = null })
-  return _codeEmbedLock
-}
-
-async function _runEnsureCodeEmbeddings(memory) {
-  if (!memory.embedder) return
-  const modelKey = memory.embedder.model
-  const stored = memory.db.prepare(`SELECT value FROM meta WHERE key = 'code_embedding_model'`).get()?.value
-  if (stored !== modelKey) {
-    memory.db.prepare(`UPDATE code_chunks SET embedding = NULL`).run()
-    memory.db.prepare(`INSERT INTO meta (key, value) VALUES ('code_embedding_model', ?)
-      ON CONFLICT (key) DO UPDATE SET value = excluded.value`).run(modelKey)
-  }
-
-  const pending = memory.db.prepare(`SELECT rowid, path, symbol_name, content FROM code_chunks WHERE embedding IS NULL LIMIT ${CODE_EMBED_BATCH}`).all()
-  if (pending.length === 0) return
-
-  const texts = pending.map((r) => `${r.path}${r.symbol_name ? " :: " + r.symbol_name : ""}\n${r.content.slice(0, EMBED_TEXT_MAX_LEN)}`)
-  const vecs = await embed(memory.embedder, texts)
-
-  const update = memory.db.prepare(`UPDATE code_chunks SET embedding = ? WHERE rowid = ?`)
-  pending.forEach((r, i) => update.run(toBlob(vecs[i]), r.rowid))
-}
-
-/** Generate the code_search tool (read-only). */
-export function codeSearchTool(memory) {
-  return {
-    name: "code_search",
-    description:
-      "Search the project's source code for relevant code. Use this to find functions, classes, or code patterns across the codebase. Supports natural language queries and code snippets. Returns matching code chunks with file paths and line numbers. Prefer doc_search for the intended design (design docs, conventions); code_search for the implementation as written. " +
-      "For what was said in a session (conversation/chat history), use read_history.",
-    parameters: {
-      type: "object",
-      properties: {
-        query: { type: "string", description: "Natural language or code snippet to search for" },
-        limit: { type: "number", description: "Max results (default 5)" },
-      },
-      required: ["query"],
-    },
-    readonly: true,
-    async execute(args) {
-      const results = await codeSearch(memory, args.query, { limit: args.limit ?? 5 })
-      if (results.length === 0) return "(no matching code)"
-      return results.map((r) =>
-        `${r.path}${r.symbol_name ? ` :: ${r.symbol_name}` : ""} (L${r.line_start}-L${r.line_end}, relevance ${r._score?.toFixed(2) ?? "?"}):\n${r.content.slice(0, 2000)}`
-      ).join("\n\n---\n\n")
-    },
-  }
-}
-
-/**
- * Single-file incremental reindex: called after write/edit/delete, only rebuilds this one path.
- */
-export async function reindexFile(memory, cwd, absPath) {
-  const ext = extensionOf(absPath)
-  const rel = relative(cwd, absPath).replaceAll("\\", "/")
-  if (rel === ".." || rel.startsWith("../")) return
-  if (isSkippedRelPath(rel)) return
-  // Declared extensions count for the single-file path too (union with built-ins).
-  const { code: codeExts, doc: docExts } = indexExtensions(cwd)
-
-  // skip oversized files (minified bundles, test fixtures, generated code)
-  const maxBytes = codeExts.has(ext) ? MAX_CODE_FILE_BYTES : docExts.has(ext) ? MAX_DOC_FILE_BYTES : 0
-  if (maxBytes > 0) {
-    try { const st = await stat(absPath); if (st.size > maxBytes) return } catch { /* can't stat, proceed */ }
-  }
-
-  let text
-  try { text = await readFile(absPath, "utf8") } catch {
-    if (codeExts.has(ext)) memory.db.prepare(`DELETE FROM code_chunks WHERE origin = ? AND path = ?`).run(cwd, rel)
-    else if (docExts.has(ext)) memory.db.prepare(`DELETE FROM doc_chunks WHERE origin = ? AND path = ?`).run(cwd, rel)
-    return
-  }
-  const lines = text.split("\n")
-
-  if (codeExts.has(ext)) {
-    const lang = detectLanguage(absPath)
-    let mtimeMs = 0
-    try { mtimeMs = Math.floor((await stat(absPath)).mtimeMs) } catch { /* new file */ }
-    _upsertCodeFile(memory, cwd, rel, lines, lang, mtimeMs)
-  } else if (docExts.has(ext)) {
-    let mtimeMs = 0
-    try { mtimeMs = Math.floor((await stat(absPath)).mtimeMs) } catch { /* new file */ }
-    _upsertDocFile(memory, cwd, rel, lines, mtimeMs)
-  }
-  if (memory.embedder) {
-    try { await ensureEmbeddings(memory) } catch { /* embedding failure is non-blocking */ }
-  }
-}