@cursor/july 0.1.102 → 0.1.104

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(),
+}));

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

@@ -0,0 +1,42 @@
+/**
+ * Native file tools synthesized from a bound {@link FileSystem}.
+ *
+ * Advertised name / input / output match `@cursor/sdk` tool-call types.
+ * Each tool is a `defineTool` whose runtime `inputSchema` accepts those
+ * fields plus the native aliases the harness still sends.
+ */
+import { type FileSystem, type FileSystemToolName } from "../../filesystem.js";
+import type { DiscoveredTool } from "../../types.js";
+export declare const SYNTHESIZED_FILE_SYSTEM_TOOL_NAMES: readonly ["Read", "LS", "Glob", "Grep", "Write", "StrReplace", "Delete", "SemanticSearch"];
+export type SynthesizedFileSystemToolName = (typeof SYNTHESIZED_FILE_SYSTEM_TOOL_NAMES)[number];
+export declare function isSynthesizedFileSystemToolName(name: string): boolean;
+export declare function rootFileToolsFromAuthored(tools: readonly string[] | undefined): FileSystemToolName[] | undefined;
+/**
+ * Host-default file-tool filter. Omitted `tools` keeps the default
+ * seven-tool set (`undefined`). A listed allowlist is closed: names that
+ * are not FileSystem methods synthesize nothing, so agents that already
+ * replaced natives with authored VFS tools (`tools: ["updateTodos"]` plus
+ * `agent/tools/Delete.ts`) do not also get host-disk Delete.
+ *
+ * Authored `root` still uses {@link rootFileToolsFromAuthored}, where a
+ * no-file-name allowlist means the default-on file layer.
+ */
+export declare function hostFileToolsFromAuthored(tools: readonly string[] | undefined): FileSystemToolName[] | undefined;
+/**
+ * Names July will actually synthesize for this agent. Discovery reserves
+ * only this set, not every FileSystem alias.
+ */
+export declare function synthesizedFileSystemToolNames(options: {
+    hasRoot: boolean;
+    tools?: readonly string[];
+}): readonly SynthesizedFileSystemToolName[];
+/**
+ * Look up the `defineTool` factory for a native or allowlist name.
+ * The only name that still inspects `input` is legacy `edit`:
+ * `fileText` / `contents` selects Write, otherwise StrReplace.
+ */
+export declare function fileSystemTool(root: FileSystem, name: string, input?: Record<string, unknown>): DiscoveredTool | undefined;
+/** Validate and run the same tool a turn or `callTool` would. */
+export declare function runFileSystemTool(root: FileSystem, name: string, input?: Record<string, unknown>): Promise<unknown>;
+export declare function synthesizeFileSystemTools(root: FileSystem, filter?: readonly FileSystemToolName[]): DiscoveredTool[];
+//# sourceMappingURL=tools.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../src/internal/filesystem/tools.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,EAGL,KAAK,UAAU,EACf,KAAK,kBAAkB,EAWxB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EAAE,cAAc,EAAkB,MAAM,gBAAgB,CAAC;AAmCrE,eAAO,MAAM,kCAAkC,YAC7C,MAAM,EACN,IAAI,EACJ,MAAM,EACN,MAAM,EACN,OAAO,EACP,YAAY,EACZ,QAAQ,EACR,gBAAgB,CACR,CAAC;AAEX,MAAM,MAAM,6BAA6B,GACvC,CAAC,OAAO,kCAAkC,CAAC,CAAC,MAAM,CAAC,CAAC;AAMtD,wBAAgB,+BAA+B,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAMrE;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,GACnC,kBAAkB,EAAE,GAAG,SAAS,CAmBlC;AAED;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,GACnC,kBAAkB,EAAE,GAAG,SAAS,CAKlC;AAOD;;;GAGG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,EAAE;IACtD,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3B,GAAG,SAAS,6BAA6B,EAAE,CAW3C;AAomBD;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,MAAM,EACZ,KAAK,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAClC,cAAc,GAAG,SAAS,CAW5B;AAED,iEAAiE;AACjE,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,MAAM,EACZ,KAAK,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAClC,OAAO,CAAC,OAAO,CAAC,CAclB;AAED,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,UAAU,EAChB,MAAM,CAAC,EAAE,SAAS,kBAAkB,EAAE,GACrC,cAAc,EAAE,CAQlB"}