shortcutxl 0.2.0

package/dist/core/tools/find.js

@@ -0,0 +1,208 @@
+import { Type } from '@sinclair/typebox';
+import { spawnSync } from 'child_process';
+import { ABORT_AGENT_MESSAGE } from '../abort.js';
+import { existsSync } from 'fs';
+import { globSync } from 'glob';
+import path from 'path';
+import { FIND } from '../../tool-names.js';
+import { ensureTool } from '../../utils/tools-manager.js';
+import { resolveToCwd } from './path-utils.js';
+import { DEFAULT_MAX_CHARS, formatSize, truncateHead } from './truncate.js';
+const findSchema = Type.Object({
+    pattern: Type.String({
+        description: "Glob pattern to match files, e.g. '*.ts', '**/*.json', or 'src/**/*.spec.ts'"
+    }),
+    path: Type.Optional(Type.String({ description: 'Directory to search in (default: current directory)' })),
+    limit: Type.Optional(Type.Number({ description: 'Maximum number of results (default: 1000)' }))
+});
+const DEFAULT_LIMIT = 1000;
+const defaultFindOperations = {
+    exists: existsSync,
+    glob: (_pattern, _searchCwd, _options) => {
+        // This is a placeholder - actual fd execution happens in execute
+        return [];
+    }
+};
+export function createFindTool(cwd, options) {
+    const customOps = options?.operations;
+    return {
+        name: FIND,
+        label: FIND,
+        description: `Search for files by glob pattern. Returns matching file paths relative to the search directory. Respects .gitignore. Output is truncated to ${DEFAULT_LIMIT} results or ${DEFAULT_MAX_CHARS} characters (whichever is hit first).`,
+        parameters: findSchema,
+        execute: async (_toolCallId, { pattern, path: searchDir, limit }, signal) => {
+            return new Promise((resolve, reject) => {
+                if (signal?.aborted) {
+                    reject(new Error(ABORT_AGENT_MESSAGE));
+                    return;
+                }
+                const onAbort = () => reject(new Error(ABORT_AGENT_MESSAGE));
+                signal?.addEventListener('abort', onAbort, { once: true });
+                (async () => {
+                    try {
+                        const searchPath = resolveToCwd(searchDir || '.', cwd);
+                        const effectiveLimit = limit ?? DEFAULT_LIMIT;
+                        const ops = customOps ?? defaultFindOperations;
+                        // If custom operations provided with glob, use that
+                        if (customOps?.glob) {
+                            if (!(await ops.exists(searchPath))) {
+                                reject(new Error(`Path not found: ${searchPath}`));
+                                return;
+                            }
+                            const results = await ops.glob(pattern, searchPath, {
+                                ignore: ['**/node_modules/**', '**/.git/**'],
+                                limit: effectiveLimit
+                            });
+                            signal?.removeEventListener('abort', onAbort);
+                            if (results.length === 0) {
+                                resolve({
+                                    content: [{ type: 'text', text: 'No files found matching pattern' }],
+                                    details: undefined
+                                });
+                                return;
+                            }
+                            // Relativize paths
+                            const relativized = results.map((p) => {
+                                if (p.startsWith(searchPath)) {
+                                    return p.slice(searchPath.length + 1);
+                                }
+                                return path.relative(searchPath, p);
+                            });
+                            const resultLimitReached = relativized.length >= effectiveLimit;
+                            const rawOutput = relativized.join('\n');
+                            const truncation = truncateHead(rawOutput);
+                            let resultOutput = truncation.content;
+                            const details = {};
+                            const notices = [];
+                            if (resultLimitReached) {
+                                notices.push(`${effectiveLimit} results limit reached`);
+                                details.resultLimitReached = effectiveLimit;
+                            }
+                            if (truncation.truncated) {
+                                notices.push(`${formatSize(DEFAULT_MAX_CHARS)} limit reached`);
+                                details.truncation = truncation;
+                            }
+                            if (notices.length > 0) {
+                                resultOutput += `\n\n[${notices.join('. ')}]`;
+                            }
+                            resolve({
+                                content: [{ type: 'text', text: resultOutput }],
+                                details: Object.keys(details).length > 0 ? details : undefined
+                            });
+                            return;
+                        }
+                        // Default: use fd
+                        const fdPath = await ensureTool('fd', true);
+                        if (!fdPath) {
+                            reject(new Error('fd is not available and could not be downloaded'));
+                            return;
+                        }
+                        // Build fd arguments
+                        const args = [
+                            '--glob',
+                            '--color=never',
+                            '--hidden',
+                            '--max-results',
+                            String(effectiveLimit)
+                        ];
+                        // Include .gitignore files
+                        const gitignoreFiles = new Set();
+                        const rootGitignore = path.join(searchPath, '.gitignore');
+                        if (existsSync(rootGitignore)) {
+                            gitignoreFiles.add(rootGitignore);
+                        }
+                        try {
+                            const nestedGitignores = globSync('**/.gitignore', {
+                                cwd: searchPath,
+                                dot: true,
+                                absolute: true,
+                                ignore: ['**/node_modules/**', '**/.git/**']
+                            });
+                            for (const file of nestedGitignores) {
+                                gitignoreFiles.add(file);
+                            }
+                        }
+                        catch {
+                            // Ignore glob errors
+                        }
+                        for (const gitignorePath of gitignoreFiles) {
+                            args.push('--ignore-file', gitignorePath);
+                        }
+                        args.push(pattern, searchPath);
+                        const result = spawnSync(fdPath, args, {
+                            encoding: 'utf-8',
+                            maxBuffer: 10 * 1024 * 1024
+                        });
+                        signal?.removeEventListener('abort', onAbort);
+                        if (result.error) {
+                            reject(new Error(`Failed to run fd: ${result.error.message}`));
+                            return;
+                        }
+                        const output = result.stdout?.trim() || '';
+                        if (result.status !== 0) {
+                            const errorMsg = result.stderr?.trim() || `fd exited with code ${result.status}`;
+                            if (!output) {
+                                reject(new Error(errorMsg));
+                                return;
+                            }
+                        }
+                        if (!output) {
+                            resolve({
+                                content: [{ type: 'text', text: 'No files found matching pattern' }],
+                                details: undefined
+                            });
+                            return;
+                        }
+                        const lines = output.split('\n');
+                        const relativized = [];
+                        for (const rawLine of lines) {
+                            const line = rawLine.replace(/\r$/, '').trim();
+                            if (!line)
+                                continue;
+                            const hadTrailingSlash = line.endsWith('/') || line.endsWith('\\');
+                            let relativePath = line;
+                            if (line.startsWith(searchPath)) {
+                                relativePath = line.slice(searchPath.length + 1);
+                            }
+                            else {
+                                relativePath = path.relative(searchPath, line);
+                            }
+                            if (hadTrailingSlash && !relativePath.endsWith('/')) {
+                                relativePath += '/';
+                            }
+                            relativized.push(relativePath);
+                        }
+                        const resultLimitReached = relativized.length >= effectiveLimit;
+                        const rawOutput = relativized.join('\n');
+                        const truncation = truncateHead(rawOutput);
+                        let resultOutput = truncation.content;
+                        const details = {};
+                        const notices = [];
+                        if (resultLimitReached) {
+                            notices.push(`${effectiveLimit} results limit reached. Use limit=${effectiveLimit * 2} for more, or refine pattern`);
+                            details.resultLimitReached = effectiveLimit;
+                        }
+                        if (truncation.truncated) {
+                            notices.push(`${formatSize(DEFAULT_MAX_CHARS)} limit reached`);
+                            details.truncation = truncation;
+                        }
+                        if (notices.length > 0) {
+                            resultOutput += `\n\n[${notices.join('. ')}]`;
+                        }
+                        resolve({
+                            content: [{ type: 'text', text: resultOutput }],
+                            details: Object.keys(details).length > 0 ? details : undefined
+                        });
+                    }
+                    catch (e) {
+                        signal?.removeEventListener('abort', onAbort);
+                        reject(e);
+                    }
+                })();
+            });
+        }
+    };
+}
+/** Default find tool using process.cwd() - for backwards compatibility */
+export const findTool = createFindTool(process.cwd());
+//# sourceMappingURL=find.js.map

package/dist/core/tools/grep.js

@@ -0,0 +1,246 @@
+import { Type } from '@sinclair/typebox';
+import { ABORT_AGENT_MESSAGE } from '../abort.js';
+import { spawn } from 'child_process';
+import { readFileSync, statSync } from 'fs';
+import { createInterface } from 'node:readline';
+import path from 'path';
+import { GREP } from '../../tool-names.js';
+import { ensureTool } from '../../utils/tools-manager.js';
+import { resolveToCwd } from './path-utils.js';
+import { DEFAULT_MAX_CHARS, formatSize, GREP_MAX_LINE_LENGTH, truncateHead, truncateLine } from './truncate.js';
+const grepSchema = Type.Object({
+    pattern: Type.String({ description: 'Search pattern (regex or literal string)' }),
+    path: Type.Optional(Type.String({ description: 'Directory or file to search (default: current directory)' })),
+    glob: Type.Optional(Type.String({ description: "Filter files by glob pattern, e.g. '*.ts' or '**/*.spec.ts'" })),
+    ignoreCase: Type.Optional(Type.Boolean({ description: 'Case-insensitive search (default: false)' })),
+    literal: Type.Optional(Type.Boolean({
+        description: 'Treat pattern as literal string instead of regex (default: false)'
+    })),
+    context: Type.Optional(Type.Number({ description: 'Number of lines to show before and after each match (default: 0)' })),
+    limit: Type.Optional(Type.Number({ description: 'Maximum number of matches to return (default: 100)' }))
+});
+const DEFAULT_LIMIT = 100;
+const defaultGrepOperations = {
+    isDirectory: (p) => statSync(p).isDirectory(),
+    readFile: (p) => readFileSync(p, 'utf-8')
+};
+export function createGrepTool(cwd, options) {
+    const customOps = options?.operations;
+    return {
+        name: GREP,
+        label: GREP,
+        description: `Search file contents for a pattern. Returns matching lines with file paths and line numbers. Respects .gitignore. Output is truncated to ${DEFAULT_LIMIT} matches or ${DEFAULT_MAX_CHARS} characters (whichever is hit first). Long lines are truncated to ${GREP_MAX_LINE_LENGTH} chars.`,
+        parameters: grepSchema,
+        execute: async (_toolCallId, { pattern, path: searchDir, glob, ignoreCase, literal, context, limit }, signal) => {
+            return new Promise((resolve, reject) => {
+                if (signal?.aborted) {
+                    reject(new Error(ABORT_AGENT_MESSAGE));
+                    return;
+                }
+                let settled = false;
+                const settle = (fn) => {
+                    if (!settled) {
+                        settled = true;
+                        fn();
+                    }
+                };
+                (async () => {
+                    try {
+                        const rgPath = await ensureTool('rg', true);
+                        if (!rgPath) {
+                            settle(() => reject(new Error('ripgrep (rg) is not available and could not be downloaded')));
+                            return;
+                        }
+                        const searchPath = resolveToCwd(searchDir || '.', cwd);
+                        const ops = customOps ?? defaultGrepOperations;
+                        let isDirectory;
+                        try {
+                            isDirectory = await ops.isDirectory(searchPath);
+                        }
+                        catch (_err) {
+                            settle(() => reject(new Error(`Path not found: ${searchPath}`)));
+                            return;
+                        }
+                        const contextValue = context && context > 0 ? context : 0;
+                        const effectiveLimit = Math.max(1, limit ?? DEFAULT_LIMIT);
+                        const formatPath = (filePath) => {
+                            if (isDirectory) {
+                                const relative = path.relative(searchPath, filePath);
+                                if (relative && !relative.startsWith('..')) {
+                                    return relative.replace(/\\/g, '/');
+                                }
+                            }
+                            return path.basename(filePath);
+                        };
+                        const fileCache = new Map();
+                        const getFileLines = async (filePath) => {
+                            let lines = fileCache.get(filePath);
+                            if (!lines) {
+                                try {
+                                    const content = await ops.readFile(filePath);
+                                    lines = content.replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n');
+                                }
+                                catch {
+                                    lines = [];
+                                }
+                                fileCache.set(filePath, lines);
+                            }
+                            return lines;
+                        };
+                        const args = ['--json', '--line-number', '--color=never', '--hidden'];
+                        if (ignoreCase) {
+                            args.push('--ignore-case');
+                        }
+                        if (literal) {
+                            args.push('--fixed-strings');
+                        }
+                        if (glob) {
+                            args.push('--glob', glob);
+                        }
+                        args.push(pattern, searchPath);
+                        const child = spawn(rgPath, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+                        const rl = createInterface({ input: child.stdout });
+                        let stderr = '';
+                        let matchCount = 0;
+                        let matchLimitReached = false;
+                        let linesTruncated = false;
+                        let aborted = false;
+                        let killedDueToLimit = false;
+                        const outputLines = [];
+                        const cleanup = () => {
+                            rl.close();
+                            signal?.removeEventListener('abort', onAbort);
+                        };
+                        const stopChild = (dueToLimit = false) => {
+                            if (!child.killed) {
+                                killedDueToLimit = dueToLimit;
+                                child.kill();
+                            }
+                        };
+                        const onAbort = () => {
+                            aborted = true;
+                            stopChild();
+                        };
+                        signal?.addEventListener('abort', onAbort, { once: true });
+                        child.stderr?.on('data', (chunk) => {
+                            stderr += chunk.toString();
+                        });
+                        const formatBlock = async (filePath, lineNumber) => {
+                            const relativePath = formatPath(filePath);
+                            const lines = await getFileLines(filePath);
+                            if (!lines.length) {
+                                return [`${relativePath}:${lineNumber}: (unable to read file)`];
+                            }
+                            const block = [];
+                            const start = contextValue > 0 ? Math.max(1, lineNumber - contextValue) : lineNumber;
+                            const end = contextValue > 0 ? Math.min(lines.length, lineNumber + contextValue) : lineNumber;
+                            for (let current = start; current <= end; current++) {
+                                const lineText = lines[current - 1] ?? '';
+                                const sanitized = lineText.replace(/\r/g, '');
+                                const isMatchLine = current === lineNumber;
+                                // Truncate long lines
+                                const { text: truncatedText, wasTruncated } = truncateLine(sanitized);
+                                if (wasTruncated) {
+                                    linesTruncated = true;
+                                }
+                                if (isMatchLine) {
+                                    block.push(`${relativePath}:${current}: ${truncatedText}`);
+                                }
+                                else {
+                                    block.push(`${relativePath}-${current}- ${truncatedText}`);
+                                }
+                            }
+                            return block;
+                        };
+                        // Collect matches during streaming, format after
+                        const matches = [];
+                        rl.on('line', (line) => {
+                            if (!line.trim() || matchCount >= effectiveLimit) {
+                                return;
+                            }
+                            let event;
+                            try {
+                                event = JSON.parse(line);
+                            }
+                            catch {
+                                return;
+                            }
+                            if (event.type === 'match') {
+                                matchCount++;
+                                const filePath = event.data?.path?.text;
+                                const lineNumber = event.data?.line_number;
+                                if (filePath && typeof lineNumber === 'number') {
+                                    matches.push({ filePath, lineNumber });
+                                }
+                                if (matchCount >= effectiveLimit) {
+                                    matchLimitReached = true;
+                                    stopChild(true);
+                                }
+                            }
+                        });
+                        child.on('error', (error) => {
+                            cleanup();
+                            settle(() => reject(new Error(`Failed to run ripgrep: ${error.message}`)));
+                        });
+                        child.on('close', async (code) => {
+                            cleanup();
+                            if (aborted) {
+                                settle(() => reject(new Error(ABORT_AGENT_MESSAGE)));
+                                return;
+                            }
+                            if (!killedDueToLimit && code !== 0 && code !== 1) {
+                                const errorMsg = stderr.trim() || `ripgrep exited with code ${code}`;
+                                settle(() => reject(new Error(errorMsg)));
+                                return;
+                            }
+                            if (matchCount === 0) {
+                                settle(() => resolve({
+                                    content: [{ type: 'text', text: 'No matches found' }],
+                                    details: undefined
+                                }));
+                                return;
+                            }
+                            // Format matches (async to support remote file reading)
+                            for (const match of matches) {
+                                const block = await formatBlock(match.filePath, match.lineNumber);
+                                outputLines.push(...block);
+                            }
+                            // Apply byte truncation (no line limit since we already have match limit)
+                            const rawOutput = outputLines.join('\n');
+                            const truncation = truncateHead(rawOutput);
+                            let output = truncation.content;
+                            const details = {};
+                            // Build notices
+                            const notices = [];
+                            if (matchLimitReached) {
+                                notices.push(`${effectiveLimit} matches limit reached. Use limit=${effectiveLimit * 2} for more, or refine pattern`);
+                                details.matchLimitReached = effectiveLimit;
+                            }
+                            if (truncation.truncated) {
+                                notices.push(`${formatSize(DEFAULT_MAX_CHARS)} limit reached`);
+                                details.truncation = truncation;
+                            }
+                            if (linesTruncated) {
+                                notices.push(`Some lines truncated to ${GREP_MAX_LINE_LENGTH} chars. Use read tool to see full lines`);
+                                details.linesTruncated = true;
+                            }
+                            if (notices.length > 0) {
+                                output += `\n\n[${notices.join('. ')}]`;
+                            }
+                            settle(() => resolve({
+                                content: [{ type: 'text', text: output }],
+                                details: Object.keys(details).length > 0 ? details : undefined
+                            }));
+                        });
+                    }
+                    catch (err) {
+                        settle(() => reject(err));
+                    }
+                })();
+            });
+        }
+    };
+}
+/** Default grep tool using process.cwd() - for backwards compatibility */
+export const grepTool = createGrepTool(process.cwd());
+//# sourceMappingURL=grep.js.map

package/dist/core/tools/index.js

@@ -0,0 +1,67 @@
+export { bashTool, createBashTool } from './bash.js';
+export { createEditTool, editTool } from './edit.js';
+export { createFindTool, findTool } from './find.js';
+export { createGrepTool, grepTool } from './grep.js';
+export { createLsTool, lsTool } from './ls.js';
+export { createReadTool, readTool } from './read.js';
+export { DEFAULT_MAX_CHARS, formatSize, truncateHead, truncateLine, truncateOutput } from './truncate.js';
+export { createWriteTool, writeTool } from './write.js';
+import { bashTool, createBashTool } from './bash.js';
+import { createEditTool, editTool } from './edit.js';
+import { createFindTool, findTool } from './find.js';
+import { createGrepTool, grepTool } from './grep.js';
+import { createLsTool, lsTool } from './ls.js';
+import { createReadTool, readTool } from './read.js';
+import { createWriteTool, writeTool } from './write.js';
+// Default tools for full access mode (using process.cwd())
+export const codingTools = [readTool, bashTool, editTool, writeTool];
+// Read-only tools for exploration without modification (using process.cwd())
+export const readOnlyTools = [readTool, grepTool, findTool, lsTool];
+import { BASH, EDIT, FIND, GREP, LS, READ, WRITE } from '../../tool-names.js';
+// All available tools (using process.cwd())
+export const allTools = {
+    [READ]: readTool,
+    [BASH]: bashTool,
+    [EDIT]: editTool,
+    [WRITE]: writeTool,
+    [GREP]: grepTool,
+    [FIND]: findTool,
+    [LS]: lsTool
+};
+/**
+ * Create coding tools configured for a specific working directory.
+ */
+export function createCodingTools(cwd, options) {
+    return [
+        createReadTool(cwd, options?.read),
+        createBashTool(cwd, options?.bash),
+        createEditTool(cwd),
+        createWriteTool(cwd)
+    ];
+}
+/**
+ * Create read-only tools configured for a specific working directory.
+ */
+export function createReadOnlyTools(cwd, options) {
+    return [
+        createReadTool(cwd, options?.read),
+        createGrepTool(cwd),
+        createFindTool(cwd),
+        createLsTool(cwd)
+    ];
+}
+/**
+ * Create all tools configured for a specific working directory.
+ */
+export function createAllTools(cwd, options) {
+    return {
+        [READ]: createReadTool(cwd, options?.read),
+        [BASH]: createBashTool(cwd, options?.bash),
+        [EDIT]: createEditTool(cwd),
+        [WRITE]: createWriteTool(cwd),
+        [GREP]: createGrepTool(cwd),
+        [FIND]: createFindTool(cwd),
+        [LS]: createLsTool(cwd)
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/core/tools/ls.js

@@ -0,0 +1,123 @@
+import { Type } from '@sinclair/typebox';
+import { existsSync, readdirSync, statSync } from 'fs';
+import nodePath from 'path';
+import { ABORT_AGENT_MESSAGE } from '../abort.js';
+import { LS } from '../../tool-names.js';
+import { resolveToCwd } from './path-utils.js';
+import { DEFAULT_MAX_CHARS, formatSize, truncateHead } from './truncate.js';
+const lsSchema = Type.Object({
+    path: Type.Optional(Type.String({ description: 'Directory to list (default: current directory)' })),
+    limit: Type.Optional(Type.Number({ description: 'Maximum number of entries to return (default: 500)' }))
+});
+const DEFAULT_LIMIT = 500;
+const defaultLsOperations = {
+    exists: existsSync,
+    stat: statSync,
+    readdir: readdirSync
+};
+export function createLsTool(cwd, options) {
+    const ops = options?.operations ?? defaultLsOperations;
+    return {
+        name: LS,
+        label: LS,
+        description: `List directory contents. Returns entries sorted alphabetically, with '/' suffix for directories. Includes dotfiles. Output is truncated to ${DEFAULT_LIMIT} entries or ${DEFAULT_MAX_CHARS} characters (whichever is hit first).`,
+        parameters: lsSchema,
+        execute: async (_toolCallId, { path, limit }, signal) => {
+            return new Promise((resolve, reject) => {
+                if (signal?.aborted) {
+                    reject(new Error(ABORT_AGENT_MESSAGE));
+                    return;
+                }
+                const onAbort = () => reject(new Error(ABORT_AGENT_MESSAGE));
+                signal?.addEventListener('abort', onAbort, { once: true });
+                (async () => {
+                    try {
+                        const dirPath = resolveToCwd(path || '.', cwd);
+                        const effectiveLimit = limit ?? DEFAULT_LIMIT;
+                        // Check if path exists
+                        if (!(await ops.exists(dirPath))) {
+                            reject(new Error(`Path not found: ${dirPath}`));
+                            return;
+                        }
+                        // Check if path is a directory
+                        const stat = await ops.stat(dirPath);
+                        if (!stat.isDirectory()) {
+                            reject(new Error(`Not a directory: ${dirPath}`));
+                            return;
+                        }
+                        // Read directory entries
+                        let entries;
+                        try {
+                            entries = await ops.readdir(dirPath);
+                        }
+                        catch (e) {
+                            reject(new Error(`Cannot read directory: ${e.message}`));
+                            return;
+                        }
+                        // Sort alphabetically (case-insensitive)
+                        entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+                        // Format entries with directory indicators
+                        const results = [];
+                        let entryLimitReached = false;
+                        for (const entry of entries) {
+                            if (results.length >= effectiveLimit) {
+                                entryLimitReached = true;
+                                break;
+                            }
+                            const fullPath = nodePath.join(dirPath, entry);
+                            let suffix = '';
+                            try {
+                                const entryStat = await ops.stat(fullPath);
+                                if (entryStat.isDirectory()) {
+                                    suffix = '/';
+                                }
+                            }
+                            catch {
+                                // Skip entries we can't stat
+                                continue;
+                            }
+                            results.push(entry + suffix);
+                        }
+                        signal?.removeEventListener('abort', onAbort);
+                        if (results.length === 0) {
+                            resolve({
+                                content: [{ type: 'text', text: '(empty directory)' }],
+                                details: undefined
+                            });
+                            return;
+                        }
+                        // Apply byte truncation (no line limit since we already have entry limit)
+                        const rawOutput = results.join('\n');
+                        const truncation = truncateHead(rawOutput);
+                        let output = truncation.content;
+                        const details = {};
+                        // Build notices
+                        const notices = [];
+                        if (entryLimitReached) {
+                            notices.push(`${effectiveLimit} entries limit reached. Use limit=${effectiveLimit * 2} for more`);
+                            details.entryLimitReached = effectiveLimit;
+                        }
+                        if (truncation.truncated) {
+                            notices.push(`${formatSize(DEFAULT_MAX_CHARS)} limit reached`);
+                            details.truncation = truncation;
+                        }
+                        if (notices.length > 0) {
+                            output += `\n\n[${notices.join('. ')}]`;
+                        }
+                        resolve({
+                            content: [{ type: 'text', text: output }],
+                            details: Object.keys(details).length > 0 ? details : undefined
+                        });
+                    }
+                    catch (e) {
+                        signal?.removeEventListener('abort', onAbort);
+                        reject(e);
+                    }
+                })();
+            });
+        }
+    };
+}
+/** Default ls tool using process.cwd() - for backwards compatibility */
+export const lsTool = createLsTool(process.cwd());
+//# sourceMappingURL=ls.js.map