mixdog 0.9.52 → 0.9.53

package/src/runtime/agent/orchestrator/tools/builtin/list-tool.mjs

@@ -8,9 +8,7 @@ import {
     normalizeOutputPath,
     resolveAgainstCwd,
 } from './path-utils.mjs';
-import { buildNotFoundHint, finalizeReadFamilyEnoentTail, tryReadFamilyEnoentRedirect } from './search-path-diagnostics.mjs';
 import { normalizeErrorMessage } from './path-diagnostics.mjs';
-import { isUncPath, isWindowsDevicePath, hasUnsafeWin32Component } from './device-paths.mjs';
 import {
     buildListCacheKey,
     DEFAULT_IGNORE_GLOBS,
@@ -36,49 +34,12 @@ import { runRg } from './rg-runner.mjs';
 import { hasSpareCapacity as childSpawnHasSpareCapacity } from '../../../../shared/child-spawn-gate.mjs';
 import { fuzzyRank } from './fuzzy-match.mjs';
 import { assertPathReachable } from './fs-reachability.mjs';
+import { listGuardPath, normalizeListHeadLimit, readFamilyPathEnoentOrError } from './lib/list-helpers.mjs';
 
 const FIND_WALK_TIMEOUT_MS = 20_000;
 const LIST_WALK_TIMEOUT_MS = 20_000;
 const LIST_ABSOLUTE_CAP = 50_000;
 
-/** undefined / invalid / negative → defaultCap; 0 = no page cap (absolute caps still apply). */
-async function readFamilyPathEnoentOrError(workDir, fullPath, inputPath, args, options, err, rerunTool) {
-    const redirected = await tryReadFamilyEnoentRedirect({
-        workDir,
-        resolvedPath: fullPath,
-        requestedPath: inputPath,
-        errCode: err?.code,
-        options,
-        rerun: (target, opts) => rerunTool({ ...args, path: target }, workDir, opts),
-    });
-    if (redirected) return redirected;
-    const msg = `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`;
-    const hint = buildNotFoundHint(workDir, fullPath, 'List', err?.code);
-    return msg + finalizeReadFamilyEnoentTail(hint, inputPath, err?.code);
-}
-
-function normalizeListHeadLimit(raw, defaultCap) {
-    if (raw === undefined || raw === null || raw === '') return defaultCap;
-    const n = Number(raw);
-    if (!Number.isFinite(n) || n < 0) return defaultCap;
-    return Math.floor(n);
-}
-
-// UNC / Windows-device / NTFS-ADS guard for directory-walking modes
-// (list / tree / find). Walking a UNC share auto-authenticates to the
-// remote host (NTLM hash leak); a raw-device / reserved-name path can
-// hang or grant raw access. Mirrors the read path's string-based checks.
-// Returns an Error string when the path is blocked, else null.
-function listGuardPath(p) {
-    if (typeof isUncPath === 'function' && isUncPath(p))
-        return `Error: cannot walk UNC / SMB path (network credential leak risk): ${normalizeOutputPath(p)}`;
-    if (typeof isWindowsDevicePath === 'function' && isWindowsDevicePath(p))
-        return `Error: cannot walk Windows device path (reserved name or raw-device namespace): ${normalizeOutputPath(p)}`;
-    if (typeof hasUnsafeWin32Component === 'function' && hasUnsafeWin32Component(p))
-        return `Error: cannot walk Windows path with trailing dot/space or NTFS ADS suffix (bypasses device guard): ${normalizeOutputPath(p)}`;
-    return null;
-}
-
 export async function executeListTool(args, workDir, options = {}) {
     args.path = coerceReadFamilyPathArg(args.path, workDir);
     if (Array.isArray(args.path)) {

package/src/runtime/agent/orchestrator/tools/builtin/search-tool.mjs

@@ -62,6 +62,25 @@ import {
     statPathsForMtime,
 } from './cache-layers.mjs';
 import { applyGrepContextLeadPolicy, GREP_CONTEXT_MAX, hasUnsupportedRipgrepRegex } from './arg-guard.mjs';
+import {
+    buildGrepChunkMergePrefix,
+    chunkPatternList,
+    computeGrepChunkAggregateBudget,
+    extractGrepChunkResultLines,
+    mergeGrepChunkLines,
+} from './lib/search-grep-chunks.mjs';
+import {
+    expandLegacyEscapedAlternationPattern,
+    relativeGrepLine,
+    uniqueStrings,
+    isRgRegexParseError,
+    regexPatternToFixedTerms,
+    coerceNonNegInt,
+    globMtimeTiePath,
+    splitGlobString,
+    isRedundantAllFilesGlob,
+    parseGrepCountLine,
+} from './lib/search-input-helpers.mjs';
 
 // Default surrounding-lines window applied by output_mode:'content_with_context'
 // when the caller does not pass an explicit -A/-B/-C/context. Sized to cover a
@@ -70,104 +89,11 @@ import { applyGrepContextLeadPolicy, GREP_CONTEXT_MAX, hasUnsupportedRipgrepRege
 // context-mode clamp by policy); only head_limit blocks are context-clamped.
 const GREP_AUTO_CONTEXT_LINES = 25;
 
-function expandLegacyEscapedAlternationPattern(rawPattern) {
-    if (typeof rawPattern !== 'string' || !rawPattern.includes('\\|')) return null;
-    const parts = rawPattern.split('\\|').map((part) => part.trim()).filter(Boolean);
-    return parts.length > 1 ? parts : null;
-}
-
-function relativeGrepLine(line, workDir, pathOnly = false, outputMode = 'content', filenameOmitted = false) {
-    const normalized = normalizeGrepLine(line, pathOnly, outputMode, filenameOmitted);
-    if (!workDir) return normalized;
-    if (pathOnly) return relativePathPrefix(normalized, workDir);
-    if (filenameOmitted) return normalized;
-    const split = splitGrepLinePrefix(normalized);
-    if (split) {
-        return relativePathPrefix(normalized.slice(0, split.pathEnd), workDir) + normalized.slice(split.pathEnd);
-    }
-    if (outputMode === 'count') {
-        const countSplit = splitGrepCountPrefix(normalized);
-        if (countSplit) {
-            return relativePathPrefix(normalized.slice(0, countSplit.pathEnd), workDir) + normalized.slice(countSplit.pathEnd);
-        }
-    }
-    return normalized;
-}
-
-function uniqueStrings(values) {
-    return Array.from(new Set(values.filter((value) => typeof value === 'string' && value)));
-}
-
-function isRgRegexParseError(err) {
-    const msg = `${err?.stderr || ''}\n${err?.message || err || ''}`;
-    return /regex parse error/i.test(msg);
-}
-
-function regexPatternToFixedTerms(pattern) {
-    const raw = String(pattern || '');
-    if (!raw) return [];
-    return raw
-        .split(/\\?\|/g)
-        .map((part) => part.trim())
-        .map((part) => part
-            .replace(/\\[bB]/g, '')
-            .replace(/^\^/, '')
-            .replace(/\$$/, '')
-            .replace(/\\([\\.^$*+?()[\]{}|/-])/g, '$1')
-            .trim())
-        .filter((part) => part.length > 0);
-}
-
-function coerceNonNegInt(value) {
-    if (value === undefined || value === null || value === '') return null;
-    const n = Number(value);
-    if (!Number.isFinite(n) || n < 0) return NaN;
-    return Math.floor(n);
-}
-
-function globMtimeTiePath(entry) {
-    const p = String(entry?.path ?? entry?.full ?? '');
-    return process.platform === 'win32' ? p.toLocaleLowerCase() : p;
-}
 
 // CC parity (GrepTool.ts): a single glob string may pack multiple filters
 // separated by whitespace or commas, e.g. "*.ts,*.tsx" or "*.ts *.tsx". Split
 // each into its own --glob. Brace patterns ("*.{ts,tsx}") are left intact so
 // their internal commas are not torn apart.
-function splitGlobString(value) {
-    const out = [];
-    const str = String(value);
-    let depth = 0;
-    let token = '';
-    const flush = () => {
-        const trimmed = token.trim();
-        if (trimmed) out.push(trimmed);
-        token = '';
-    };
-    for (const ch of str) {
-        if (ch === '{') {
-            depth++;
-            token += ch;
-        } else if (ch === '}') {
-            if (depth > 0) depth--;
-            token += ch;
-        } else if (depth === 0 && (ch === ',' || /\s/.test(ch))) {
-            flush();
-        } else {
-            token += ch;
-        }
-    }
-    flush();
-    return out;
-}
-
-function isRedundantAllFilesGlob(value) {
-    const g = canonicalizeGlobSlashes(String(value || '').trim())
-        .replace(/^\.\//, '')
-        .replace(/^\/+/, '')
-        .replace(/\/+$/, '');
-    return g === '**/*' || g === '**';
-}
 
 function grepMissingPatternMessage() {
     return 'Error: grep requires pattern.';
@@ -177,190 +103,6 @@ function globMissingPatternMessage() {
     return 'Error: glob requires pattern.';
 }
 
-function parseGrepCountLine(line) {
-    const text = String(line || '');
-    const searchFrom = /^[A-Za-z]:/.test(text) ? 2 : 0;
-    const idx = text.lastIndexOf(':');
-    if (idx <= searchFrom) return null;
-    const count = Number(text.slice(idx + 1));
-    if (!Number.isFinite(count) || count <= 0) return null;
-    const path = text.slice(0, idx);
-    if (!path) return null;
-    return { path, count };
-}
-
-const GREP_RESULT_LINE_SKIP = /^\[(?:Showing|total|pattern set|capped|warning|redirected|regex parse)/;
-const GREP_CHUNK_AGGREGATE_FLOOR = 200;
-const GREP_CHUNK_AGGREGATE_DEFAULT = 800;
-const GREP_CHUNK_AGGREGATE_MAX = 4000;
-
-function chunkPatternList(patterns, cap) {
-    const out = [];
-    for (let i = 0; i < patterns.length; i += cap) out.push(patterns.slice(i, i + cap));
-    return out;
-}
-
-function computeGrepChunkAggregateBudget(offset, headLimit, headLimitCoerced) {
-    if (headLimitCoerced === 0 && headLimit === Infinity) return GREP_CHUNK_AGGREGATE_MAX;
-    if (headLimit === Infinity) return GREP_CHUNK_AGGREGATE_DEFAULT;
-    const need = offset + headLimit;
-    return Math.min(GREP_CHUNK_AGGREGATE_MAX, Math.max(GREP_CHUNK_AGGREGATE_FLOOR, need * 2));
-}
-
-function compareGrepLinesByPathLine(a, b) {
-    const pa = splitGrepLinePrefix(a);
-    const pb = splitGrepLinePrefix(b);
-    if (!pa && !pb) return String(a).localeCompare(String(b));
-    if (!pa) return 1;
-    if (!pb) return -1;
-    const byPath = pa.path.localeCompare(pb.path);
-    if (byPath !== 0) return byPath;
-    return pa.lineNo - pb.lineNo;
-}
-
-function deriveGrepCountLinesFromMatchContent(lines) {
-    const byPath = new Map();
-    for (const line of lines) {
-        const split = splitGrepLinePrefix(line);
-        if (!split || split.delimiter !== ':') continue;
-        if (!byPath.has(split.path)) byPath.set(split.path, new Set());
-        byPath.get(split.path).add(split.lineNo);
-    }
-    return [...byPath.entries()]
-        .sort((a, b) => a[0].localeCompare(b[0]))
-        .map(([path, lineNos]) => `${path}:${lineNos.size}`);
-}
-
-function isGrepMatchLine(line) {
-    const split = splitGrepLinePrefix(line);
-    return !!(split && split.delimiter === ':');
-}
-
-function grepMatchAnchorKey(line) {
-    const split = splitGrepLinePrefix(line);
-    if (!split || split.delimiter !== ':') return '';
-    return `${split.path}\0${split.lineNo}`;
-}
-
-function parseGrepContextBlocksInSegment(segmentLines) {
-    const blocks = [];
-    let pending = [];
-    let i = 0;
-    while (i < segmentLines.length) {
-        const line = segmentLines[i];
-        if (isGrepMatchLine(line)) {
-            const blockLines = pending.concat([line]);
-            pending = [];
-            i += 1;
-            while (i < segmentLines.length) {
-                const next = segmentLines[i];
-                if (next === '--' || isGrepMatchLine(next)) break;
-                blockLines.push(next);
-                i += 1;
-            }
-            const anchor = grepMatchAnchorKey(line);
-            if (anchor) blocks.push({ anchor, lines: blockLines });
-            continue;
-        }
-        pending.push(line);
-        i += 1;
-    }
-    return blocks;
-}
-
-function compareGrepAnchorKeys(a, b) {
-    const [pa, la] = String(a || '').split('\0');
-    const [pb, lb] = String(b || '').split('\0');
-    const byPath = pa.localeCompare(pb);
-    if (byPath !== 0) return byPath;
-    return Number(la) - Number(lb);
-}
-
-function mergeGrepContextChunkLines(lines) {
-    const segments = [];
-    let current = [];
-    for (const line of lines) {
-        if (line === '--') {
-            segments.push(current);
-            current = [];
-        } else {
-            current.push(line);
-        }
-    }
-    segments.push(current);
-    const seen = new Set();
-    const blocks = [];
-    for (const segment of segments) {
-        if (!segment.length) continue;
-        for (const block of parseGrepContextBlocksInSegment(segment)) {
-            if (!block.anchor || seen.has(block.anchor)) continue;
-            seen.add(block.anchor);
-            blocks.push(block);
-        }
-    }
-    blocks.sort((a, b) => compareGrepAnchorKeys(a.anchor, b.anchor));
-    const out = [];
-    for (const block of blocks) {
-        if (out.length) out.push('--');
-        out.push(...block.lines);
-    }
-    return out;
-}
-
-function mergeGrepChunkLines(lines, { outputMode, beforeN, afterN, contextN }) {
-    const hasContext = (beforeN > 0 || afterN > 0 || contextN > 0);
-    if (outputMode === 'count') {
-        return deriveGrepCountLinesFromMatchContent(lines);
-    }
-    if (outputMode === 'files_with_matches') {
-        const seen = new Set();
-        const out = [];
-        for (const line of lines) {
-            const path = String(line || '').trim();
-            if (!path || seen.has(path)) continue;
-            seen.add(path);
-            out.push(path);
-        }
-        out.sort((a, b) => a.localeCompare(b));
-        return out;
-    }
-    if (outputMode === 'content' && hasContext) {
-        return mergeGrepContextChunkLines(lines);
-    }
-    const matches = new Map();
-    for (const line of lines) {
-        const split = splitGrepLinePrefix(line);
-        if (split && split.delimiter === ':') {
-            const key = `${split.path}\0${split.lineNo}`;
-            if (!matches.has(key)) matches.set(key, line);
-        }
-    }
-    return [...matches.values()].sort(compareGrepLinesByPathLine);
-}
-
-function extractGrepChunkResultLines(body, room = Infinity) {
-    const text = String(body || '').trim();
-    if (!text || /^Error:/i.test(text)) return { error: text || 'Error: empty grep chunk result' };
-    if (/^\(no matches\)/i.test(text)) return { lines: [], truncated: false };
-    const rawLines = text.split('\n');
-    const childShowingTruncated = rawLines.some((line) => /^\[Showing /i.test(String(line || '').trim()));
-    const lines = rawLines.filter((line) => line && !GREP_RESULT_LINE_SKIP.test(line));
-    const truncated = childShowingTruncated
-        || (Number.isFinite(room) && room >= 0 && lines.length >= room);
-    return { lines, truncated };
-}
-
-function buildGrepChunkMergePrefix(patternChunkCount, truncated, aggregateBudget, outputMode = 'content') {
-    if (patternChunkCount <= 1 && !truncated) return '';
-    const parts = [];
-    if (patternChunkCount > 1) parts.push(`pattern set split into ${patternChunkCount} chunks`);
-    if (truncated) {
-        parts.push(`chunk results truncated at aggregate budget ${aggregateBudget} lines; results are partial`);
-        if (outputMode === 'count') parts.push('counts are lower bounds (>=)');
-    }
-    return `[${parts.join('; ')}]\n`;
-}
-
 // --- context-mode match-block windowing (Parts 2 & 3) ---------------------
 // In context mode (explicit -A/-B/-C or content_with_context auto), head_limit
 // and offset count MATCH BLOCKS, not raw output lines, and truncation keeps a