dsh-remote 0.8.2 → 0.8.4

package/lib/paths.js

@@ -1,169 +1,169 @@
-// dsh-remote — pure path / shell helpers (no fs, no ssh).
-// Split out of lib/index.js so they are unit-testable without loading the
-// plugin. Both POSIX (`/a/b`) and Windows (`D:\Code`, `\\server\share`) forms
-// are supported everywhere.
-
-/** Single-quote one shell argument verbatim. */
-export function shq(s) {
-  return "'" + String(s).replace(/'/g, "'\\''") + "'"
-}
-
-/**
- * Normalize a remote path into a clean absolute path, supporting BOTH POSIX
- * (`/home/user`) and Windows (`D:\Code`, `C:/Users/x`, `\\server\share`) forms.
- *
- * - POSIX paths keep `/` separators and a leading `/`.
- * - Windows drive paths keep their `X:` prefix and are returned with `\`
- *   separators (the native form on a Windows remote); a leading `/` is NOT
- *   added, so `D:\Code` stays `D:\Code` instead of becoming `/D:\Code`.
- * - UNC paths (`\\server\share\…`) keep the `\\server\share` prefix.
- * - `.` / `..` segments are collapsed in both separator styles.
- */
-export function normalizeRemotePath(p) {
-  const s = String(p)
-  // Windows UNC: \\server\share\…
-  const unc = s.match(/^(\\\\[^\\]+(?:\\[^\\]+)?)(?:\\|$)(.*)$/s)
-  if (unc) {
-    const [prefix, rest] = [unc[1], unc[2]]
-    const parts = []
-    for (const seg of rest.split(/[\\/]+/)) {
-      if (seg === '' || seg === '.') continue
-      if (seg === '..') { parts.pop(); continue }
-      parts.push(seg)
-    }
-    return parts.length ? prefix + '\\' + parts.join('\\') : prefix
-  }
-  // Windows drive: X:\… or X:/…
-  const drive = s.match(/^([a-zA-Z]:)(?:[\\/]|$)(.*)$/s)
-  if (drive) {
-    const [prefix, rest] = [drive[1], drive[2]]
-    const parts = []
-    for (const seg of rest.split(/[\\/]+/)) {
-      if (seg === '' || seg === '.') continue
-      if (seg === '..') { parts.pop(); continue }
-      parts.push(seg)
-    }
-    return prefix + '\\' + parts.join('\\')
-  }
-  // POSIX: /a/b/c
-  const parts = []
-  for (const seg of s.split('/')) {
-    if (seg === '' || seg === '.') continue
-    if (seg === '..') {
-      parts.pop()
-      continue
-    }
-    parts.push(seg)
-  }
-  return '/' + parts.join('/')
-}
-
-/** Join a remote dir + entry name, honoring the dir's own separator style. */
-export function joinRemotePath(dir, name) {
-  const d = String(dir)
-  if (!d) return String(name)
-  if (d.endsWith('/') || d.endsWith('\\')) return d + String(name)
-  return d + (d.includes('\\') ? '\\' : '/') + String(name)
-}
-
-/** Parent dir of a remote absolute path (string-level; POSIX or Windows). */
-export function remoteDirname(p) {
-  const norm = normalizeRemotePath(p)
-  // Windows drive/UNC root: D:\ or \\server\share
-  if (norm === '/' || /^[a-zA-Z]:\\?$/.test(norm) || /^\\\\[^\\]+\\[^\\]+$/.test(norm)) {
-    // Ensure a drive root ends with a backslash: D: → D:\
-    const m = norm.match(/^([a-zA-Z]:)$/)
-    return m ? m[1] + '\\' : norm
-  }
-  const sep = norm.includes('\\') ? '\\' : '/'
-  const idx = norm.lastIndexOf(sep)
-  if (idx <= 0) {
-    // Windows drive with a child (D:\Code) → D:\
-    const m = norm.match(/^([a-zA-Z]:)\\/)
-    return m ? m[1] + '\\' : sep === '/' && norm.startsWith('/') ? '/' : norm
-  }
-  // A parent that is a Windows drive root also needs the trailing backslash.
-  const parent = norm.slice(0, idx)
-  if (sep === '\\' && /^[a-zA-Z]:$/.test(parent)) return parent + '\\'
-  return parent
-}
-
-/** Create every level of a remote dir via SFTP (true mkdir -p: parents AND the
- * target itself), working for both POSIX (`/a/b`) and Windows (`D:\a\b`)
- * paths. Best effort: an existing or permission-denied level is skipped.
- * FILE-oriented callers must pass the parent dir (remoteDirname(filePath)). */
-export async function mkdirRemoteDirs(sftp, dir) {
-  const target = normalizeRemotePath(dir)
-  const isWin = target.includes('\\')
-  // Split off a Windows drive prefix (D:) so it is not treated as a segment.
-  const drive = isWin ? (target.match(/^([a-zA-Z]:)[\\/]?(.*)$/s) || null) : null
-  const segs = drive ? drive[2].split(/[\\/]/).filter(Boolean) : target.split(/[\\/]/).filter(Boolean)
-  let cur = isWin ? (drive ? drive[1] + '\\' : '') : ''
-  // Drive root (D:\) itself, best effort (usually exists).
-  if (isWin && cur) { try { await sftp.mkdir(cur) } catch { /* exists */ } }
-  for (const s of segs) {
-    if (cur) {
-      if (!cur.endsWith('\\') && !cur.endsWith('/')) cur += isWin ? '\\' : '/'
-      cur += s
-    } else {
-      cur = (isWin ? s + ':' : '/' + s)
-    }
-    try { await sftp.mkdir(cur) } catch { /* exists or no perms */ }
-  }
-}
-
-/**
- * Convert an internal remote path (POSIX `/a/b` or Windows `D:\Code`) into the
- * path format the SFTP server understands.
- *
- * Windows OpenSSH's sftp-server accepts POSIX-style paths: a drive letter is
- * written `/D:/…` (equivalent to `D:\…`). POSIX paths pass through unchanged.
- * UNC paths are kept as-is (the server resolves `\\server\share` itself).
- */
-export function toSftpPath(p) {
-  const norm = normalizeRemotePath(p)
-  const m = norm.match(/^([a-zA-Z]):\\(.*)$/s)
-  if (m) return '/' + m[1] + ':/' + m[2].replace(/\\/g, '/')
-  return norm
-}
-
-/** Basename of a remote absolute path (POSIX or Windows). */
-export function remotePathBase(p) {
-  const norm = normalizeRemotePath(p).replace(/[\\/]+$/, '')
-  const base = norm.split(/[\\/]/).pop()
-  // Windows drive root (D:\) has no meaningful basename
-  if (!base || /^[a-zA-Z]:$/.test(base)) return 'workspace'
-  return base
-}
-
-/** Relative path of `p` under `root` (POSIX form, no leading slash), or null
- * when `p` is not inside `root`. Both POSIX and Windows drive paths work
- * (Windows is compared in its `/D:/…` POSIX-equivalent form). */
-export function relPathUnder(root, p) {
-  const posix = (x) => {
-    let n = normalizeRemotePath(x).replace(/[\\/]+$/, '')
-    const m = n.match(/^([a-zA-Z]):(.*)$/s)
-    if (m) return '/' + m[1].toLowerCase() + ':/' + (m[2] ? m[2].replace(/\\/g, '/').replace(/^\/+/, '') : '')
-    return n.replace(/\\/g, '/')
-  }
-  const r = posix(root)
-  const n = posix(p)
-  if (n === r) return ''
-  const prefix = r === '/' ? '/' : r + '/'
-  if (n.startsWith(prefix)) return n.slice(prefix.length)
-  return null
-}
-
-export function truncate(s, max) {
-  if (s.length <= max) return s
-  return s.slice(0, max) + `\n…[truncated: ${s.length - max} more chars]`
-}
-
-/** 32-bit string hash rendered in base36 (short, collision-safe enough). */
-export function shortHash(s) {
-  let h = 0
-  for (let i = 0; i < s.length; i++) {
-    h = ((h << 5) - h + s.charCodeAt(i)) | 0
-  }
-  return (h >>> 0).toString(36)
-}
+// dsh-remote — pure path / shell helpers (no fs, no ssh).
+// Split out of lib/index.js so they are unit-testable without loading the
+// plugin. Both POSIX (`/a/b`) and Windows (`D:\Code`, `\\server\share`) forms
+// are supported everywhere.
+
+/** Single-quote one shell argument verbatim. */
+export function shq(s) {
+  return "'" + String(s).replace(/'/g, "'\\''") + "'"
+}
+
+/**
+ * Normalize a remote path into a clean absolute path, supporting BOTH POSIX
+ * (`/home/user`) and Windows (`D:\Code`, `C:/Users/x`, `\\server\share`) forms.
+ *
+ * - POSIX paths keep `/` separators and a leading `/`.
+ * - Windows drive paths keep their `X:` prefix and are returned with `\`
+ *   separators (the native form on a Windows remote); a leading `/` is NOT
+ *   added, so `D:\Code` stays `D:\Code` instead of becoming `/D:\Code`.
+ * - UNC paths (`\\server\share\…`) keep the `\\server\share` prefix.
+ * - `.` / `..` segments are collapsed in both separator styles.
+ */
+export function normalizeRemotePath(p) {
+  const s = String(p)
+  // Windows UNC: \\server\share\…
+  const unc = s.match(/^(\\\\[^\\]+(?:\\[^\\]+)?)(?:\\|$)(.*)$/s)
+  if (unc) {
+    const [prefix, rest] = [unc[1], unc[2]]
+    const parts = []
+    for (const seg of rest.split(/[\\/]+/)) {
+      if (seg === '' || seg === '.') continue
+      if (seg === '..') { parts.pop(); continue }
+      parts.push(seg)
+    }
+    return parts.length ? prefix + '\\' + parts.join('\\') : prefix
+  }
+  // Windows drive: X:\… or X:/…
+  const drive = s.match(/^([a-zA-Z]:)(?:[\\/]|$)(.*)$/s)
+  if (drive) {
+    const [prefix, rest] = [drive[1], drive[2]]
+    const parts = []
+    for (const seg of rest.split(/[\\/]+/)) {
+      if (seg === '' || seg === '.') continue
+      if (seg === '..') { parts.pop(); continue }
+      parts.push(seg)
+    }
+    return prefix + '\\' + parts.join('\\')
+  }
+  // POSIX: /a/b/c
+  const parts = []
+  for (const seg of s.split('/')) {
+    if (seg === '' || seg === '.') continue
+    if (seg === '..') {
+      parts.pop()
+      continue
+    }
+    parts.push(seg)
+  }
+  return '/' + parts.join('/')
+}
+
+/** Join a remote dir + entry name, honoring the dir's own separator style. */
+export function joinRemotePath(dir, name) {
+  const d = String(dir)
+  if (!d) return String(name)
+  if (d.endsWith('/') || d.endsWith('\\')) return d + String(name)
+  return d + (d.includes('\\') ? '\\' : '/') + String(name)
+}
+
+/** Parent dir of a remote absolute path (string-level; POSIX or Windows). */
+export function remoteDirname(p) {
+  const norm = normalizeRemotePath(p)
+  // Windows drive/UNC root: D:\ or \\server\share
+  if (norm === '/' || /^[a-zA-Z]:\\?$/.test(norm) || /^\\\\[^\\]+\\[^\\]+$/.test(norm)) {
+    // Ensure a drive root ends with a backslash: D: → D:\
+    const m = norm.match(/^([a-zA-Z]:)$/)
+    return m ? m[1] + '\\' : norm
+  }
+  const sep = norm.includes('\\') ? '\\' : '/'
+  const idx = norm.lastIndexOf(sep)
+  if (idx <= 0) {
+    // Windows drive with a child (D:\Code) → D:\
+    const m = norm.match(/^([a-zA-Z]:)\\/)
+    return m ? m[1] + '\\' : sep === '/' && norm.startsWith('/') ? '/' : norm
+  }
+  // A parent that is a Windows drive root also needs the trailing backslash.
+  const parent = norm.slice(0, idx)
+  if (sep === '\\' && /^[a-zA-Z]:$/.test(parent)) return parent + '\\'
+  return parent
+}
+
+/** Create every level of a remote dir via SFTP (true mkdir -p: parents AND the
+ * target itself), working for both POSIX (`/a/b`) and Windows (`D:\a\b`)
+ * paths. Best effort: an existing or permission-denied level is skipped.
+ * FILE-oriented callers must pass the parent dir (remoteDirname(filePath)). */
+export async function mkdirRemoteDirs(sftp, dir) {
+  const target = normalizeRemotePath(dir)
+  const isWin = target.includes('\\')
+  // Split off a Windows drive prefix (D:) so it is not treated as a segment.
+  const drive = isWin ? (target.match(/^([a-zA-Z]:)[\\/]?(.*)$/s) || null) : null
+  const segs = drive ? drive[2].split(/[\\/]/).filter(Boolean) : target.split(/[\\/]/).filter(Boolean)
+  let cur = isWin ? (drive ? drive[1] + '\\' : '') : ''
+  // Drive root (D:\) itself, best effort (usually exists).
+  if (isWin && cur) { try { await sftp.mkdir(cur) } catch { /* exists */ } }
+  for (const s of segs) {
+    if (cur) {
+      if (!cur.endsWith('\\') && !cur.endsWith('/')) cur += isWin ? '\\' : '/'
+      cur += s
+    } else {
+      cur = (isWin ? s + ':' : '/' + s)
+    }
+    try { await sftp.mkdir(cur) } catch { /* exists or no perms */ }
+  }
+}
+
+/**
+ * Convert an internal remote path (POSIX `/a/b` or Windows `D:\Code`) into the
+ * path format the SFTP server understands.
+ *
+ * Windows OpenSSH's sftp-server accepts POSIX-style paths: a drive letter is
+ * written `/D:/…` (equivalent to `D:\…`). POSIX paths pass through unchanged.
+ * UNC paths are kept as-is (the server resolves `\\server\share` itself).
+ */
+export function toSftpPath(p) {
+  const norm = normalizeRemotePath(p)
+  const m = norm.match(/^([a-zA-Z]):\\(.*)$/s)
+  if (m) return '/' + m[1] + ':/' + m[2].replace(/\\/g, '/')
+  return norm
+}
+
+/** Basename of a remote absolute path (POSIX or Windows). */
+export function remotePathBase(p) {
+  const norm = normalizeRemotePath(p).replace(/[\\/]+$/, '')
+  const base = norm.split(/[\\/]/).pop()
+  // Windows drive root (D:\) has no meaningful basename
+  if (!base || /^[a-zA-Z]:$/.test(base)) return 'workspace'
+  return base
+}
+
+/** Relative path of `p` under `root` (POSIX form, no leading slash), or null
+ * when `p` is not inside `root`. Both POSIX and Windows drive paths work
+ * (Windows is compared in its `/D:/…` POSIX-equivalent form). */
+export function relPathUnder(root, p) {
+  const posix = (x) => {
+    let n = normalizeRemotePath(x).replace(/[\\/]+$/, '')
+    const m = n.match(/^([a-zA-Z]):(.*)$/s)
+    if (m) return '/' + m[1].toLowerCase() + ':/' + (m[2] ? m[2].replace(/\\/g, '/').replace(/^\/+/, '') : '')
+    return n.replace(/\\/g, '/')
+  }
+  const r = posix(root)
+  const n = posix(p)
+  if (n === r) return ''
+  const prefix = r === '/' ? '/' : r + '/'
+  if (n.startsWith(prefix)) return n.slice(prefix.length)
+  return null
+}
+
+export function truncate(s, max) {
+  if (s.length <= max) return s
+  return s.slice(0, max) + `\n…[truncated: ${s.length - max} more chars]`
+}
+
+/** 32-bit string hash rendered in base36 (short, collision-safe enough). */
+export function shortHash(s) {
+  let h = 0
+  for (let i = 0; i < s.length; i++) {
+    h = ((h << 5) - h + s.charCodeAt(i)) | 0
+  }
+  return (h >>> 0).toString(36)
+}

package/lib/search.js

@@ -1,127 +1,127 @@
-// dsh-remote — portable recursive search over SFTP.
-// Replaces `find … -exec grep` (which needs a POSIX shell and dies on
-// Windows remotes). Walks the remote tree over SFTP readdir/stat/readFile with
-// the same bounded-parallelism + ignore rules as the mirror sync.
-import { joinRemotePath } from './paths.js'
-
-function mapLimit(items, limit, fn) {
-  const limitN = Math.max(1, Math.min(Math.floor(limit) || 1, items.length))
-  let next = 0
-  const worker = async () => {
-    while (next < items.length) {
-      const i = next++
-      try { await fn(items[i], i) } catch { /* per-item errors are the fn's concern */ }
-    }
-  }
-  const workers = []
-  for (let w = 0; w < limitN; w++) workers.push(worker())
-  return Promise.all(workers)
-}
-
-/** fnmatch-lite for the `glob` filter (matches the entry BASENAME). */
-export function matchGlob(name, glob) {
-  let re = ''
-  let i = 0
-  const g = String(glob || '')
-  while (i < g.length) {
-    const c = g[i]
-    if (c === '*') {
-      if (g[i + 1] === '*') { re += '.*'; i += 2; continue }
-      re += '[^/]*'; i++; continue
-    }
-    if (c === '?') { re += '[^/]'; i++; continue }
-    if ('\\^$+{}[]()|.'.includes(c)) re += '\\' + c
-    else re += c
-    i++
-  }
-  return new RegExp('^' + re + '$').test(String(name))
-}
-
-const BINARY_SNIFF = 8192
-function looksBinary(buf) {
-  const n = Math.min(buf.length, BINARY_SNIFF)
-  for (let i = 0; i < n; i++) if (buf[i] === 0) return true
-  return false
-}
-
-/**
- * Recursively search a remote directory.
- * @returns {Promise<{matches: Array<{path, line, text}>, scanned: number, truncated: boolean}>}
- */
-export async function searchTree(sftp, rootDir, opts = {}) {
-  const {
-    regex,             // RegExp (already compiled with ignoreCase where asked)
-    glob,              // optional basename glob filter
-    contextLines = 0,
-    maxMatches = 500,
-    maxDepth = 12,
-    maxFiles = 20000,
-    maxScanBytes = 1024 * 1024,
-    isIgnored = () => false,
-  } = opts
-
-  const matches = []
-  let scanned = 0
-  let truncated = false
-
-  const walk = async (dir, depth) => {
-    if (truncated || scanned >= maxFiles) return
-    let entries = []
-    try { entries = (await sftp.readdir(dir)) || [] } catch { return }
-    const dirs = []
-    for (const e of entries) {
-      const name = String(e.filename)
-      if (name === '.' || name === '..') continue
-      const isDir = !!(e.attrs && e.attrs.isDirectory && e.attrs.isDirectory())
-      if (isDir) dirs.push(name)
-    }
-    // Depth-first, dirs first, but stop as soon as we hit caps.
-    for (const name of dirs) {
-      if (truncated || scanned >= maxFiles) return
-      if (depth <= 0) continue
-      const sub = joinRemotePath(dir, name)
-      if (isIgnored(name, true)) continue
-      await walk(sub, depth - 1)
-    }
-    if (truncated || scanned >= maxFiles) return
-
-    const fileNames = entries
-      .filter((e) => !(e.attrs && e.attrs.isDirectory && e.attrs.isDirectory()))
-      .map((e) => String(e.filename))
-      .filter((n) => n !== '.' && n !== '..')
-    await mapLimit(fileNames, 4, async (name) => {
-      if (truncated || scanned >= maxFiles || matches.length >= maxMatches) return
-      if (glob && !matchGlob(name, glob)) return
-      if (isIgnored(name, false)) return
-      const fp = joinRemotePath(dir, name)
-      scanned++
-      let st
-      try { st = await sftp.stat(fp) } catch { return }
-      if (st.size > maxScanBytes) return
-      let buf
-      try { buf = await sftp.readFile(fp) } catch { return }
-      if (looksBinary(buf)) return
-      const content = buf.toString('utf8').replace(/\r\n/g, '\n')
-      const lines = content.split('\n')
-      const hitLines = new Set()
-      for (let i = 0; i < lines.length; i++) {
-        if (regex.test(lines[i])) {
-          regex.lastIndex = 0
-          for (let c = Math.max(0, i - contextLines); c <= Math.min(lines.length - 1, i + contextLines); c++) {
-            hitLines.add(c)
-          }
-          if (matches.length >= maxMatches) { truncated = true; return }
-        }
-      }
-      if (hitLines.size) {
-        for (const ln of [...hitLines].sort((a, b) => a - b)) {
-          if (matches.length >= maxMatches) { truncated = true; return }
-          matches.push({ path: fp, line: ln + 1, text: lines[ln] })
-        }
-      }
-    })
-  }
-
-  await walk(rootDir, maxDepth)
-  return { matches, scanned, truncated }
-}
+// dsh-remote — portable recursive search over SFTP.
+// Replaces `find … -exec grep` (which needs a POSIX shell and dies on
+// Windows remotes). Walks the remote tree over SFTP readdir/stat/readFile with
+// the same bounded-parallelism + ignore rules as the mirror sync.
+import { joinRemotePath } from './paths.js'
+
+function mapLimit(items, limit, fn) {
+  const limitN = Math.max(1, Math.min(Math.floor(limit) || 1, items.length))
+  let next = 0
+  const worker = async () => {
+    while (next < items.length) {
+      const i = next++
+      try { await fn(items[i], i) } catch { /* per-item errors are the fn's concern */ }
+    }
+  }
+  const workers = []
+  for (let w = 0; w < limitN; w++) workers.push(worker())
+  return Promise.all(workers)
+}
+
+/** fnmatch-lite for the `glob` filter (matches the entry BASENAME). */
+export function matchGlob(name, glob) {
+  let re = ''
+  let i = 0
+  const g = String(glob || '')
+  while (i < g.length) {
+    const c = g[i]
+    if (c === '*') {
+      if (g[i + 1] === '*') { re += '.*'; i += 2; continue }
+      re += '[^/]*'; i++; continue
+    }
+    if (c === '?') { re += '[^/]'; i++; continue }
+    if ('\\^$+{}[]()|.'.includes(c)) re += '\\' + c
+    else re += c
+    i++
+  }
+  return new RegExp('^' + re + '$').test(String(name))
+}
+
+const BINARY_SNIFF = 8192
+function looksBinary(buf) {
+  const n = Math.min(buf.length, BINARY_SNIFF)
+  for (let i = 0; i < n; i++) if (buf[i] === 0) return true
+  return false
+}
+
+/**
+ * Recursively search a remote directory.
+ * @returns {Promise<{matches: Array<{path, line, text}>, scanned: number, truncated: boolean}>}
+ */
+export async function searchTree(sftp, rootDir, opts = {}) {
+  const {
+    regex,             // RegExp (already compiled with ignoreCase where asked)
+    glob,              // optional basename glob filter
+    contextLines = 0,
+    maxMatches = 500,
+    maxDepth = 12,
+    maxFiles = 20000,
+    maxScanBytes = 1024 * 1024,
+    isIgnored = () => false,
+  } = opts
+
+  const matches = []
+  let scanned = 0
+  let truncated = false
+
+  const walk = async (dir, depth) => {
+    if (truncated || scanned >= maxFiles) return
+    let entries = []
+    try { entries = (await sftp.readdir(dir)) || [] } catch { return }
+    const dirs = []
+    for (const e of entries) {
+      const name = String(e.filename)
+      if (name === '.' || name === '..') continue
+      const isDir = !!(e.attrs && e.attrs.isDirectory && e.attrs.isDirectory())
+      if (isDir) dirs.push(name)
+    }
+    // Depth-first, dirs first, but stop as soon as we hit caps.
+    for (const name of dirs) {
+      if (truncated || scanned >= maxFiles) return
+      if (depth <= 0) continue
+      const sub = joinRemotePath(dir, name)
+      if (isIgnored(name, true)) continue
+      await walk(sub, depth - 1)
+    }
+    if (truncated || scanned >= maxFiles) return
+
+    const fileNames = entries
+      .filter((e) => !(e.attrs && e.attrs.isDirectory && e.attrs.isDirectory()))
+      .map((e) => String(e.filename))
+      .filter((n) => n !== '.' && n !== '..')
+    await mapLimit(fileNames, 4, async (name) => {
+      if (truncated || scanned >= maxFiles || matches.length >= maxMatches) return
+      if (glob && !matchGlob(name, glob)) return
+      if (isIgnored(name, false)) return
+      const fp = joinRemotePath(dir, name)
+      scanned++
+      let st
+      try { st = await sftp.stat(fp) } catch { return }
+      if (st.size > maxScanBytes) return
+      let buf
+      try { buf = await sftp.readFile(fp) } catch { return }
+      if (looksBinary(buf)) return
+      const content = buf.toString('utf8').replace(/\r\n/g, '\n')
+      const lines = content.split('\n')
+      const hitLines = new Set()
+      for (let i = 0; i < lines.length; i++) {
+        if (regex.test(lines[i])) {
+          regex.lastIndex = 0
+          for (let c = Math.max(0, i - contextLines); c <= Math.min(lines.length - 1, i + contextLines); c++) {
+            hitLines.add(c)
+          }
+          if (matches.length >= maxMatches) { truncated = true; return }
+        }
+      }
+      if (hitLines.size) {
+        for (const ln of [...hitLines].sort((a, b) => a - b)) {
+          if (matches.length >= maxMatches) { truncated = true; return }
+          matches.push({ path: fp, line: ln + 1, text: lines[ln] })
+        }
+      }
+    })
+  }
+
+  await walk(rootDir, maxDepth)
+  return { matches, scanned, truncated }
+}