@qvac/harness 0.8.9 → 0.8.10

package/worker/harness-sidecar.mjs

@@ -4,6 +4,7 @@ import FileLog from 'bare-file-logger'
 import fs from 'fs'
 import { dirname, join } from 'path'
 import process from 'bare-process'
+import { followHostLevel, harnessLogLevel } from '../dist-lib/lib/log.js'
 import { configureSdkStorage } from '../dist-lib/lib/sdk-storage.js'
 import {
   Harness,
@@ -12,18 +13,14 @@ import {
   setHarnessLog,
   setHarnessLogSink
 } from '../dist-lib/index.js'
-import { createCreateDocumentsTool } from '../dist-lib/lib/tools/create-documents.js'
-import { createEditDocumentsTool } from '../dist-lib/lib/tools/edit-documents.js'
 import { createExecTool } from '../dist-lib/lib/tools/exec.js'
-import { createFileGlobTool } from '../dist-lib/lib/tools/file-glob.js'
 import { deniedRootsFor } from '../dist-lib/lib/tools/fs/scope.js'
-import { createGrepTool } from '../dist-lib/lib/tools/grep.js'
 import { createHttpRequestTool } from '../dist-lib/lib/tools/http-request.js'
 import { createMcpCallTool } from '../dist-lib/lib/tools/mcp-call.js'
 import { createOfficeTools } from '../dist-lib/lib/tools/office.js'
 import { compileOperationTools } from '../dist-lib/lib/tools/operations/compile.js'
 import { createPdfTool } from '../dist-lib/lib/tools/pdf.js'
-import { createReadFilesTool } from '../dist-lib/lib/tools/read-files.js'
+import { createFileTools } from '../dist-lib/lib/tools/files/index.js'
 import { createSkillTool } from '../dist-lib/lib/tools/skill.js'
 import { ensureBundledSkillsDir } from '../dist-lib/lib/tools/skills/bundled-dir.js'
 import { credentialAllowListFor, mcpReadMethods } from '../dist-lib/lib/tools/skills/index.js'
@@ -81,11 +78,17 @@ export default async function start(ipc, ready) {
 
   const sdkStorage = JSON.parse(Bare.argv[3] || '{}')
   const deniedRoots = deniedRootsFor(sdkStorage.home)
-  const hostWantsLogs = Bare.argv[7] === '1'
-  setHarnessLog(hostWantsLogs)
+  // spawn.ts's log slot: the host's level, '1' for on at QVAC_LOG_LEVEL, empty for off
+  if (Bare.argv[7]) {
+    followHostLevel(Bare.argv[7])
+  } else {
+    setHarnessLog(false)
+  }
+
+  const hostWantsLogs = harnessLogLevel() !== 'off'
   // before the first await so nothing logs ahead of the sink; the host writes assistant.log beside it
   const log = openHarnessLog(join(dirname(sdkStorage.home), 'harness.log')) ?? DISCARD
-  setHarnessLogSink((line) => log.info(SCOPE, line))
+  setHarnessLogSink((line, level) => log[level](SCOPE, line))
   captureConsole(log)
   await alignSdkConsoleWithHost(hostWantsLogs)
 
@@ -131,11 +134,7 @@ export default async function start(ipc, ready) {
     createWebSearchTool(),
     createWebFetchTool(),
     createWeatherLookupTool(),
-    createReadFilesTool({ deniedRoots }),
-    createFileGlobTool({ deniedRoots }),
-    createGrepTool({ deniedRoots }),
-    createCreateDocumentsTool({ deniedRoots }),
-    createEditDocumentsTool({ deniedRoots }),
+    ...createFileTools({ deniedRoots }),
     createPdfTool(),
     ...createOfficeTools()
   ]

package/dist-lib/lib/tools/create-documents.d.ts

@@ -1,3 +0,0 @@
-import type { ToolDefinition } from '../capabilities/completion.ts';
-import { type FsToolOptions } from './fs/scope.ts';
-export declare function createCreateDocumentsTool({ realpath, deniedRoots }?: FsToolOptions): ToolDefinition;

package/dist-lib/lib/tools/create-documents.js

@@ -1,95 +0,0 @@
-import { canonicalDenyRoots, defaultRealpath, resolveKey } from './fs/scope.js';
-import { writeText } from './fs/write.js';
-import { errorMessage } from '../guards.js';
-function documentRequests(raw) {
-    if (!Array.isArray(raw) || raw.length === 0)
-        return null;
-    const documents = [];
-    for (const entry of raw) {
-        if (!isDocumentRequest(entry))
-            return null;
-        documents.push({ path: entry.path, content: entry.content });
-    }
-    return documents;
-}
-function isDocumentRequest(value) {
-    if (typeof value !== 'object' || value === null)
-        return false;
-    if (!('path' in value) || typeof value.path !== 'string' || !value.path.trim()) {
-        return false;
-    }
-    return 'content' in value && typeof value.content === 'string';
-}
-export function createCreateDocumentsTool({ realpath = defaultRealpath, deniedRoots } = {}) {
-    return {
-        name: 'create_documents',
-        toolset: 'files',
-        description: 'Create new files inside the granted directories. Parent directories are ' +
-            'created as needed. Fails per file if the file already exists — use ' +
-            'edit_documents to change existing files.',
-        parameters: {
-            type: 'object',
-            properties: {
-                documents: {
-                    type: 'array',
-                    description: 'Files to create',
-                    items: {
-                        type: 'object',
-                        properties: {
-                            path: { type: 'string', description: 'File path' },
-                            content: { type: 'string', description: 'Full file content' }
-                        },
-                        required: ['path', 'content']
-                    }
-                }
-            },
-            required: ['documents']
-        },
-        effect: () => 'read',
-        writeRootsRequired: true,
-        validate(rawArgs) {
-            return documentRequests(rawArgs.documents)
-                ? null
-                : 'documents must be a non-empty array of { path, content }';
-        },
-        resource(args) {
-            const documents = documentRequests(args.documents);
-            if (!documents) {
-                return null;
-            }
-            const bytes = documents.reduce((sum, doc) => sum + doc.content.length, 0);
-            const first = documents[0];
-            const suffix = documents.length > 1 ? ` (+${documents.length - 1} more)` : '';
-            return { kind: 'file', label: `create ${first.path}${suffix}, ${bytes} chars` };
-        },
-        async execute(rawArgs, ctx) {
-            const roots = ctx?.fsWriteRoots ?? [];
-            const documents = documentRequests(rawArgs.documents);
-            if (!documents) {
-                return { error: 'documents must be a non-empty array of { path, content }' };
-            }
-            const created = [];
-            const failed = [];
-            const deny = await canonicalDenyRoots(deniedRoots, realpath);
-            for (const doc of documents) {
-                const resolved = await resolveKey(doc.path, roots, { realpath, deny });
-                if ('error' in resolved) {
-                    failed.push({ path: doc.path, error: resolved.error });
-                    continue;
-                }
-                try {
-                    if ((await resolved.root.drive.entry(resolved.key)) !== null) {
-                        failed.push({ path: doc.path, error: 'file already exists' });
-                        continue;
-                    }
-                    await writeText(resolved.root.drive, resolved.key, doc.content);
-                    created.push(doc.path);
-                }
-                catch (err) {
-                    failed.push({ path: doc.path, error: errorMessage(err) });
-                }
-            }
-            return { created, failed: failed.length ? failed : undefined };
-        }
-    };
-}

package/dist-lib/lib/tools/edit-documents.d.ts

@@ -1,3 +0,0 @@
-import type { ToolDefinition } from '../capabilities/completion.ts';
-import { type FsToolOptions } from './fs/scope.ts';
-export declare function createEditDocumentsTool({ realpath, deniedRoots }?: FsToolOptions): ToolDefinition;

package/dist-lib/lib/tools/edit-documents.js

@@ -1,132 +0,0 @@
-import b4a from 'b4a';
-import { canonicalDenyRoots, defaultRealpath, resolveKey } from './fs/scope.js';
-import { writeText } from './fs/write.js';
-import { errorMessage } from '../guards.js';
-function editRequests(raw) {
-    if (!Array.isArray(raw) || raw.length === 0)
-        return null;
-    const edits = [];
-    for (const entry of raw) {
-        if (!isEditRequest(entry))
-            return null;
-        edits.push({ path: entry.path, search: entry.search, replace: entry.replace });
-    }
-    return edits;
-}
-function isEditRequest(value) {
-    if (typeof value !== 'object' || value === null)
-        return false;
-    if (!('path' in value) || typeof value.path !== 'string' || !value.path.trim()) {
-        return false;
-    }
-    if (!('search' in value) || typeof value.search !== 'string' || !value.search) {
-        return false;
-    }
-    return 'replace' in value && typeof value.replace === 'string';
-}
-function applyEdits(content, edits) {
-    let next = content;
-    for (const edit of edits) {
-        const first = next.indexOf(edit.search);
-        if (first === -1) {
-            return { error: 'search text not found' };
-        }
-        if (next.indexOf(edit.search, first + edit.search.length) !== -1) {
-            return { error: 'search text is ambiguous (matches more than once)' };
-        }
-        next = next.slice(0, first) + edit.replace + next.slice(first + edit.search.length);
-    }
-    return next;
-}
-export function createEditDocumentsTool({ realpath = defaultRealpath, deniedRoots } = {}) {
-    return {
-        name: 'edit_documents',
-        toolset: 'files',
-        description: 'Edit existing files inside the granted directories via search/replace. ' +
-            'Each search string must match exactly once in its file; include enough ' +
-            'surrounding context to make it unique. Edits to one file apply together.',
-        parameters: {
-            type: 'object',
-            properties: {
-                edits: {
-                    type: 'array',
-                    description: 'Search/replace edits',
-                    items: {
-                        type: 'object',
-                        properties: {
-                            path: { type: 'string', description: 'File path' },
-                            search: { type: 'string', description: 'Exact text to find (must match once)' },
-                            replace: { type: 'string', description: 'Replacement text' }
-                        },
-                        required: ['path', 'search', 'replace']
-                    }
-                }
-            },
-            required: ['edits']
-        },
-        effect: () => 'write',
-        autoApprove: false,
-        writeRootsRequired: true,
-        validate(rawArgs) {
-            return editRequests(rawArgs.edits)
-                ? null
-                : 'edits must be a non-empty array of { path, search, replace }';
-        },
-        resource(args) {
-            const edits = editRequests(args.edits);
-            if (!edits) {
-                return null;
-            }
-            const paths = [...new Set(edits.map((edit) => edit.path))];
-            const label = paths.slice(0, 3).join(', ');
-            return {
-                kind: 'file',
-                label: `edit ${paths.length > 3 ? `${label} (+${paths.length - 3} more)` : label} (${edits.length} edit${edits.length > 1 ? 's' : ''})`
-            };
-        },
-        async execute(rawArgs, ctx) {
-            const roots = ctx?.fsWriteRoots ?? [];
-            const edits = editRequests(rawArgs.edits);
-            if (!edits) {
-                return { error: 'edits must be a non-empty array of { path, search, replace }' };
-            }
-            const byPath = new Map();
-            for (const edit of edits) {
-                const list = byPath.get(edit.path) ?? [];
-                list.push(edit);
-                byPath.set(edit.path, list);
-            }
-            const edited = [];
-            const failed = [];
-            const deny = await canonicalDenyRoots(deniedRoots, realpath);
-            for (const [file, fileEdits] of byPath) {
-                const resolved = await resolveKey(file, roots, { realpath, deny });
-                if ('error' in resolved) {
-                    failed.push({ path: file, error: resolved.error });
-                    continue;
-                }
-                try {
-                    const entry = await resolved.root.drive.entry(resolved.key);
-                    const blob = entry === null ? null : await resolved.root.drive.get(resolved.key);
-                    if (entry === null || blob === null) {
-                        failed.push({ path: file, error: `no such file: ${file}` });
-                        continue;
-                    }
-                    const next = applyEdits(b4a.toString(blob, 'utf8'), fileEdits);
-                    if (typeof next === 'object') {
-                        failed.push({ path: file, error: next.error });
-                        continue;
-                    }
-                    await writeText(resolved.root.drive, resolved.key, next, {
-                        executable: entry.value.executable
-                    });
-                    edited.push(file);
-                }
-                catch (err) {
-                    failed.push({ path: file, error: errorMessage(err) });
-                }
-            }
-            return { edited, failed: failed.length ? failed : undefined };
-        }
-    };
-}

package/dist-lib/lib/tools/file-glob.d.ts

@@ -1,14 +0,0 @@
-import type { ToolDefinition } from '../capabilities/completion.ts';
-import { type DriveRoot, type FsToolError, type FsToolOptions, type ResolveKeyOptions } from './fs/scope.ts';
-export declare const DEFAULT_GLOB_MATCHES = 100;
-export declare const MAX_GLOB_MATCHES = 1000;
-export interface SearchTarget {
-    root: DriveRoot;
-    folder: string;
-}
-export interface ResolvedTargets {
-    targets: SearchTarget[];
-}
-export declare function searchTargets(dir: unknown, roots: readonly DriveRoot[], { realpath, deny }: ResolveKeyOptions): Promise<ResolvedTargets | FsToolError>;
-export declare function relativeKey(key: string, folder: string): string;
-export declare function createFileGlobTool({ realpath, deniedRoots }?: FsToolOptions): ToolDefinition;

package/dist-lib/lib/tools/file-glob.js

@@ -1,118 +0,0 @@
-import { compileGlob } from './fs/glob.js';
-import { NO_DIRS_GRANTED, canonicalDenyRoots, defaultRealpath, isDeniedPath, resolveKey } from './fs/scope.js';
-import { walkFiles } from './fs/walk.js';
-export const DEFAULT_GLOB_MATCHES = 100;
-export const MAX_GLOB_MATCHES = 1000;
-export async function searchTargets(dir, roots, { realpath, deny }) {
-    if (typeof dir === 'string' && dir.trim()) {
-        const resolved = await resolveKey(dir, roots, { realpath, deny });
-        if ('error' in resolved) {
-            return resolved;
-        }
-        if (resolved.root.kind === 'local') {
-            if (!resolved.exists) {
-                return { error: `no such file: ${dir}` };
-            }
-        }
-        else {
-            let hasEntry = false;
-            for await (const _entry of resolved.root.drive.list(resolved.key)) {
-                hasEntry = true;
-                break;
-            }
-            if (!hasEntry && (await resolved.root.drive.entry(resolved.key)) === null) {
-                return { error: `no such file: ${dir}` };
-            }
-        }
-        return { targets: [{ root: resolved.root, folder: resolved.key }] };
-    }
-    if (roots.length === 0) {
-        return { error: NO_DIRS_GRANTED };
-    }
-    return { targets: roots.map((root) => ({ root, folder: '/' })) };
-}
-export function relativeKey(key, folder) {
-    return folder === '/' ? key.slice(1) : key.slice(folder.length + 1);
-}
-export function createFileGlobTool({ realpath = defaultRealpath, deniedRoots } = {}) {
-    return {
-        name: 'file_glob',
-        toolset: 'files',
-        description: 'List files matching a glob pattern inside the granted directories. ' +
-            'Use ** to cross directories (e.g. "**/*.ts"). Returns absolute paths. ' +
-            'Symlinks are never followed; skippedLinks counts the ones left out.',
-        parameters: {
-            type: 'object',
-            properties: {
-                pattern: { type: 'string', description: 'Glob pattern relative to the searched directory' },
-                dir: {
-                    type: 'string',
-                    description: 'Optional directory to search (default: every granted directory)'
-                },
-                limit: {
-                    type: 'number',
-                    description: `Optional match cap (default ${DEFAULT_GLOB_MATCHES}, max ${MAX_GLOB_MATCHES})`
-                }
-            },
-            required: ['pattern']
-        },
-        effect: () => 'read',
-        stableRead: true,
-        autoApprove: true,
-        rootsRequired: true,
-        validate(rawArgs) {
-            if (typeof rawArgs.pattern !== 'string' || !rawArgs.pattern.trim()) {
-                return 'pattern is required';
-            }
-            const limit = rawArgs.limit;
-            if (limit !== undefined && limit !== null) {
-                const n = Number(limit);
-                if (!Number.isInteger(n) || n <= 0 || n > MAX_GLOB_MATCHES) {
-                    return `limit must be a positive integer ≤ ${MAX_GLOB_MATCHES}`;
-                }
-            }
-            return null;
-        },
-        resource(args) {
-            const pattern = String(args.pattern ?? '').trim();
-            return pattern ? { kind: 'file', label: `glob ${pattern}` } : null;
-        },
-        async execute(rawArgs, ctx) {
-            const roots = ctx?.fsRoots ?? [];
-            const pattern = String(rawArgs.pattern ?? '').trim();
-            if (!pattern) {
-                return { error: 'pattern is required' };
-            }
-            const limit = rawArgs.limit ? Number(rawArgs.limit) : DEFAULT_GLOB_MATCHES;
-            const deny = await canonicalDenyRoots(deniedRoots, realpath);
-            const scoped = await searchTargets(rawArgs.dir, roots, { realpath, deny });
-            if ('error' in scoped) {
-                return scoped;
-            }
-            const match = compileGlob(pattern);
-            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;
-                    if (!match(relativeKey(file.key, target.folder)))
-                        continue;
-                    matches.push(file.path);
-                    if (matches.length >= limit) {
-                        return { matches, truncated: true, skippedLinks: skippedLinks || undefined };
-                    }
-                }
-            }
-            return {
-                matches,
-                truncated: truncated || undefined,
-                skippedLinks: skippedLinks || undefined
-            };
-        }
-    };
-}

package/dist-lib/lib/tools/grep.d.ts

@@ -1,5 +0,0 @@
-import type { ToolDefinition } from '../capabilities/completion.ts';
-import { type FsToolOptions } from './fs/scope.ts';
-export declare const DEFAULT_GREP_MATCHES = 200;
-export declare const MAX_GREP_MATCHES = 1000;
-export declare function createGrepTool({ realpath, deniedRoots }?: FsToolOptions): ToolDefinition;

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;