@cursor/bdk 0.2.8 → 0.2.10

package/dist/internal/filesystem/tools.js

@@ -5,22 +5,6 @@
  * Each tool is a `defineTool` whose runtime `inputSchema` accepts those
  * fields plus the native aliases the harness still sends.
  */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
 import { Buffer } from "node:buffer";
 import { minimatch } from "minimatch";
 import { z } from "zod";
@@ -80,11 +64,10 @@ export function rootFileToolsFromAuthored(tools) {
  * no-file-name allowlist means the default-on file layer.
  */
 export function hostFileToolsFromAuthored(tools) {
-    var _a;
     if (tools === undefined) {
         return undefined;
     }
-    return (_a = rootFileToolsFromAuthored(tools)) !== null && _a !== void 0 ? _a : [];
+    return rootFileToolsFromAuthored(tools) ?? [];
 }
 const HOST_DEFAULT_SYNTHESIZED_NAMES = SYNTHESIZED_FILE_SYSTEM_TOOL_NAMES.filter(name => name !== "SemanticSearch");
 /**
@@ -116,7 +99,7 @@ function aliasKeys(aliases) {
         if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
             return raw;
         }
-        const input = Object.assign({}, raw);
+        const input = { ...raw };
         for (const [from, to] of Object.entries(aliases)) {
             if (input[to] === undefined && input[from] !== undefined) {
                 input[to] = input[from];
@@ -138,7 +121,7 @@ function parseGrepOutputMode(value) {
     return "content";
 }
 function contextLineCount(specific, both) {
-    const value = specific !== null && specific !== void 0 ? specific : both;
+    const value = specific ?? both;
     if (value === undefined || !Number.isFinite(value)) {
         return 0;
     }
@@ -149,7 +132,7 @@ function compileToolGrepPattern(pattern, options) {
         const flags = `${options.caseInsensitive === true ? "i" : ""}${options.multiline === true ? "s" : ""}`;
         return new RegExp(pattern, flags === "" ? undefined : flags);
     }
-    catch (_a) {
+    catch {
         throw new InvalidGrepPatternError(pattern);
     }
 }
@@ -159,23 +142,23 @@ function compileToolGrepPattern(pattern, options) {
  * directory or omitted path uses `FileSystem.glob`, which applies the
  * mount's own root. Slash-free globs are recursive, matching line grep.
  */
-function collectMultilineGrepFiles(root, input) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const listed = yield collectListOrStat(root, input.path);
-        if (listed.kind === "file") {
-            const filePath = (_a = input.path) !== null && _a !== void 0 ? _a : "";
-            if (input.glob !== undefined && !fileMatchesGrepGlob(filePath, input.glob)) {
-                return [];
-            }
-            return [filePath];
-        }
-        if (listed.kind === "missing") {
+async function collectMultilineGrepFiles(root, input) {
+    const listed = await collectListOrStat(root, input.path);
+    if (listed.kind === "file") {
+        const filePath = input.path ?? "";
+        if (input.glob !== undefined && !fileMatchesGrepGlob(filePath, input.glob)) {
             return [];
         }
-        const entries = yield collectGlob(root, Object.assign({ pattern: recursiveGrepGlob(input.glob) }, (input.path === undefined ? {} : { dir: input.path })));
-        return entries.map(entry => entry.path);
+        return [filePath];
+    }
+    if (listed.kind === "missing") {
+        return [];
+    }
+    const entries = await collectGlob(root, {
+        pattern: recursiveGrepGlob(input.glob),
+        ...(input.path === undefined ? {} : { dir: input.path }),
     });
+    return entries.map(entry => entry.path);
 }
 function recursiveGrepGlob(glob) {
     if (glob === undefined || glob.length === 0) {
@@ -200,7 +183,6 @@ function fileMatchesGrepGlob(filePath, globPattern) {
     return false;
 }
 function multilineHitsInContent(path, content, regex) {
-    var _a;
     const global = new RegExp(regex.source, regex.flags.includes("g") ? regex.flags : `${regex.flags}g`);
     const hits = [];
     let match = global.exec(content);
@@ -208,7 +190,7 @@ function multilineHitsInContent(path, content, regex) {
         hits.push({
             path,
             lineNumber: content.slice(0, match.index).split("\n").length,
-            line: (_a = content.slice(match.index).split("\n")[0]) !== null && _a !== void 0 ? _a : "",
+            line: content.slice(match.index).split("\n")[0] ?? "",
         });
         if (match[0].length === 0) {
             global.lastIndex += 1;
@@ -217,94 +199,103 @@ function multilineHitsInContent(path, content, regex) {
     }
     return hits;
 }
-function collectMultilineGrepMatches(root, input, opts) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const regex = compileToolGrepPattern(input.pattern, {
-            caseInsensitive: input.caseInsensitive,
-            multiline: true,
-        });
-        const files = yield collectMultilineGrepFiles(root, input);
-        const matches = [];
-        const offset = opts.offset !== undefined && opts.offset > 0 ? opts.offset : 0;
-        const headLimit = opts.headLimit !== undefined && opts.headLimit > 0 ? opts.headLimit : undefined;
-        let skippedItems = 0;
-        let takenItems = 0;
-        for (const filePath of files) {
-            let content;
-            try {
-                content = yield root.read(filePath);
-            }
-            catch (_a) {
-                continue;
-            }
-            if (typeof content !== "string") {
-                continue;
-            }
-            const hits = multilineHitsInContent(filePath, content, regex);
-            if (hits.length === 0) {
-                continue;
-            }
-            if (opts.outputMode === "content") {
-                for (const hit of hits) {
-                    if (skippedItems < offset) {
-                        skippedItems++;
-                        continue;
-                    }
-                    matches.push(hit);
-                    takenItems++;
-                    if (headLimit !== undefined && takenItems >= headLimit) {
-                        return matches;
-                    }
-                }
-                continue;
-            }
-            if (skippedItems < offset) {
-                skippedItems++;
-                continue;
-            }
-            if (headLimit !== undefined && takenItems >= headLimit) {
-                break;
-            }
-            matches.push(...hits);
-            takenItems++;
-        }
-        return matches;
+async function collectMultilineGrepMatches(root, input, opts) {
+    const regex = compileToolGrepPattern(input.pattern, {
+        caseInsensitive: input.caseInsensitive,
+        multiline: true,
     });
-}
-function attachGrepContext(root, matches, context) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (context.before === 0 && context.after === 0) {
-            return matches;
+    const files = await collectMultilineGrepFiles(root, input);
+    const matches = [];
+    const offset = opts.offset !== undefined && opts.offset > 0 ? opts.offset : 0;
+    const headLimit = opts.headLimit !== undefined && opts.headLimit > 0 ? opts.headLimit : undefined;
+    let skippedItems = 0;
+    let takenItems = 0;
+    for (const filePath of files) {
+        let content;
+        try {
+            content = await root.read(filePath);
+        }
+        catch {
+            continue;
+        }
+        if (typeof content !== "string") {
+            continue;
+        }
+        const hits = multilineHitsInContent(filePath, content, regex);
+        if (hits.length === 0) {
+            continue;
         }
-        const linesByPath = new Map();
-        const hits = [];
-        for (const match of matches) {
-            let lines = linesByPath.get(match.path);
-            if (lines === undefined) {
-                try {
-                    const content = yield root.read(match.path);
-                    lines = typeof content === "string" ? content.split("\n") : [];
+        if (opts.outputMode === "content") {
+            for (const hit of hits) {
+                if (skippedItems < offset) {
+                    skippedItems++;
+                    continue;
                 }
-                catch (_a) {
-                    lines = [];
+                matches.push(hit);
+                takenItems++;
+                if (headLimit !== undefined && takenItems >= headLimit) {
+                    return matches;
                 }
-                linesByPath.set(match.path, lines);
             }
-            const index = match.lineNumber - 1;
-            hits.push(Object.assign(Object.assign(Object.assign({}, match), (context.before > 0
+            continue;
+        }
+        if (skippedItems < offset) {
+            skippedItems++;
+            continue;
+        }
+        if (headLimit !== undefined && takenItems >= headLimit) {
+            break;
+        }
+        matches.push(...hits);
+        takenItems++;
+    }
+    return matches;
+}
+async function attachGrepContext(root, matches, context) {
+    if (context.before === 0 && context.after === 0) {
+        return matches;
+    }
+    const linesByPath = new Map();
+    const hits = [];
+    for (const match of matches) {
+        let lines = linesByPath.get(match.path);
+        if (lines === undefined) {
+            try {
+                const content = await root.read(match.path);
+                lines = typeof content === "string" ? content.split("\n") : [];
+            }
+            catch {
+                lines = [];
+            }
+            linesByPath.set(match.path, lines);
+        }
+        const index = match.lineNumber - 1;
+        hits.push({
+            ...match,
+            ...(context.before > 0
                 ? {
                     beforeContext: lines.slice(Math.max(0, index - context.before), Math.max(0, index)),
                 }
-                : {})), (context.after > 0
+                : {}),
+            ...(context.after > 0
                 ? { afterContext: lines.slice(index + 1, index + 1 + context.after) }
-                : {})));
-        }
-        return hits;
-    });
+                : {}),
+        });
+    }
+    return hits;
 }
 function discovered(name, definition, contract) {
     const effect = typeof definition.effect === "function" ? "dynamic" : definition.effect;
-    return Object.assign(Object.assign({ name, description: definition.description, inputSchema: toolInputJsonSchema(contract.input), outputSchema: toolOutputJsonSchema(contract.output), execution: "server", needsApproval: false }, (effect === undefined ? {} : { effect })), { definition });
+    return {
+        name,
+        description: definition.description,
+        inputSchema: toolInputJsonSchema(contract.input),
+        outputSchema: toolOutputJsonSchema(contract.output),
+        execution: "server",
+        needsApproval: false,
+        ...(effect === undefined ? {} : { effect }),
+        definition,
+    };
 }
 const readInputSchema = z.preprocess(aliasKeys({}), z.object({
     path: z.string(),
@@ -316,40 +307,38 @@ function readTool(root) {
         description: "Reads a file from the local filesystem. This tool can also read image files when called with the appropriate path. Formats supported: jpeg/jpg, png, gif, webp.",
         inputSchema: readInputSchema,
         effect: "read",
-        execute(_a) {
-            return __awaiter(this, arguments, void 0, function* ({ path, offset, limit }) {
-                let content;
-                try {
-                    content = yield root.read(path);
-                }
-                catch (error) {
-                    if (isFileNotFoundError(error)) {
-                        const hint = yield nearestNeighborMissHint(root, path);
-                        if (hint !== undefined) {
-                            return hint;
-                        }
+        async execute({ path, offset, limit }) {
+            let content;
+            try {
+                content = await root.read(path);
+            }
+            catch (error) {
+                if (isFileNotFoundError(error)) {
+                    const hint = await nearestNeighborMissHint(root, path);
+                    if (hint !== undefined) {
+                        return hint;
                     }
-                    throw error;
                 }
-                const image = fileSystemImage(content, path);
-                if (image !== undefined) {
-                    return {
-                        content: [
-                            { type: "text", text: `Read image file: ${path}` },
-                            {
-                                type: "image",
-                                data: Buffer.from(image.bytes).toString("base64"),
-                                mimeType: image.mimeType,
-                            },
-                        ],
-                    };
-                }
-                const text = fileSystemText(content);
-                const totalLines = lineCount(text);
-                return formatNumberedLines(sliceReadContent(text, offset, limit), {
-                    startLine: slicedReadStartLine(totalLines, offset),
-                    totalLines,
-                });
+                throw error;
+            }
+            const image = fileSystemImage(content, path);
+            if (image !== undefined) {
+                return {
+                    content: [
+                        { type: "text", text: `Read image file: ${path}` },
+                        {
+                            type: "image",
+                            data: Buffer.from(image.bytes).toString("base64"),
+                            mimeType: image.mimeType,
+                        },
+                    ],
+                };
+            }
+            const text = fileSystemText(content);
+            const totalLines = lineCount(text);
+            return formatNumberedLines(sliceReadContent(text, offset, limit), {
+                startLine: slicedReadStartLine(totalLines, offset),
+                totalLines,
             });
         },
     }), { input: sdkReadArgs, output: sdkReadResult });
@@ -368,23 +357,21 @@ Other details:
 - The result does not display dot-files and dot-directories.`,
         inputSchema: lsInputSchema,
         effect: "read",
-        execute(_a) {
-            return __awaiter(this, arguments, void 0, function* ({ path, ignore }) {
-                const listed = yield lsFromList(root, path, ignore);
-                if (listed.status === "error") {
-                    if (listed.error.message.startsWith("Path is not a directory:")) {
-                        return `not a directory: ${path} — Read it.`;
-                    }
-                    if (listed.error.message.startsWith("Path does not exist:")) {
-                        const hint = yield nearestNeighborMissHint(root, path);
-                        if (hint !== undefined) {
-                            return hint;
-                        }
+        async execute({ path, ignore }) {
+            const listed = await lsFromList(root, path, ignore);
+            if (listed.status === "error") {
+                if (listed.error.message.startsWith("Path is not a directory:")) {
+                    return `not a directory: ${path} — Read it.`;
+                }
+                if (listed.error.message.startsWith("Path does not exist:")) {
+                    const hint = await nearestNeighborMissHint(root, path);
+                    if (hint !== undefined) {
+                        return hint;
                     }
-                    throw new Error(`Error listing directory: ${listed.error.message}`);
                 }
-                return formatLsTree(listed.value.directoryTreeRoot);
-            });
+                throw new Error(`Error listing directory: ${listed.error.message}`);
+            }
+            return formatLsTree(listed.value.directoryTreeRoot);
         },
     }), { input: sdkLsArgs, output: sdkLsResult });
 }
@@ -408,12 +395,14 @@ Tool to search for files matching a glob pattern
 `,
         inputSchema: globInputSchema,
         effect: "read",
-        execute(_a) {
-            return __awaiter(this, arguments, void 0, function* ({ globPattern, targetDirectory }) {
-                const dir = targetDirectory !== null && targetDirectory !== void 0 ? targetDirectory : "/";
-                const files = (yield collectGlob(root, Object.assign(Object.assign({ pattern: globPattern }, (targetDirectory === undefined ? {} : { dir: targetDirectory })), { limit: FILE_SYSTEM_SCAN_LIMIT }))).map(entry => entry.path);
-                return formatGlobOutput(dir, files);
-            });
+        async execute({ globPattern, targetDirectory }) {
+            const dir = targetDirectory ?? "/";
+            const files = (await collectGlob(root, {
+                pattern: globPattern,
+                ...(targetDirectory === undefined ? {} : { dir: targetDirectory }),
+                limit: FILE_SYSTEM_SCAN_LIMIT,
+            })).map(entry => entry.path);
+            return formatGlobOutput(dir, files);
         },
     }), { input: sdkGlobArgs, output: sdkGlobResult });
 }
@@ -454,21 +443,28 @@ function grepTool(root) {
         description: `A search tool built on ripgrep. Results are capped to several thousand output lines for responsiveness; when truncation occurs, the results report "at least" counts, but are otherwise accurate.`,
         inputSchema: grepInputSchema,
         effect: "read",
-        execute(input) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const outputMode = parseGrepOutputMode(input.outputMode);
-                const query = Object.assign(Object.assign(Object.assign({ pattern: input.pattern }, (input.path === undefined ? {} : { path: input.path })), (input.glob === undefined ? {} : { glob: input.glob })), { caseInsensitive: input.caseInsensitive === true });
-                const page = Object.assign(Object.assign({ outputMode }, (input.headLimit === undefined ? {} : { headLimit: input.headLimit })), (input.offset === undefined ? {} : { offset: input.offset }));
-                const matches = input.multiline === true
-                    ? yield collectMultilineGrepMatches(root, query, page)
-                    : yield collectGrepMatches(root, query, page);
-                const before = contextLineCount(input.contextBefore, input.context);
-                const after = contextLineCount(input.contextAfter, input.context);
-                const hits = outputMode === "content"
-                    ? yield attachGrepContext(root, matches, { before, after })
-                    : matches;
-                return formatGrepOutput(shapeGrepUnion(hits, outputMode));
-            });
+        async execute(input) {
+            const outputMode = parseGrepOutputMode(input.outputMode);
+            const query = {
+                pattern: input.pattern,
+                ...(input.path === undefined ? {} : { path: input.path }),
+                ...(input.glob === undefined ? {} : { glob: input.glob }),
+                caseInsensitive: input.caseInsensitive === true,
+            };
+            const page = {
+                outputMode,
+                ...(input.headLimit === undefined ? {} : { headLimit: input.headLimit }),
+                ...(input.offset === undefined ? {} : { offset: input.offset }),
+            };
+            const matches = input.multiline === true
+                ? await collectMultilineGrepMatches(root, query, page)
+                : await collectGrepMatches(root, query, page);
+            const before = contextLineCount(input.contextBefore, input.context);
+            const after = contextLineCount(input.contextAfter, input.context);
+            const hits = outputMode === "content"
+                ? await attachGrepContext(root, matches, { before, after })
+                : matches;
+            return formatGrepOutput(shapeGrepUnion(hits, outputMode));
         },
     }), { input: sdkGrepArgs, output: sdkGrepResult });
 }
@@ -482,11 +478,9 @@ function writeTool(root) {
         description: "Writes a file to the local filesystem.",
         inputSchema: writeInputSchema,
         effect: "write",
-        execute(_a) {
-            return __awaiter(this, arguments, void 0, function* ({ path, fileText }) {
-                yield root.write(path, fileText);
-                return formatWriteOutput(path);
-            });
+        async execute({ path, fileText }) {
+            await root.write(path, fileText);
+            return formatWriteOutput(path);
         },
     }), { input: sdkWriteArgs, output: sdkWriteResult });
 }
@@ -505,16 +499,17 @@ function strReplaceTool(root) {
         description: "Performs exact string replacements in files.",
         inputSchema: strReplaceInputSchema,
         effect: "write",
-        execute(_a) {
-            return __awaiter(this, arguments, void 0, function* ({ path, oldText, newText, replaceAll }) {
-                const { occurrencesModified } = yield strReplaceOnFileSystem(root, Object.assign({ path,
-                    oldText,
-                    newText }, (replaceAll === undefined ? {} : { replaceAll })));
-                return formatStrReplaceOutput({
-                    path,
-                    replaceAll: replaceAll === true,
-                    occurrencesModified,
-                });
+        async execute({ path, oldText, newText, replaceAll }) {
+            const { occurrencesModified } = await strReplaceOnFileSystem(root, {
+                path,
+                oldText,
+                newText,
+                ...(replaceAll === undefined ? {} : { replaceAll }),
+            });
+            return formatStrReplaceOutput({
+                path,
+                replaceAll: replaceAll === true,
+                occurrencesModified,
             });
         },
     }), { input: sdkStrReplaceArgs, output: sdkEditResult });
@@ -530,11 +525,9 @@ function deleteTool(root) {
     - The file cannot be deleted`,
         inputSchema: deleteInputSchema,
         effect: "write",
-        execute(_a) {
-            return __awaiter(this, arguments, void 0, function* ({ path }) {
-                yield root.delete(path);
-                return "";
-            });
+        async execute({ path }) {
+            await root.delete(path);
+            return "";
         },
     }), { input: sdkDeleteArgs, output: sdkDeleteResult });
 }
@@ -549,31 +542,20 @@ function semanticSearchTool(root) {
         description: "`SemanticSearch`: semantic search that finds code by meaning, not exact text",
         inputSchema: semanticSearchInputSchema,
         effect: "read",
-        execute(_a) {
-            return __awaiter(this, arguments, void 0, function* ({ query, targetDirectories, numResults }) {
-                var _b, e_1, _c, _d;
-                const cap = numResults !== undefined && numResults > 0 ? numResults : undefined;
-                const hits = [];
-                try {
-                    for (var _e = true, _f = __asyncValues(root.search(Object.assign(Object.assign({ query }, (targetDirectories === undefined ? {} : { targetDirectories })), (cap === undefined ? {} : { maxResults: cap })))), _g; _g = yield _f.next(), _b = _g.done, !_b; _e = true) {
-                        _d = _g.value;
-                        _e = false;
-                        const hit = _d;
-                        hits.push(hit);
-                        if (cap !== undefined && hits.length >= cap) {
-                            break;
-                        }
-                    }
-                }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (!_e && !_b && (_c = _f.return)) yield _c.call(_f);
-                    }
-                    finally { if (e_1) throw e_1.error; }
+        async execute({ query, targetDirectories, numResults }) {
+            const cap = numResults !== undefined && numResults > 0 ? numResults : undefined;
+            const hits = [];
+            for await (const hit of root.search({
+                query,
+                ...(targetDirectories === undefined ? {} : { targetDirectories }),
+                ...(cap === undefined ? {} : { maxResults: cap }),
+            })) {
+                hits.push(hit);
+                if (cap !== undefined && hits.length >= cap) {
+                    break;
                 }
-                return hits.map(hit => `${hit.path}: ${hit.snippet}`).join("\n");
-            });
+            }
+            return hits.map(hit => `${hit.path}: ${hit.snippet}`).join("\n");
         },
     }), { input: sdkSemSearchArgs, output: sdkSemSearchResult });
 }
@@ -603,22 +585,20 @@ export function fileSystemTool(root, name, input = {}) {
     return FILE_SYSTEM_TOOL_FACTORIES[canonical](root);
 }
 /** Validate and run the same tool a turn or `callTool` would. */
-export function runFileSystemTool(root_1, name_1) {
-    return __awaiter(this, arguments, void 0, function* (root, name, input = {}) {
-        const tool = fileSystemTool(root, name, input);
-        if (tool === undefined) {
-            throw new Error(`Unknown file system tool: ${name}`);
-        }
-        const execute = tool.definition.execute;
-        if (typeof execute !== "function") {
-            throw new Error(`File system tool ${name} has no execute`);
-        }
-        const validation = validateToolInput(tool.definition.inputSchema, input);
-        if (!validation.ok) {
-            throw new Error(validation.message);
-        }
-        return execute(validation.value, {});
-    });
+export async function runFileSystemTool(root, name, input = {}) {
+    const tool = fileSystemTool(root, name, input);
+    if (tool === undefined) {
+        throw new Error(`Unknown file system tool: ${name}`);
+    }
+    const execute = tool.definition.execute;
+    if (typeof execute !== "function") {
+        throw new Error(`File system tool ${name} has no execute`);
+    }
+    const validation = validateToolInput(tool.definition.inputSchema, input);
+    if (!validation.ok) {
+        throw new Error(validation.message);
+    }
+    return execute(validation.value, {});
 }
 export function synthesizeFileSystemTools(root, filter) {
     const tools = [];