@cursor/july 0.1.103 → 0.1.105

package/dist/internal/filesystem/merge.js

@@ -0,0 +1,196 @@
+/**
+ * K-way merge of already-sorted streams. Each source must be ordered
+ * under the same `compare`; the merge does not re-sort a source.
+ *
+ * A binary heap of heads keeps the next yield O(log k) in the number of
+ * 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));
+            }
+        }
+    });
+}
+function pushNext(heap, head) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const next = yield 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);
+        }
+    });
+}
+/**
+ * Binary min-heap. `compare(a, b) < 0` means `a` is before `b`.
+ * Exported for the invariant tests; composers use {@link mergeSorted}.
+ */
+export class MinHeap {
+    constructor(compare) {
+        this.compare = compare;
+        this.items = [];
+    }
+    get size() {
+        return this.items.length;
+    }
+    peek() {
+        return this.items[0];
+    }
+    push(item) {
+        this.items.push(item);
+        this.bubbleUp(this.items.length - 1);
+    }
+    pop() {
+        const first = this.items[0];
+        if (first === undefined) {
+            return undefined;
+        }
+        const last = this.items.pop();
+        if (last === undefined || this.items.length === 0) {
+            return first;
+        }
+        this.items[0] = last;
+        this.bubbleDown(0);
+        return first;
+    }
+    bubbleUp(index) {
+        let current = index;
+        while (current > 0) {
+            const parent = Math.floor((current - 1) / 2);
+            const parentItem = this.items[parent];
+            const currentItem = this.items[current];
+            if (parentItem === undefined ||
+                currentItem === undefined ||
+                this.compare(currentItem, parentItem) >= 0) {
+                return;
+            }
+            this.items[parent] = currentItem;
+            this.items[current] = parentItem;
+            current = parent;
+        }
+    }
+    bubbleDown(index) {
+        let current = index;
+        for (;;) {
+            const left = current * 2 + 1;
+            const right = left + 1;
+            let smallest = current;
+            const currentItem = this.items[smallest];
+            const leftItem = this.items[left];
+            if (leftItem !== undefined &&
+                currentItem !== undefined &&
+                this.compare(leftItem, currentItem) < 0) {
+                smallest = left;
+            }
+            const smallestItem = this.items[smallest];
+            const rightItem = this.items[right];
+            if (rightItem !== undefined &&
+                smallestItem !== undefined &&
+                this.compare(rightItem, smallestItem) < 0) {
+                smallest = right;
+            }
+            if (smallest === current) {
+                return;
+            }
+            const swapCurrent = this.items[current];
+            const swapSmallest = this.items[smallest];
+            if (swapCurrent === undefined || swapSmallest === undefined) {
+                return;
+            }
+            this.items[current] = swapSmallest;
+            this.items[smallest] = swapCurrent;
+            current = smallest;
+        }
+    }
+}

package/dist/internal/filesystem/scratch.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Host `{cwd}/agent-tools/{uuid}.txt` → `/tmp/{uuid}.txt`.
+ *
+ * Native WebSearch / WebFetch still scratch large output on the host.
+ * The session engine mounts `tempFs()` at `/tmp` with `unionFs` and
+ * copies only those files onto that tree. This module is the host-path
+ * translation, not a FileSystem type.
+ */
+import type { FileSystem } from "../../filesystem.js";
+export declare const TMP_SCRATCH_PREFIX = "/tmp";
+export declare const HOST_AGENT_TOOLS_DIR = "agent-tools";
+export declare const WEB_SCRATCH_TOOLS: readonly ["webSearch", "webFetch"];
+export declare function isWebScratchTool(name: string | undefined): boolean;
+export declare function tmpScratchPath(fileName: string): string;
+export declare function hostAgentToolsDir(cwd: string): string;
+/**
+ * Basename of `{cwd}/agent-tools/{uuid}.txt`, or undefined. Other
+ * paths in a result are ignored.
+ */
+export declare function hostAgentToolsFileName(args: {
+    cwd: string;
+    candidate: string;
+}): string | undefined;
+export declare function remapScratchPath(args: {
+    cwd: string;
+    path: string;
+}): string;
+export declare function remapScratchPaths(input: Record<string, unknown>, cwd: string): Record<string, unknown>;
+export declare function rewriteWebScratchText(args: {
+    cwd: string;
+    text: string;
+}): string;
+/** Rewrite host agent-tools paths in a string or a structured tool result. */
+export declare function rewriteWebScratchValue(args: {
+    cwd: string;
+    value: unknown;
+}): unknown;
+/**
+ * WebSearch / WebFetch result. Ingest the host spill and rewrite
+ * paths onto `/tmp`. Other tools are a no-op.
+ */
+export declare function finishWebScratchTool(args: {
+    toolName: string | undefined;
+    result: unknown;
+    cwd: string;
+    root: FileSystem;
+}): Promise<unknown>;
+/** Finish a native web tool on the SDK update that carried its result. */
+export declare function applyWebScratchUpdate<T>(args: {
+    cwd: string;
+    root: FileSystem;
+    update: T;
+}): Promise<T>;
+export declare function ingestHostAgentToolsScratch(args: {
+    cwd: string;
+    root: FileSystem;
+    hostPath?: string;
+}): Promise<string[]>;
+//# sourceMappingURL=scratch.d.ts.map

package/dist/internal/filesystem/scratch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scratch.d.ts","sourceRoot":"","sources":["../../../src/internal/filesystem/scratch.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEtD,eAAO,MAAM,kBAAkB,SAAS,CAAC;AACzC,eAAO,MAAM,oBAAoB,gBAAgB,CAAC;AAClD,eAAO,MAAM,iBAAiB,YAAI,WAAW,EAAE,UAAU,CAAU,CAAC;AAEpE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAElE;AAgBD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAErD;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;CACnB,GAAG,MAAM,GAAG,SAAS,CAUrB;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAM5E;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,GAAG,EAAE,MAAM,GACV,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CASzB;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC1C,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,MAAM,CAUT;AAED,8EAA8E;AAC9E,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,OAAO,CAAC;CAChB,GAAG,OAAO,CAgBV;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CAAC,IAAI,EAAE;IAC/C,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,MAAM,EAAE,OAAO,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;CAClB,GAAG,OAAO,CAAC,OAAO,CAAC,CAMnB;AA0BD,0EAA0E;AAC1E,wBAAsB,qBAAqB,CAAC,CAAC,EAAE,IAAI,EAAE;IACnD,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;IACjB,MAAM,EAAE,CAAC,CAAC;CACX,GAAG,OAAO,CAAC,CAAC,CAAC,CAYb;AAED,wBAAsB,2BAA2B,CAAC,IAAI,EAAE;IACtD,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAiBpB"}

package/dist/internal/filesystem/scratch.js

@@ -0,0 +1,212 @@
+/**
+ * Host `{cwd}/agent-tools/{uuid}.txt` → `/tmp/{uuid}.txt`.
+ *
+ * Native WebSearch / WebFetch still scratch large output on the host.
+ * The session engine mounts `tempFs()` at `/tmp` with `unionFs` and
+ * 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";
+export const HOST_AGENT_TOOLS_DIR = "agent-tools";
+export const WEB_SCRATCH_TOOLS = ["webSearch", "webFetch"];
+export function isWebScratchTool(name) {
+    return name === "webSearch" || name === "webFetch";
+}
+const UUID_TXT = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.txt$/i;
+const HOST_FOLLOW_UP = /Use shell \/ grep \/ read_file on this path to inspect the page/g;
+const OVERLAY_FOLLOW_UP = "Use Read / Grep on this path to inspect the page";
+const PATH_KEYS = [
+    "path",
+    "dir",
+    "targetDirectory",
+    "target_directory",
+];
+export function tmpScratchPath(fileName) {
+    return `${TMP_SCRATCH_PREFIX}/${fileName}`;
+}
+export function hostAgentToolsDir(cwd) {
+    return path.resolve(cwd, HOST_AGENT_TOOLS_DIR);
+}
+/**
+ * Basename of `{cwd}/agent-tools/{uuid}.txt`, or undefined. Other
+ * paths in a result are ignored.
+ */
+export function hostAgentToolsFileName(args) {
+    if (args.candidate === "") {
+        return undefined;
+    }
+    const resolved = path.resolve(args.candidate);
+    if (path.dirname(resolved) !== hostAgentToolsDir(args.cwd)) {
+        return undefined;
+    }
+    const base = path.basename(resolved);
+    return UUID_TXT.test(base) ? base : undefined;
+}
+export function remapScratchPath(args) {
+    const fileName = hostAgentToolsFileName({
+        cwd: args.cwd,
+        candidate: args.path,
+    });
+    return fileName === undefined ? args.path : tmpScratchPath(fileName);
+}
+export function remapScratchPaths(input, cwd) {
+    const next = Object.assign({}, input);
+    for (const key of PATH_KEYS) {
+        const value = next[key];
+        if (typeof value === "string") {
+            next[key] = remapScratchPath({ cwd, path: value });
+        }
+    }
+    return next;
+}
+export function rewriteWebScratchText(args) {
+    const dir = hostAgentToolsDir(args.cwd);
+    const escaped = dir.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = new RegExp(`${escaped}[/\\\\]([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\\.txt)`, "gi");
+    return args.text
+        .replace(pattern, (_match, fileName) => tmpScratchPath(fileName))
+        .replace(HOST_FOLLOW_UP, OVERLAY_FOLLOW_UP);
+}
+/** Rewrite host agent-tools paths in a string or a structured tool result. */
+export function rewriteWebScratchValue(args) {
+    const { cwd, value } = args;
+    if (typeof value === "string") {
+        return rewriteWebScratchText({ cwd, text: value });
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => rewriteWebScratchValue({ cwd, value: item }));
+    }
+    if (value !== null && typeof value === "object") {
+        const next = {};
+        for (const [key, item] of Object.entries(value)) {
+            next[key] = rewriteWebScratchValue({ cwd, value: item });
+        }
+        return next;
+    }
+    return value;
+}
+/**
+ * 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 });
+    });
+}
+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.taskUpdate.toolCall
+            : undefined;
+    if (call === undefined || !isWebScratchTool(call.type)) {
+        return undefined;
+    }
+    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,
+        });
+        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);
+            }
+        }
+        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;
+        }
+    });
+}
+function copyHostAgentToolsFile(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        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 = 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;
+    });
+}
+function isEnoent(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "ENOENT");
+}

package/dist/internal/filesystem/sdk-schemas.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Advertised native-tool schemas. These are the `@cursor/sdk`
+ * tool-call types (`@anysphere/cursor-sdk-shared/tool-call-types`)
+ * reconstructed here so `@cursor/july` does not take an unpublished
+ * workspace dependency. The contract test pins JSON-schema equality
+ * against the SDK originals.
+ *
+ * Runtime aliases (`contents` → `fileText`, `old_string` → `oldText`)
+ * live on the `defineTool` input schema, not on these objects.
+ */
+import { z } from "zod";
+export declare const sdkReadArgs: z.ZodTypeAny;
+export declare const sdkReadResult: z.ZodTypeAny;
+export declare const sdkWriteArgs: z.ZodTypeAny;
+export declare const sdkWriteResult: z.ZodTypeAny;
+export declare const sdkDeleteArgs: z.ZodTypeAny;
+export declare const sdkDeleteResult: z.ZodTypeAny;
+export declare const sdkGlobArgs: z.ZodTypeAny;
+export declare const sdkGlobResult: z.ZodTypeAny;
+export declare const sdkGrepArgs: z.ZodTypeAny;
+export declare const sdkGrepResult: z.ZodTypeAny;
+export declare const sdkLsArgs: z.ZodTypeAny;
+export declare const sdkLsResult: z.ZodTypeAny;
+/** StrReplace is SDK `edit` plus the str-replace args the model actually sends. */
+export declare const sdkStrReplaceArgs: z.ZodTypeAny;
+export declare const sdkEditResult: z.ZodTypeAny;
+export declare const sdkSemSearchArgs: z.ZodTypeAny;
+export declare const sdkSemSearchResult: z.ZodTypeAny;
+//# sourceMappingURL=sdk-schemas.d.ts.map

package/dist/internal/filesystem/sdk-schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk-schemas.d.ts","sourceRoot":"","sources":["../../../src/internal/filesystem/sdk-schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAmBxB,eAAO,MAAM,WAAW,EAAE,CAAC,CAAC,UAE1B,CAAC;AAEH,eAAO,MAAM,aAAa,EAAE,CAAC,CAAC,UAM7B,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,CAAC,CAAC,UAI3B,CAAC;AAEH,eAAO,MAAM,cAAc,EAAE,CAAC,CAAC,UAO9B,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,CAAC,CAAC,UAE5B,CAAC;AAEH,eAAO,MAAM,eAAe,EAAE,CAAC,CAAC,UAI/B,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,CAAC,CAAC,UAG1B,CAAC;AAEH,eAAO,MAAM,aAAa,EAAE,CAAC,CAAC,UAO7B,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,CAAC,CAAC,UAe1B,CAAC;AAuCH,eAAO,MAAM,aAAa,EAAE,CAAC,CAAC,UAK7B,CAAC;AAEF,eAAO,MAAM,SAAS,EAAE,CAAC,CAAC,UAGxB,CAAC;AA0BH,eAAO,MAAM,WAAW,EAAE,CAAC,CAAC,UAI3B,CAAC;AAEF,mFAAmF;AACnF,eAAO,MAAM,iBAAiB,EAAE,CAAC,CAAC,UAKhC,CAAC;AAEH,eAAO,MAAM,aAAa,EAAE,CAAC,CAAC,UAM7B,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,CAAC,CAAC,UAI/B,CAAC;AAEH,eAAO,MAAM,kBAAkB,EAAE,CAAC,CAAC,UAIlC,CAAC"}

package/dist/internal/filesystem/sdk-schemas.js

@@ -0,0 +1,153 @@
+/**
+ * Advertised native-tool schemas. These are the `@cursor/sdk`
+ * tool-call types (`@anysphere/cursor-sdk-shared/tool-call-types`)
+ * reconstructed here so `@cursor/july` does not take an unpublished
+ * workspace dependency. The contract test pins JSON-schema equality
+ * against the SDK originals.
+ *
+ * Runtime aliases (`contents` → `fileText`, `old_string` → `oldText`)
+ * live on the `defineTool` input schema, not on these objects.
+ */
+import { z } from "zod";
+const simpleError = z.object({
+    message: z.string(),
+});
+function resultSchema(success) {
+    return z.discriminatedUnion("status", [
+        z.object({
+            status: z.literal("success"),
+            value: success,
+        }),
+        z.object({
+            status: z.literal("error"),
+            error: simpleError,
+        }),
+    ]);
+}
+export const sdkReadArgs = z.object({
+    path: z.string(),
+});
+export const sdkReadResult = resultSchema(z.object({
+    content: z.string(),
+    totalLines: z.number(),
+    fileSize: z.number(),
+}));
+export const sdkWriteArgs = z.object({
+    path: z.string(),
+    fileText: z.string(),
+    returnFileContentAfterWrite: z.boolean().optional(),
+});
+export const sdkWriteResult = resultSchema(z.object({
+    path: z.string(),
+    linesCreated: z.number(),
+    fileSize: z.number(),
+    fileContentAfterWrite: z.string().optional(),
+}));
+export const sdkDeleteArgs = z.object({
+    path: z.string(),
+});
+export const sdkDeleteResult = resultSchema(z.object({
+    fileSize: z.number(),
+}));
+export const sdkGlobArgs = z.object({
+    targetDirectory: z.string().optional(),
+    globPattern: z.string(),
+});
+export const sdkGlobResult = resultSchema(z.object({
+    files: z.array(z.string()),
+    totalFiles: z.number(),
+    clientTruncated: z.boolean(),
+    ripgrepTruncated: z.boolean(),
+}));
+export const sdkGrepArgs = z.object({
+    pattern: z.string(),
+    path: z.string().optional(),
+    glob: z.string().optional(),
+    outputMode: z.string().optional(),
+    contextBefore: z.number().optional(),
+    contextAfter: z.number().optional(),
+    context: z.number().optional(),
+    caseInsensitive: z.boolean().optional(),
+    type: z.string().optional(),
+    headLimit: z.number().optional(),
+    offset: z.number().optional(),
+    multiline: z.boolean().optional(),
+    sort: z.string().optional(),
+    sortAscending: z.boolean().optional(),
+});
+const grepContentMatch = z.object({
+    file: z.string(),
+    lineNumber: z.number().optional(),
+    line: z.string(),
+    beforeContext: z.array(z.string()).optional(),
+    afterContext: z.array(z.string()).optional(),
+});
+const grepFileCount = z.object({
+    file: z.string(),
+    count: z.number(),
+});
+const grepUnion = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("content"),
+        output: z.object({
+            matches: z.array(grepContentMatch),
+            totalMatches: z.number(),
+        }),
+    }),
+    z.object({
+        type: z.literal("files"),
+        output: z.object({
+            files: z.array(z.string()),
+            count: z.number(),
+        }),
+    }),
+    z.object({
+        type: z.literal("count"),
+        output: z.object({
+            counts: z.array(grepFileCount),
+            total: z.number(),
+        }),
+    }),
+]);
+export const sdkGrepResult = resultSchema(z.object({
+    workspaceResults: z.record(grepUnion).optional(),
+    activeEditorResult: grepUnion.optional(),
+}));
+export const sdkLsArgs = z.object({
+    path: z.string(),
+    ignore: z.array(z.string()).optional(),
+});
+const lsDirectoryTreeNodeFile = z.object({
+    name: z.string(),
+});
+const lsDirectoryTreeNode = z.lazy(() => z.object({
+    absPath: z.string(),
+    childrenDirs: z.array(lsDirectoryTreeNode),
+    childrenFiles: z.array(lsDirectoryTreeNodeFile),
+    childrenWereProcessed: z.boolean(),
+    fullSubtreeExtensionCounts: z.record(z.number()),
+    numFiles: z.number(),
+}));
+export const sdkLsResult = resultSchema(z.object({
+    directoryTreeRoot: lsDirectoryTreeNode,
+}));
+/** StrReplace is SDK `edit` plus the str-replace args the model actually sends. */
+export const sdkStrReplaceArgs = z.object({
+    path: z.string(),
+    oldText: z.string(),
+    newText: z.string(),
+    replaceAll: z.boolean().optional(),
+});
+export const sdkEditResult = resultSchema(z.object({
+    linesAdded: z.number().optional(),
+    linesRemoved: z.number().optional(),
+    diffString: z.string().optional(),
+}));
+export const sdkSemSearchArgs = z.object({
+    query: z.string(),
+    targetDirectories: z.array(z.string()).optional(),
+    explanation: z.string().optional(),
+});
+export const sdkSemSearchResult = resultSchema(z.object({
+    results: z.string(),
+}));