@qvac/harness 0.8.9 → 0.8.10

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 };
-        }
-    };
-}