mixdog 0.7.1

package/src/agent/orchestrator/tools/builtin/rename-tool.mjs

@@ -0,0 +1,196 @@
+// Server-less, preview-first symbol rename.
+//
+// Mixdog has no semantic LSP. This tool reuses the existing code-graph
+// find_references API to collect every reference site for a symbol, then —
+// BY DEFAULT — returns a PREVIEW only: the {file,line,col,context} sites that
+// WOULD change, plus an explicit warning that the match is graph-based
+// (approximate, not LSP-semantic) and may include same-named-but-different
+// symbols. The destructive rewrite runs ONLY when apply===true, and replaces
+// the symbol EXACTLY at the {line,col} spans find_references returned —
+// verifying the slice equals the symbol before splicing. It never blanket-
+// replaces a line, so same-line string/comment occurrences the reference
+// search did NOT sanction are left untouched, `$`-identifiers can't mis-match
+// inside larger identifiers, and original (possibly mixed) line endings are
+// preserved verbatim.
+import { readFileSync, writeFileSync, statSync } from 'fs';
+import { isAbsolute, resolve as pathResolve } from 'path';
+import { executeCodeGraphTool, markCodeGraphDirtyPaths } from '../code-graph.mjs';
+import { invalidateBuiltinResultCache } from './cache-layers.mjs';
+
+const APPROX_WARNING =
+    'APPROXIMATE: matches come from the code-graph (text/word-boundary based), '
+    + 'NOT an LSP-semantic resolver. They may include same-named-but-different '
+    + 'symbols (shadowed locals, unrelated properties, etc.). Review every site '
+    + 'before applying.';
+
+// A valid JS/TS/Py-style identifier — required so we never attempt a rewrite
+// of an arbitrary string that would corrupt source via word-boundary regex.
+function _isIdentifier(s) {
+    return typeof s === 'string' && /^[A-Za-z_$][\w$]*$/.test(s);
+}
+
+// Parse find_references text output. Each hit line is `rel:line:col    context`.
+// Diagnostic/footer lines (starting with `(` or `[`) and blanks are skipped.
+function _parseReferenceLines(text) {
+    const sites = [];
+    if (typeof text !== 'string') return sites;
+    const re = /^(.+?):(\d+):(\d+)\s{2,}(.*)$/;
+    for (const raw of text.split(/\r?\n/)) {
+        const line = raw.replace(/\s+$/, '');
+        if (!line) continue;
+        if (line.startsWith('(') || line.startsWith('[') || line.startsWith('#')) continue;
+        const m = re.exec(line);
+        if (!m) continue;
+        sites.push({ file: m[1], line: +m[2], col: +m[3], context: m[4] });
+    }
+    return sites;
+}
+
+function _absFor(file, workDir) {
+    return isAbsolute(file) ? file : pathResolve(workDir, file);
+}
+
+// Split content into physical lines while preserving each line's own trailing
+// terminator (\r\n, \n, or '' for the last line). This lets us rewrite a single
+// line's text and re-join with the EXACT original endings — no normalization of
+// mixed line endings.
+function _splitKeepEol(content) {
+    const out = [];
+    const re = /\r\n|\n|\r/g;
+    let last = 0;
+    let m = null;
+    while ((m = re.exec(content))) {
+        out.push({ text: content.slice(last, m.index), eol: m[0] });
+        last = m.index + m[0].length;
+    }
+    out.push({ text: content.slice(last), eol: '' });
+    return out;
+}
+
+// Apply the rename ONLY at the exact {line,col} spans find_references returned.
+// For each site we verify the slice [col-1 .. col-1+symbol.length] === symbol
+// before splicing; if it doesn't match (stale graph, shifted line, or an
+// occurrence the search didn't sanction) the site is recorded as skipped and
+// nothing on that line is touched. Identity-check + slice splice replaces the
+// previous `\b`-regex line rewrite, which mishandled `$`-identifiers and
+// clobbered same-line non-reference occurrences.
+function _applyRename(sites, symbol, newName, workDir) {
+    const byFile = new Map();
+    for (const s of sites) {
+        const abs = _absFor(s.file, workDir);
+        if (!byFile.has(abs)) byFile.set(abs, []);
+        byFile.get(abs).push(s);
+    }
+    const changed = [];
+    const skipped = [];
+    let replacements = 0;
+    for (const [abs, fileSites] of byFile) {
+        let content;
+        try { content = readFileSync(abs, 'utf8'); }
+        catch (err) {
+            for (const s of fileSites) skipped.push({ ...s, reason: `read failed: ${err && err.message ? err.message : String(err)}` });
+            continue;
+        }
+        const lines = _splitKeepEol(content);
+        // Replace from rightmost column first within a line so earlier splices
+        // don't shift the offsets of later ones on the same line.
+        const ordered = fileSites.slice().sort((a, b) => (a.line - b.line) || (b.col - a.col));
+        let fileTouched = false;
+        for (const s of ordered) {
+            const idx = s.line - 1;
+            if (idx < 0 || idx >= lines.length) { skipped.push({ ...s, reason: 'line out of range' }); continue; }
+            const start = s.col - 1;
+            const text = lines[idx].text;
+            if (start < 0 || start + symbol.length > text.length) { skipped.push({ ...s, reason: 'column out of range' }); continue; }
+            const slice = text.slice(start, start + symbol.length);
+            if (slice !== symbol) { skipped.push({ ...s, reason: `slice mismatch (got ${JSON.stringify(slice)})` }); continue; }
+            lines[idx].text = text.slice(0, start) + newName + text.slice(start + symbol.length);
+            replacements += 1;
+            fileTouched = true;
+        }
+        if (fileTouched) {
+            writeFileSync(abs, lines.map((l) => l.text + l.eol).join(''), 'utf8');
+            changed.push(abs);
+        }
+    }
+    return { changed, replacements, skipped };
+}
+
+export async function executeRenameTool(args, workDir, signal = null) {
+    try {
+        const symbol = (args && typeof args.symbol === 'string') ? args.symbol.trim() : '';
+        const newName = (args && typeof args.new_name === 'string') ? args.new_name.trim() : '';
+        const file = (args && typeof args.file === 'string' && args.file.trim()) ? args.file.trim() : '';
+        const apply = args && args.apply === true;
+        if (!symbol) return 'Error: rename requires "symbol"';
+        if (!newName) return 'Error: rename requires "new_name"';
+        if (!_isIdentifier(symbol)) return `Error: rename "symbol" must be a valid identifier (got ${JSON.stringify(args.symbol)})`;
+        if (!_isIdentifier(newName)) return `Error: rename "new_name" must be a valid identifier (got ${JSON.stringify(args.new_name)})`;
+        if (symbol === newName) return 'Error: rename "new_name" is identical to "symbol"; nothing to do';
+
+        // Collect reference sites via the code-graph references mode.
+        const refArgs = { mode: 'references', symbol };
+        if (file) refArgs.file = file;
+        const refText = await executeCodeGraphTool('code_graph', refArgs, workDir, signal);
+        if (typeof refText === 'string' && refText.startsWith('Error:')) {
+            return refText;
+        }
+        const sites = _parseReferenceLines(refText);
+
+        if (sites.length === 0) {
+            return JSON.stringify({
+                ok: true,
+                mode: apply ? 'apply' : 'preview',
+                symbol,
+                new_name: newName,
+                warning: APPROX_WARNING,
+                count: 0,
+                sites: [],
+                note: 'no reference sites found — nothing to rename',
+            }, null, 2);
+        }
+
+        // DEFAULT: preview only. Never mutate on the default call. The CORE of
+        // the payload is the approximate-match warning plus the change-list of
+        // {file,line,col,context} sites that WOULD change; ok/mode/count/hint are
+        // secondary metadata.
+        if (!apply) {
+            return JSON.stringify({
+                warning: APPROX_WARNING,
+                changes: sites,
+                ok: true,
+                mode: 'preview',
+                symbol,
+                new_name: newName,
+                count: sites.length,
+                hint: 'Re-run with apply:true to perform the rename at these sites.',
+            }, null, 2);
+        }
+
+        // apply===true: perform the gated rewrite at the exact sanctioned spans.
+        const { changed, replacements, skipped } = _applyRename(sites, symbol, newName, workDir);
+        if (changed.length) {
+            try { invalidateBuiltinResultCache(changed); } catch {}
+            try { markCodeGraphDirtyPaths(changed); } catch {}
+        }
+        const result = {
+            ok: true,
+            mode: 'apply',
+            symbol,
+            new_name: newName,
+            warning: APPROX_WARNING,
+            sites_considered: sites.length,
+            replacements,
+            files_changed: changed.map((p) => (p.startsWith(workDir) ? p.slice(workDir.length).replace(/^[\\/]/, '') : p)),
+        };
+        if (skipped.length) {
+            result.skipped = skipped;
+            result.skipped_warning = `${skipped.length} site(s) were NOT renamed (offset out of range or the slice did not match the symbol). They were left untouched; review them manually.`;
+        }
+        return JSON.stringify(result, null, 2);
+    } catch (err) {
+        return JSON.stringify({ ok: false, error: `rename failed: ${err && err.message ? err.message : String(err)}` }, null, 2);
+    }
+}
+
+export default executeRenameTool;

package/src/agent/orchestrator/tools/builtin/rg-runner.mjs

@@ -0,0 +1,422 @@
+import { spawn, execFileSync } from 'child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+let _rgExecutableResolved = null;
+
+function _resolveRgExecutable() {
+    const isWin = process.platform === 'win32';
+    try {
+        const cmd = isWin ? 'where' : 'which';
+        const out = execFileSync(cmd, ['rg'], { encoding: 'utf8', windowsHide: true }).trim();
+        const first = out.split(/\r?\n/).map((l) => l.trim()).find(Boolean);
+        if (first && existsSync(first)) return first;
+    } catch { /* fall through to PATH scan */ }
+    const pathSep = isWin ? ';' : ':';
+    const dirs = String(process.env.PATH || '').split(pathSep).filter(Boolean);
+    const pathext = isWin
+        ? String(process.env.PATHEXT || '.EXE;.CMD;.BAT').split(';').map((e) => e.toLowerCase())
+        : [''];
+    const names = isWin ? ['rg.exe', 'rg'] : ['rg'];
+    for (const dir of dirs) {
+        for (const name of names) {
+            const candidate = join(dir, name);
+            if (!existsSync(candidate)) continue;
+            if (isWin) {
+                const ext = candidate.slice(candidate.lastIndexOf('.')).toLowerCase();
+                if (ext && !pathext.includes(ext)) continue;
+            }
+            return candidate;
+        }
+    }
+    return 'rg';
+}
+
+function rgExecutable() {
+    if (_rgExecutableResolved === null) {
+        _rgExecutableResolved = _resolveRgExecutable();
+    }
+    return _rgExecutableResolved;
+}
+
+// When _resolveRgExecutable() exhausts `where`/`which` and the PATH scan and
+// falls back to the bare 'rg', a later spawn would die with a raw ENOENT. Probe
+// the fallback so we can surface a clear, actionable error instead. Success is
+// cached permanently; failure is cached for only RG_FALLBACK_FAIL_TTL_MS so
+// installing rg mid-session recovers without restarting the daemon.
+const RG_FALLBACK_FAIL_TTL_MS = 30000;
+let _rgFallbackUsable = null;
+let _rgFallbackFailAt = 0;
+function rgFallbackUsable() {
+    if (_rgFallbackUsable === true) return true;
+    if (_rgFallbackUsable === false && (Date.now() - _rgFallbackFailAt) < RG_FALLBACK_FAIL_TTL_MS) {
+        return false;
+    }
+    try {
+        execFileSync('rg', ['--version'], { stdio: 'ignore', windowsHide: true, timeout: 3000 });
+        _rgFallbackUsable = true;
+    } catch {
+        _rgFallbackUsable = false;
+        _rgFallbackFailAt = Date.now();
+    }
+    return _rgFallbackUsable;
+}
+
+// Throws a clear error only when the bare 'rg' fallback was reached AND it is
+// not actually runnable. A real resolved path short-circuits with no probe, so
+// behavior is unchanged whenever rg exists.
+function assertRgAvailable() {
+    if (rgExecutable() !== 'rg') return;
+    if (rgFallbackUsable()) return;
+    const e = new Error('ripgrep (rg) not found on PATH — install ripgrep or add it to PATH');
+    e.code = 'ERG_NOT_FOUND';
+    throw e;
+}
+
+// Cap rg stdout accumulation so a runaway producer (huge repo, accidental
+// match-all) cannot balloon the JS string heap. Mirrors CC's ripgrep.ts cap.
+const MAX_RG_STDOUT_BYTES = 20 * 1024 * 1024; // 20MB
+
+// SIGTERM → grace → force kill; hard Promise settle if 'close' never fires
+// (mirrors shell-command.mjs treeKill + _treeKillForceSettle timings).
+const RG_KILL_GRACE_MS = 3000;
+const RG_FORCE_SETTLE_SLACK_MS = 5000;
+
+function _rgProcGone(proc) {
+    return !proc || proc.exitCode != null || proc.signalCode != null;
+}
+
+function _escalateRgKill(proc) {
+    if (_rgProcGone(proc)) return;
+    const pid = proc.pid;
+    if (!pid) return;
+    try {
+        if (process.platform === 'win32') {
+            spawn('taskkill', ['/pid', String(pid), '/t', '/f'], {
+                windowsHide: true,
+                stdio: 'ignore',
+            });
+        } else {
+            try {
+                proc.kill('SIGKILL');
+            } catch { /* ignore */ }
+        }
+    } catch { /* ignore */ }
+}
+
+function _killRgProc(proc, timers) {
+    if (_rgProcGone(proc)) return;
+    try {
+        proc.kill('SIGTERM');
+    } catch { /* ignore */ }
+    if (timers.killGrace) {
+        clearTimeout(timers.killGrace);
+        timers.killGrace = null;
+    }
+    timers.killGrace = setTimeout(() => {
+        timers.killGrace = null;
+        _escalateRgKill(proc);
+    }, RG_KILL_GRACE_MS);
+    if (timers.killGrace.unref) timers.killGrace.unref();
+}
+
+function _clearRgTimeoutOnly(timers) {
+    if (timers.timeout) {
+        clearTimeout(timers.timeout);
+        timers.timeout = null;
+    }
+}
+
+function _clearRgTimers(timers) {
+    _clearRgTimeoutOnly(timers);
+    if (timers.killGrace) {
+        clearTimeout(timers.killGrace);
+        timers.killGrace = null;
+    }
+    if (timers.forceSettle) {
+        clearTimeout(timers.forceSettle);
+        timers.forceSettle = null;
+    }
+}
+
+function _armRgForceSettle({ timeoutMs, isSettled, timers, proc, onForceSettle }) {
+    if (timers.forceSettle) clearTimeout(timers.forceSettle);
+    timers.forceSettle = setTimeout(() => {
+        timers.forceSettle = null;
+        if (isSettled()) return;
+        // Hard deadline: escalate immediately — do not schedule grace then clear it.
+        _escalateRgKill(proc);
+        onForceSettle();
+    }, timeoutMs + RG_FORCE_SETTLE_SLACK_MS);
+    if (timers.forceSettle.unref) timers.forceSettle.unref();
+}
+
+// Ripgrep wrapper. Ripgrep occasionally fails with EAGAIN on Windows when
+// thread/resource pressure spikes. On EAGAIN we retry once with `-j 1` to
+// force single-threaded execution; rg exit code 1 is "no matches" and is
+// surfaced as empty stdout so callers can render "(no matches)" uniformly.
+function spawnRg(argsList, execOptions) {
+    const timeoutMs = Number(execOptions?.timeout ?? 20000);
+    return new Promise((resolve, reject) => {
+        const proc = spawn(rgExecutable(), argsList, {
+            cwd: execOptions?.cwd,
+            env: execOptions?.env || process.env,
+            windowsHide: true,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        let timedOut = false;
+        /** @type {'timeout' | 'cap' | null} */
+        let killReason = null;
+        let settled = false;
+        let stdoutBytes = 0;
+        let stdoutTruncated = false;
+        const timers = { timeout: null, killGrace: null, forceSettle: null };
+        timers.timeout = setTimeout(() => {
+            timedOut = true;
+            killReason = 'timeout';
+            _killRgProc(proc, timers);
+        }, timeoutMs);
+        if (timers.timeout.unref) timers.timeout.unref();
+        _armRgForceSettle({
+            timeoutMs,
+            isSettled: () => settled,
+            timers,
+            proc,
+            onForceSettle: () => {
+                timedOut = true;
+                killReason = 'timeout';
+                const e = new Error(`rg timed out after ${timeoutMs} ms`);
+                e.code = 'ETIMEDOUT';
+                if (settled) return;
+                settled = true;
+                _clearRgTimers(timers);
+                reject(e);
+            },
+        });
+        proc.stdout.setEncoding('utf-8');
+        proc.stderr.setEncoding('utf-8');
+        proc.stdout.on('data', (d) => {
+            if (stdoutTruncated) return;
+            // Account by UTF-8 byte length (d is a decoded string here), not by
+            // string length, so non-ASCII output cannot overshoot the byte cap.
+            const dBytes = Buffer.byteLength(d);
+            const remaining = MAX_RG_STDOUT_BYTES - stdoutBytes;
+            if (dBytes >= remaining) {
+                // Slice by BYTES (not chars) and cut on a UTF-8 codepoint
+                // boundary: a char-count slice overshoots on multibyte output,
+                // and even a raw byte slice would let a split trailing codepoint
+                // decode to U+FFFD (3 bytes) and exceed the cap. Back `end` over
+                // continuation bytes (0b10xxxxxx) so the kept bytes are <= cap.
+                const buf = Buffer.from(d, 'utf8');
+                let end = Math.max(0, Math.min(remaining, buf.length));
+                while (end > 0 && end < buf.length && (buf[end] & 0xC0) === 0x80) end--;
+                stdout += buf.subarray(0, end).toString('utf8');
+                stdoutBytes = MAX_RG_STDOUT_BYTES;
+                stdoutTruncated = true;
+                if (killReason !== 'timeout') killReason = 'cap';
+                _clearRgTimeoutOnly(timers);
+                _killRgProc(proc, timers);
+                return;
+            }
+            stdout += d;
+            stdoutBytes += dBytes;
+        });
+        proc.stderr.on('data', (d) => { stderr += d; });
+        proc.on('error', (err) => {
+            if (settled) return;
+            settled = true;
+            _clearRgTimers(timers);
+            reject(err);
+        });
+        proc.on('close', (code) => {
+            if (settled) return;
+            settled = true;
+            _clearRgTimers(timers);
+            if (timedOut && killReason === 'timeout') {
+                const e = new Error(`rg timed out after ${timeoutMs} ms`);
+                e.code = 'ETIMEDOUT';
+                return reject(e);
+            }
+            const wrap = (s) => {
+                if (!stdoutTruncated) return s;
+                const boxed = new String(s);
+                try { boxed.truncated = true; } catch { /* ignore */ }
+                return boxed;
+            };
+            const boxPartialStdout = (s, rgStderrText) => {
+                const boxed = new String(s);
+                try {
+                    if (stdoutTruncated) boxed.truncated = true;
+                    boxed.partial = true;
+                    boxed.rgStderr = rgStderrText;
+                } catch { /* ignore */ }
+                return boxed;
+            };
+            if (code === 0) return resolve(wrap(stdout));
+            if (code === 1) return resolve(wrap(''));
+            // SIGTERM after our own truncation kill: surface accumulated stdout.
+            if (stdoutTruncated) return resolve(wrap(stdout));
+            // Exit 2 (e.g. permission denied on some paths) may still emit matches.
+            if (code === 2 && stdout.length > 0) {
+                return resolve(boxPartialStdout(stdout, stderr.trim()));
+            }
+            const e = new Error(`rg exited with code ${code}: ${stderr.trim()}`);
+            e.code = code;
+            e.stderr = stderr;
+            reject(e);
+        });
+    });
+}
+
+export async function runRg(argsList, execOptions = {}) {
+    assertRgAvailable();
+    try {
+        return await spawnRg(argsList, execOptions);
+    } catch (err) {
+        const msg = String(err?.message || err?.stderr || '');
+        if (/EAGAIN/i.test(msg) && !argsList.includes('-j')) {
+            return spawnRg(['-j', '1', ...argsList], execOptions);
+        }
+        throw err;
+    }
+}
+
+function spawnRgWindowedLines(argsList, execOptions, opts = {}) {
+    const timeoutMs = Number(execOptions?.timeout ?? 20000);
+    const offset = Math.max(0, Math.floor(Number(opts.offset) || 0));
+    const lineLimit = Number.isFinite(opts.limit) ? Math.max(0, Math.floor(Number(opts.limit) || 0)) : Infinity;
+    const summaryLimit = Math.max(0, Math.floor(Number(opts.summaryLimit) || 0));
+    const collectLimit = lineLimit === Infinity ? Infinity : Math.max(lineLimit, summaryLimit);
+    return new Promise((resolve, reject) => {
+        const proc = spawn(rgExecutable(), argsList, {
+            cwd: execOptions?.cwd,
+            env: execOptions?.env || process.env,
+            windowsHide: true,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let buffer = '';
+        let stderr = '';
+        let skipped = 0;
+        let seenAfterOffset = 0;
+        let stoppedEarly = false;
+        let timedOut = false;
+        /** @type {'timeout' | 'early' | null} */
+        let killReason = null;
+        let settled = false;
+        const timers = { timeout: null, killGrace: null, forceSettle: null };
+        const lines = [];
+        timers.timeout = setTimeout(() => {
+            timedOut = true;
+            killReason = 'timeout';
+            _killRgProc(proc, timers);
+        }, timeoutMs);
+        if (timers.timeout.unref) timers.timeout.unref();
+        _armRgForceSettle({
+            timeoutMs,
+            isSettled: () => settled,
+            timers,
+            proc,
+            onForceSettle: () => {
+                timedOut = true;
+                killReason = 'timeout';
+                const e = new Error(`rg timed out after ${timeoutMs} ms`);
+                e.code = 'ETIMEDOUT';
+                if (settled) return;
+                settled = true;
+                _clearRgTimers(timers);
+                reject(e);
+            },
+        });
+        const stopEarly = () => {
+            if (stoppedEarly) return;
+            stoppedEarly = true;
+            buffer = '';
+            if (killReason !== 'timeout') killReason = 'early';
+            _clearRgTimeoutOnly(timers);
+            _killRgProc(proc, timers);
+        };
+        const pushLine = (raw) => {
+            if (stoppedEarly || raw.length === 0) return;
+            const line = raw.endsWith('\r') ? raw.slice(0, -1) : raw;
+            if (line.length === 0) return;
+            if (skipped < offset) {
+                skipped++;
+                return;
+            }
+            seenAfterOffset++;
+            if (seenAfterOffset <= collectLimit) {
+                lines.push(line);
+                return;
+            }
+            stopEarly();
+        };
+        proc.stdout.setEncoding('utf-8');
+        proc.stderr.setEncoding('utf-8');
+        proc.stdout.on('data', (chunk) => {
+            if (stoppedEarly) return;
+            buffer += chunk;
+            let start = 0;
+            let idx = buffer.indexOf('\n', start);
+            while (!stoppedEarly && idx !== -1) {
+                pushLine(buffer.slice(start, idx));
+                start = idx + 1;
+                idx = buffer.indexOf('\n', start);
+            }
+            buffer = stoppedEarly ? '' : buffer.slice(start);
+        });
+        proc.stderr.on('data', (d) => {
+            if (stderr.length < 4096) stderr += d;
+        });
+        proc.on('error', (err) => {
+            if (settled) return;
+            settled = true;
+            _clearRgTimers(timers);
+            reject(err);
+        });
+        proc.on('close', (code) => {
+            if (settled) return;
+            settled = true;
+            _clearRgTimers(timers);
+            if (timedOut && killReason === 'timeout') {
+                const e = new Error(`rg timed out after ${timeoutMs} ms`);
+                e.code = 'ETIMEDOUT';
+                return reject(e);
+            }
+            if (!stoppedEarly && buffer.length > 0) pushLine(buffer);
+            if (stoppedEarly) {
+                return resolve({ lines, complete: false, totalSeen: seenAfterOffset });
+            }
+            if (code === 0 || code === 1) {
+                return resolve({ lines, complete: true, totalSeen: seenAfterOffset });
+            }
+            if (code === 2 && lines.length > 0) {
+                return resolve({
+                    lines,
+                    complete: false,
+                    totalSeen: seenAfterOffset,
+                    partial: true,
+                    rgStderr: stderr.trim(),
+                });
+            }
+            const e = new Error(`rg exited with code ${code}: ${stderr.trim()}`);
+            e.code = code;
+            e.stderr = stderr;
+            reject(e);
+        });
+    });
+}
+
+export async function runRgWindowedLines(argsList, execOptions = {}, opts = {}) {
+    assertRgAvailable();
+    try {
+        return await spawnRgWindowedLines(argsList, execOptions, opts);
+    } catch (err) {
+        const msg = String(err?.message || err?.stderr || '');
+        if (/EAGAIN/i.test(msg) && !argsList.includes('-j')) {
+            return spawnRgWindowedLines(['-j', '1', ...argsList], execOptions, opts);
+        }
+        throw err;
+    }
+}