mixdog 0.7.18 → 0.8.0

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

@@ -1,196 +0,0 @@
-// 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

@@ -1,422 +0,0 @@
-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;
-    }
-}