@cursor/bdk 0.2.9 → 0.2.10

package/dist/internal/filesystem/merge.js

@@ -6,111 +6,69 @@
  * sources. `unique` skips later copies of a key so an earlier source can
  * shadow a later one (the union rule).
  */
-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); }
-};
-var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
-var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
-    var i, p;
-    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
-    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
-};
-var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
-    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
-    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-    function fulfill(value) { resume("next", value); }
-    function reject(value) { resume("throw", value); }
-    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-};
 /**
  * Merge already-sorted iterables / async iterables under `compare`.
  * Equal keys (`compare === 0`) keep source order: earlier `sources`
  * index wins. With `unique`, those later copies are skipped.
  */
-export function mergeSorted(sources, options) {
-    return __asyncGenerator(this, arguments, function* mergeSorted_1() {
-        const { compare, unique = false } = options;
-        const heap = new MinHeap((left, right) => {
-            const byValue = compare(left.value, right.value);
-            return byValue !== 0 ? byValue : left.source - right.source;
-        });
-        const iterators = sources.map((source, sourceIndex) => {
-            const iterator = Symbol.asyncIterator in source
-                ? source[Symbol.asyncIterator]()
-                : (function () {
-                    return __asyncGenerator(this, arguments, function* () {
-                        yield __await(yield* __asyncDelegator(__asyncValues(source)));
-                    });
-                })();
-            return { iterator, sourceIndex };
-        });
-        yield __await(Promise.all(iterators.map((_a) => __awaiter(this, [_a], void 0, function* ({ iterator, sourceIndex }) {
-            const next = yield iterator.next();
-            if (!next.done) {
-                heap.push({ value: next.value, iterator, source: sourceIndex });
-            }
-        }))));
-        while (heap.size > 0) {
-            const best = heap.pop();
-            if (best === undefined) {
-                return yield __await(void 0);
-            }
-            yield yield __await(best.value);
-            if (unique) {
-                yield __await(advanceMatching(heap, best, compare));
-            }
-            else {
-                yield __await(pushNext(heap, best));
-            }
-        }
+export async function* mergeSorted(sources, options) {
+    const { compare, unique = false } = options;
+    const heap = new MinHeap((left, right) => {
+        const byValue = compare(left.value, right.value);
+        return byValue !== 0 ? byValue : left.source - right.source;
     });
-}
-function pushNext(heap, head) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const next = yield head.iterator.next();
+    const iterators = sources.map((source, sourceIndex) => {
+        const iterator = Symbol.asyncIterator in source
+            ? source[Symbol.asyncIterator]()
+            : (async function* () {
+                yield* source;
+            })();
+        return { iterator, sourceIndex };
+    });
+    await Promise.all(iterators.map(async ({ iterator, sourceIndex }) => {
+        const next = await iterator.next();
         if (!next.done) {
-            heap.push({
-                value: next.value,
-                iterator: head.iterator,
-                source: head.source,
-            });
+            heap.push({ value: next.value, iterator, source: sourceIndex });
         }
-    });
+    }));
+    while (heap.size > 0) {
+        const best = heap.pop();
+        if (best === undefined) {
+            return;
+        }
+        yield best.value;
+        if (unique) {
+            await advanceMatching(heap, best, compare);
+        }
+        else {
+            await pushNext(heap, best);
+        }
+    }
+}
+async function pushNext(heap, head) {
+    const next = await head.iterator.next();
+    if (!next.done) {
+        heap.push({
+            value: next.value,
+            iterator: head.iterator,
+            source: head.source,
+        });
+    }
 }
 /** Advance every head whose key equals `best` (compare === 0). */
-function advanceMatching(heap, best, compare) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield pushNext(heap, best);
-        while (heap.size > 0) {
-            const peek = heap.peek();
-            if (peek === undefined || compare(peek.value, best.value) !== 0) {
-                return;
-            }
-            const duplicate = heap.pop();
-            if (duplicate === undefined) {
-                return;
-            }
-            yield pushNext(heap, duplicate);
+async function advanceMatching(heap, best, compare) {
+    await pushNext(heap, best);
+    while (heap.size > 0) {
+        const peek = heap.peek();
+        if (peek === undefined || compare(peek.value, best.value) !== 0) {
+            return;
         }
-    });
+        const duplicate = heap.pop();
+        if (duplicate === undefined) {
+            return;
+        }
+        await pushNext(heap, duplicate);
+    }
 }
 /**
  * Binary min-heap. `compare(a, b) < 0` means `a` is before `b`.

package/dist/internal/filesystem/nearest.js

@@ -3,15 +3,6 @@
  * catalog API; `list(dirname(path))` is the sibling set. Immediate
  * children only — a recursive mount must not dump its whole subtree.
  */
-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());
-    });
-};
 import { posix } from "node:path";
 import { FILE_SYSTEM_SCAN_LIMIT, normalizeFsPath } from "../../filesystem.js";
 import { collectList } from "./walk.js";
@@ -42,20 +33,18 @@ export function formatMissNeighborHint(path, neighbors) {
  * One-line miss hint when the parent directory listed siblings.
  * `undefined` leaves the caller to throw the ordinary miss.
  */
-export function nearestNeighborMissHint(root, path) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const missed = normalizeFsPath(path);
-        const parent = parentDir(missed);
-        const files = yield collectList(root, parent, {
-            limit: FILE_SYSTEM_SCAN_LIMIT,
-        });
-        const names = [
-            ...new Set(files
-                .map(file => relativeToParent(file.path, parent))
-                .filter(name => name.length > 0 && !name.includes("/"))),
-        ].filter(name => name !== posix.basename(missed));
-        return formatMissNeighborHint(missed, nearestListedNames(posix.basename(missed), names));
+export async function nearestNeighborMissHint(root, path) {
+    const missed = normalizeFsPath(path);
+    const parent = parentDir(missed);
+    const files = await collectList(root, parent, {
+        limit: FILE_SYSTEM_SCAN_LIMIT,
     });
+    const names = [
+        ...new Set(files
+            .map(file => relativeToParent(file.path, parent))
+            .filter(name => name.length > 0 && !name.includes("/"))),
+    ].filter(name => name !== posix.basename(missed));
+    return formatMissNeighborHint(missed, nearestListedNames(posix.basename(missed), names));
 }
 function rankKey(name) {
     const base = posix.basename(name);
@@ -66,20 +55,19 @@ function isPrefixRelated(left, right) {
     return left.startsWith(right) || right.startsWith(left);
 }
 function editDistance(left, right) {
-    var _a, _b, _c, _d;
     const previous = Array.from({ length: right.length + 1 }, (_, index) => index);
     for (let i = 0; i < left.length; i += 1) {
         let diagonal = i;
         previous[0] = i + 1;
         for (let j = 0; j < right.length; j += 1) {
-            const insertion = ((_a = previous[j + 1]) !== null && _a !== void 0 ? _a : 0) + 1;
-            const deletion = ((_b = previous[j]) !== null && _b !== void 0 ? _b : 0) + 1;
+            const insertion = (previous[j + 1] ?? 0) + 1;
+            const deletion = (previous[j] ?? 0) + 1;
             const substitution = diagonal + (left[i] === right[j] ? 0 : 1);
-            diagonal = (_c = previous[j + 1]) !== null && _c !== void 0 ? _c : 0;
+            diagonal = previous[j + 1] ?? 0;
             previous[j + 1] = Math.min(insertion, deletion, substitution);
         }
     }
-    return (_d = previous[right.length]) !== null && _d !== void 0 ? _d : right.length;
+    return previous[right.length] ?? right.length;
 }
 function parentDir(path) {
     const dir = posix.dirname(path);

package/dist/internal/filesystem/scratch.js

@@ -6,15 +6,6 @@
  * copies only those files onto that tree. This module is the host-path
  * translation, not a FileSystem type.
  */
-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());
-    });
-};
 import { readdir, readFile, rm } from "node:fs/promises";
 import path from "node:path";
 export const TMP_SCRATCH_PREFIX = "/tmp";
@@ -56,7 +47,7 @@ export function remapScratchPath(args) {
     return fileName === undefined ? args.path : tmpScratchPath(fileName);
 }
 export function remapScratchPaths(input, cwd) {
-    const next = Object.assign({}, input);
+    const next = { ...input };
     for (const key of PATH_KEYS) {
         const value = next[key];
         if (typeof value === "string") {
@@ -95,24 +86,21 @@ export function rewriteWebScratchValue(args) {
  * WebSearch / WebFetch result. Ingest the host spill and rewrite
  * paths onto `/tmp`. Other tools are a no-op.
  */
-export function finishWebScratchTool(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!isWebScratchTool(args.toolName)) {
-            return args.result;
-        }
-        yield ingestHostAgentToolsScratch({ cwd: args.cwd, root: args.root });
-        return rewriteWebScratchValue({ cwd: args.cwd, value: args.result });
-    });
+export async function finishWebScratchTool(args) {
+    if (!isWebScratchTool(args.toolName)) {
+        return args.result;
+    }
+    await ingestHostAgentToolsScratch({ cwd: args.cwd, root: args.root });
+    return rewriteWebScratchValue({ cwd: args.cwd, value: args.result });
 }
 function completedWebToolCall(update) {
-    var _a;
     if (update === null || typeof update !== "object") {
         return undefined;
     }
     const rec = update;
     const call = rec.type === "tool-call-completed"
         ? rec.toolCall
-        : rec.type === "tool-call-delta" && ((_a = rec.taskUpdate) === null || _a === void 0 ? void 0 : _a.type) === "tool-call-completed"
+        : rec.type === "tool-call-delta" && rec.taskUpdate?.type === "tool-call-completed"
             ? rec.taskUpdate.toolCall
             : undefined;
     if (call === undefined || !isWebScratchTool(call.type)) {
@@ -121,80 +109,72 @@ function completedWebToolCall(update) {
     return call;
 }
 /** Finish a native web tool on the SDK update that carried its result. */
-export function applyWebScratchUpdate(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const call = completedWebToolCall(args.update);
-        if (call === undefined) {
-            return args.update;
-        }
-        call.result = yield finishWebScratchTool({
-            toolName: call.type,
-            result: call.result,
-            cwd: args.cwd,
-            root: args.root,
-        });
+export async function applyWebScratchUpdate(args) {
+    const call = completedWebToolCall(args.update);
+    if (call === undefined) {
         return args.update;
+    }
+    call.result = await finishWebScratchTool({
+        toolName: call.type,
+        result: call.result,
+        cwd: args.cwd,
+        root: args.root,
     });
+    return args.update;
 }
-export function ingestHostAgentToolsScratch(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const written = [];
-        const names = args.hostPath === undefined ? yield listHostAgentToolsFiles(args.cwd) : [args.hostPath];
-        for (const hostPath of names) {
-            const dest = yield copyHostAgentToolsFile({
-                cwd: args.cwd,
-                root: args.root,
-                hostPath,
-            });
-            if (dest !== undefined) {
-                written.push(dest);
-            }
+export async function ingestHostAgentToolsScratch(args) {
+    const written = [];
+    const names = args.hostPath === undefined ? await listHostAgentToolsFiles(args.cwd) : [args.hostPath];
+    for (const hostPath of names) {
+        const dest = await copyHostAgentToolsFile({
+            cwd: args.cwd,
+            root: args.root,
+            hostPath,
+        });
+        if (dest !== undefined) {
+            written.push(dest);
         }
-        return written;
-    });
+    }
+    return written;
 }
-function listHostAgentToolsFiles(cwd) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const dir = hostAgentToolsDir(cwd);
-        try {
-            const entries = yield readdir(dir, { withFileTypes: true });
-            return entries
-                .filter(entry => entry.isFile() && UUID_TXT.test(entry.name))
-                .map(entry => path.join(dir, entry.name));
-        }
-        catch (error) {
-            if (isEnoent(error)) {
-                return [];
-            }
-            throw error;
+async function listHostAgentToolsFiles(cwd) {
+    const dir = hostAgentToolsDir(cwd);
+    try {
+        const entries = await readdir(dir, { withFileTypes: true });
+        return entries
+            .filter(entry => entry.isFile() && UUID_TXT.test(entry.name))
+            .map(entry => path.join(dir, entry.name));
+    }
+    catch (error) {
+        if (isEnoent(error)) {
+            return [];
         }
-    });
+        throw error;
+    }
 }
-function copyHostAgentToolsFile(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const fileName = hostAgentToolsFileName({
-            cwd: args.cwd,
-            candidate: args.hostPath,
-        });
-        if (fileName === undefined) {
+async function copyHostAgentToolsFile(args) {
+    const fileName = hostAgentToolsFileName({
+        cwd: args.cwd,
+        candidate: args.hostPath,
+    });
+    if (fileName === undefined) {
+        return undefined;
+    }
+    const dest = tmpScratchPath(fileName);
+    const hostPath = path.resolve(args.hostPath);
+    let bytes;
+    try {
+        bytes = await readFile(hostPath);
+    }
+    catch (error) {
+        if (isEnoent(error)) {
             return undefined;
         }
-        const dest = tmpScratchPath(fileName);
-        const hostPath = path.resolve(args.hostPath);
-        let bytes;
-        try {
-            bytes = yield readFile(hostPath);
-        }
-        catch (error) {
-            if (isEnoent(error)) {
-                return undefined;
-            }
-            throw error;
-        }
-        yield args.root.write(dest, bytes.toString("utf8"));
-        yield rm(hostPath, { force: true });
-        return dest;
-    });
+        throw error;
+    }
+    await args.root.write(dest, bytes.toString("utf8"));
+    await rm(hostPath, { force: true });
+    return dest;
 }
 function isEnoent(error) {
     return (typeof error === "object" &&