@qvac/harness 0.8.9 → 0.8.11

package/dist-lib/lib/tools/grep.js

@@ -1,184 +0,0 @@
-import { errorMessage } from '../guards.js';
-import { hlog } from '../log.js';
-import { searchTargets } from './file-glob.js';
-import { readLines } from './fs/read.js';
-import { isDriveReadTruncated } from './fs/remote.js';
-import { canonicalDenyRoots, defaultRealpath, isDeniedPath } from './fs/scope.js';
-import { walkFiles } from './fs/walk.js';
-export const DEFAULT_GREP_MATCHES = 200;
-export const MAX_GREP_MATCHES = 1000;
-const MAX_LINE_CHARS = 500;
-const BINARY_PROBE_CHARS = 1024;
-async function scanFile(drive, key, { path, tests, room }) {
-    const hits = [];
-    let probed = 0;
-    let binary = false;
-    let index = 0;
-    try {
-        for await (const line of readLines(drive, key)) {
-            index++;
-            if (probed < BINARY_PROBE_CHARS && line.includes('\0')) {
-                binary = true;
-                break;
-            }
-            if (probed < BINARY_PROBE_CHARS) {
-                probed += line.length + 1;
-            }
-            if (!tests.some((test) => test(line))) {
-                continue;
-            }
-            hits.push({ file: path, line: index, text: line.slice(0, MAX_LINE_CHARS) });
-            if (hits.length >= room) {
-                return { hits, binary, end: 'capped' };
-            }
-        }
-    }
-    catch (error) {
-        if (isDriveReadTruncated(error)) {
-            return { hits, binary, end: 'cut' };
-        }
-        return { hits, binary, end: 'unreadable', error };
-    }
-    return { hits, binary, end: 'complete' };
-}
-function stringArray(raw) {
-    if (!Array.isArray(raw) || raw.length === 0)
-        return null;
-    const values = raw.filter((entry) => typeof entry === 'string' && entry.length > 0);
-    return values.length === raw.length ? values : null;
-}
-function compileQueries(queries, regex, caseSensitive) {
-    if (regex) {
-        try {
-            return queries.map((q) => {
-                const rx = new RegExp(q, caseSensitive ? '' : 'i');
-                return (line) => rx.test(line);
-            });
-        }
-        catch (err) {
-            return { error: `invalid regex: ${errorMessage(err)}` };
-        }
-    }
-    return queries.map((q) => {
-        const needle = caseSensitive ? q : q.toLowerCase();
-        return caseSensitive
-            ? (line) => line.includes(needle)
-            : (line) => line.toLowerCase().includes(needle);
-    });
-}
-export function createGrepTool({ realpath = defaultRealpath, deniedRoots } = {}) {
-    return {
-        name: 'grep',
-        toolset: 'files',
-        description: 'Search file contents inside the granted directories. Queries are literal ' +
-            'substrings by default (case-insensitive); set regex=true for patterns. ' +
-            'Returns matching lines with file and line number. Symlinks are never ' +
-            'followed; skippedLinks counts the ones left out.',
-        parameters: {
-            type: 'object',
-            properties: {
-                queries: {
-                    type: 'array',
-                    description: 'Text or patterns to search for',
-                    items: { type: 'string' }
-                },
-                dir: {
-                    type: 'string',
-                    description: 'Optional directory to search (default: every granted directory)'
-                },
-                regex: {
-                    type: 'boolean',
-                    description: 'Treat queries as regular expressions (default false)'
-                },
-                caseSensitive: { type: 'boolean', description: 'Match case exactly (default false)' },
-                maxMatches: {
-                    type: 'number',
-                    description: `Optional match cap (default ${DEFAULT_GREP_MATCHES}, max ${MAX_GREP_MATCHES})`
-                }
-            },
-            required: ['queries']
-        },
-        effect: () => 'read',
-        stableRead: true,
-        autoApprove: true,
-        rootsRequired: true,
-        validate(rawArgs) {
-            const queries = stringArray(rawArgs.queries);
-            if (!queries) {
-                return 'queries must be a non-empty array of strings';
-            }
-            const compiled = compileQueries(queries, rawArgs.regex === true, rawArgs.caseSensitive === true);
-            if ('error' in compiled) {
-                return compiled.error;
-            }
-            const maxMatches = rawArgs.maxMatches;
-            if (maxMatches !== undefined && maxMatches !== null) {
-                const n = Number(maxMatches);
-                if (!Number.isInteger(n) || n <= 0 || n > MAX_GREP_MATCHES) {
-                    return `maxMatches must be a positive integer ≤ ${MAX_GREP_MATCHES}`;
-                }
-            }
-            return null;
-        },
-        resource(args) {
-            const queries = stringArray(args.queries);
-            return queries ? { kind: 'file', label: `grep ${queries.join(', ')}` } : null;
-        },
-        async execute(rawArgs, ctx) {
-            const roots = ctx?.fsRoots ?? [];
-            const queries = stringArray(rawArgs.queries);
-            if (!queries) {
-                return { error: 'queries must be a non-empty array of strings' };
-            }
-            const compiled = compileQueries(queries, rawArgs.regex === true, rawArgs.caseSensitive === true);
-            if ('error' in compiled) {
-                return compiled;
-            }
-            const maxMatches = rawArgs.maxMatches ? Number(rawArgs.maxMatches) : DEFAULT_GREP_MATCHES;
-            const deny = await canonicalDenyRoots(deniedRoots, realpath);
-            const scoped = await searchTargets(rawArgs.dir, roots, { realpath, deny });
-            if ('error' in scoped) {
-                return scoped;
-            }
-            const matches = [];
-            let truncated = false;
-            let skippedLinks = 0;
-            for (const target of scoped.targets) {
-                const walk = await walkFiles(target.root, target.folder);
-                truncated ||= walk.truncated;
-                skippedLinks += walk.skippedLinks;
-                for (const file of walk.files) {
-                    if (isDeniedPath(file.path, deny))
-                        continue;
-                    const scan = await scanFile(target.root.drive, file.key, {
-                        path: file.path,
-                        tests: compiled,
-                        room: maxMatches - matches.length
-                    });
-                    if (scan.end === 'capped') {
-                        matches.push(...scan.hits);
-                        return { matches, truncated: true, skippedLinks: skippedLinks || undefined };
-                    }
-                    if (scan.end === 'unreadable') {
-                        hlog('warn: grep skipped a file', {
-                            file: file.path,
-                            err: errorMessage(scan.error)
-                        });
-                        continue;
-                    }
-                    if (scan.end === 'cut') {
-                        truncated = true;
-                    }
-                    if (!scan.binary) {
-                        matches.push(...scan.hits);
-                    }
-                }
-            }
-            return {
-                matches,
-                truncated: truncated || undefined,
-                skippedLinks: skippedLinks || undefined
-            };
-        }
-    };
-}

package/dist-lib/lib/tools/read-files.d.ts

@@ -1,5 +0,0 @@
-import type { ToolDefinition } from '../capabilities/completion.ts';
-import { type FsToolOptions } from './fs/scope.ts';
-export declare const DEFAULT_READ_CHARS = 8192;
-export declare const MAX_READ_CHARS = 65536;
-export declare function createReadFilesTool({ realpath, deniedRoots }?: FsToolOptions): ToolDefinition;

package/dist-lib/lib/tools/read-files.js

@@ -1,157 +0,0 @@
-import { errorMessage, isRecord } from '../guards.js';
-import { readLines } from './fs/read.js';
-import { isDriveReadTruncated } from './fs/remote.js';
-import { canonicalDenyRoots, defaultRealpath, resolveKey } from './fs/scope.js';
-export const DEFAULT_READ_CHARS = 8192;
-export const MAX_READ_CHARS = 65_536;
-function lineIndex(value) {
-    if (value === undefined || value === null)
-        return undefined;
-    const n = Number(value);
-    if (!Number.isInteger(n) || n < 1) {
-        return null;
-    }
-    return n;
-}
-function fileRequests(raw) {
-    if (!Array.isArray(raw) || raw.length === 0)
-        return null;
-    const files = [];
-    for (const entry of raw) {
-        if (!isRecord(entry) || typeof entry.path !== 'string' || !entry.path.trim()) {
-            return null;
-        }
-        const startLine = lineIndex(entry.startLine);
-        const endLine = lineIndex(entry.endLine);
-        if (startLine === null || endLine === null) {
-            return null;
-        }
-        files.push({ path: entry.path, startLine, endLine });
-    }
-    return files;
-}
-async function slice(drive, key, { request, maxChars }) {
-    const first = request.startLine ?? 1;
-    const last = request.endLine ?? Infinity;
-    const kept = [];
-    let length = 0;
-    let index = 0;
-    let capped = false;
-    try {
-        for await (const line of readLines(drive, key)) {
-            if (++index < first)
-                continue;
-            if (index > last)
-                break;
-            kept.push(line);
-            length += line.length + (kept.length > 1 ? 1 : 0);
-            if (length > maxChars) {
-                break;
-            }
-        }
-    }
-    catch (err) {
-        if (!isDriveReadTruncated(err)) {
-            throw err;
-        }
-        capped = true;
-    }
-    const text = kept.join('\n');
-    return text.length > maxChars || capped
-        ? { content: text.slice(0, maxChars), truncated: true }
-        : { content: text };
-}
-export function createReadFilesTool({ realpath = defaultRealpath, deniedRoots } = {}) {
-    return {
-        name: 'read_files',
-        toolset: 'files',
-        description: 'Read the contents of one or more files inside the granted directories. ' +
-            'Optionally slice by 1-indexed line range. Failures are reported per file.',
-        parameters: {
-            type: 'object',
-            properties: {
-                files: {
-                    type: 'array',
-                    description: 'Files to read',
-                    items: {
-                        type: 'object',
-                        properties: {
-                            path: { type: 'string', description: 'File path' },
-                            startLine: { type: 'number', description: 'Optional 1-indexed first line' },
-                            endLine: { type: 'number', description: 'Optional 1-indexed last line (inclusive)' }
-                        },
-                        required: ['path']
-                    }
-                },
-                maxChars: {
-                    type: 'number',
-                    description: `Optional per-file cap in characters (default ${DEFAULT_READ_CHARS}, max ${MAX_READ_CHARS})`
-                }
-            },
-            required: ['files']
-        },
-        effect: () => 'read',
-        stableRead: true,
-        autoApprove: true,
-        rootsRequired: true,
-        validate(rawArgs) {
-            if (!fileRequests(rawArgs.files)) {
-                return 'files must be a non-empty array of { path } with optional positive integer startLine/endLine';
-            }
-            const maxChars = rawArgs.maxChars;
-            if (maxChars !== undefined && maxChars !== null) {
-                const n = Number(maxChars);
-                if (!Number.isInteger(n) || n <= 0 || n > MAX_READ_CHARS) {
-                    return `maxChars must be a positive integer ≤ ${MAX_READ_CHARS}`;
-                }
-            }
-            return null;
-        },
-        resource(args) {
-            const files = fileRequests(args.files);
-            if (!files) {
-                return null;
-            }
-            const label = files
-                .map((f) => f.path)
-                .slice(0, 3)
-                .join(', ');
-            return {
-                kind: 'file',
-                label: files.length > 3 ? `${label} (+${files.length - 3} more)` : label
-            };
-        },
-        async execute(rawArgs, ctx) {
-            const roots = ctx?.fsRoots ?? [];
-            const requests = fileRequests(rawArgs.files);
-            if (!requests) {
-                return { error: 'files must be a non-empty array of { path }' };
-            }
-            const maxChars = rawArgs.maxChars ? Number(rawArgs.maxChars) : DEFAULT_READ_CHARS;
-            const files = [];
-            const failed = [];
-            const deny = await canonicalDenyRoots(deniedRoots, realpath);
-            for (const request of requests) {
-                const resolved = await resolveKey(request.path, roots, { realpath, deny });
-                if ('error' in resolved) {
-                    failed.push({ path: request.path, error: resolved.error });
-                    continue;
-                }
-                try {
-                    if ((await resolved.root.drive.entry(resolved.key)) === null) {
-                        failed.push({ path: request.path, error: `no such file: ${request.path}` });
-                        continue;
-                    }
-                    files.push({
-                        path: request.path,
-                        ...(await slice(resolved.root.drive, resolved.key, { request, maxChars }))
-                    });
-                }
-                catch (err) {
-                    failed.push({ path: request.path, error: errorMessage(err) });
-                }
-            }
-            return { files, failed: failed.length ? failed : undefined };
-        }
-    };
-}