@cursor/july 0.1.109 → 0.1.112

package/src/internal/env-file.ts

@@ -39,7 +39,7 @@ export async function upsertEnvFile(
   for (const { key, value } of entries) {
     const next = `${key}=${value}`;
     let replaced = false;
-    for (let i = 0; i < lines.length; ) {
+    for (let i = 0; i < lines.length;) {
       if (!matchesKey(lines[i] ?? "", key)) {
         i += 1;
         continue;
@@ -71,7 +71,7 @@ export async function ensureEnvLocalGitignored(dir: string): Promise<boolean> {
   const existing = await readOptionalFile(path);
   const covered = existing
     .split(/\r?\n/)
-    .some((line) => /^\.env(\.local\*?|\.\*|\*)$/.test(line.trim()));
+    .some(line => /^\.env(\.local\*?|\.\*|\*)$/.test(line.trim()));
   if (covered) {
     return false;
   }

package/src/internal/eval-run-store.ts

@@ -87,7 +87,7 @@ export class EvalRunStore {
     await this.hydrate();
     const { evals, config } = await discoverEvals(this.projectRoot);
     return {
-      evals: evals.map((e) => ({
+      evals: evals.map(e => ({
         id: e.id,
         fileId: e.fileId,
         ...(e.definition.description === undefined
@@ -156,9 +156,7 @@ export class EvalRunStore {
     }
 
     const runId = `evalrun_${randomUUID().replace(/-/g, "").slice(0, 16)}`;
-    const cases: EvalCaseSnapshot[] = selected.map((e) =>
-      discoveredToPending(e)
-    );
+    const cases: EvalCaseSnapshot[] = selected.map(e => discoveredToPending(e));
     const snapshot: EvalRunSnapshot = {
       runId,
       status: "running",
@@ -367,12 +365,12 @@ export class EvalRunStore {
           : { bearerToken: opts.bearerToken }),
         ...(opts.verbose === undefined ? {} : { verbose: opts.verbose }),
         ...(opts.timeoutMs === undefined ? {} : { timeoutMs: opts.timeoutMs }),
-        onCaseStart: (id) => {
+        onCaseStart: id => {
           const run = this.runs.get(runId);
           if (run === undefined || run.status === "cancelled") {
             return;
           }
-          const c = run.cases.find((x) => x.id === id);
+          const c = run.cases.find(x => x.id === id);
           if (c !== undefined) {
             c.status = "running";
             c.inputs = [];
@@ -389,7 +387,7 @@ export class EvalRunStore {
           if (run === undefined) {
             return;
           }
-          const c = run.cases.find((x) => x.id === id);
+          const c = run.cases.find(x => x.id === id);
           if (c === undefined) {
             return;
           }
@@ -414,7 +412,7 @@ export class EvalRunStore {
             c.finalText = event.data.text;
           }
         },
-        onCaseDone: (result) => {
+        onCaseDone: result => {
           this.applyCaseResult(runId, result);
           const run = this.runs.get(runId);
           if (run !== undefined) {
@@ -462,7 +460,7 @@ export class EvalRunStore {
     if (run === undefined) {
       return;
     }
-    const c = run.cases.find((x) => x.id === result.id);
+    const c = run.cases.find(x => x.id === result.id);
     if (c === undefined) {
       return;
     }

package/src/internal/eval-runner.ts

@@ -256,17 +256,17 @@ export function filterDiscoveredEvals(
 ): DiscoveredEval[] {
   let selected = evals as DiscoveredEval[];
   if (options.filterIds !== undefined && options.filterIds.length > 0) {
-    selected = selected.filter((e) =>
-      options.filterIds!.some((f) => matchesEvalIdFilter(e.id, f))
+    selected = selected.filter(e =>
+      options.filterIds!.some(f => matchesEvalIdFilter(e.id, f))
     );
   }
   if (options.tags !== undefined && options.tags.length > 0) {
-    selected = selected.filter((e) =>
-      (e.definition.tags ?? []).some((t) => options.tags!.includes(t))
+    selected = selected.filter(e =>
+      (e.definition.tags ?? []).some(t => options.tags!.includes(t))
     );
   }
   // Suite aggregators (`summary` tag) need sibling cases from the same file.
-  return expandSummarySuiteSelection(evals, selected, (e) =>
+  return expandSummarySuiteSelection(evals, selected, e =>
     isEvalSummaryCase(e.definition.tags)
   );
 }
@@ -314,7 +314,7 @@ export async function runDiscoveredEvals(
   const nested = await mapPool(
     groups,
     maxConcurrency,
-    async (group) => {
+    async group => {
       const results: EvalRunResult[] = [];
       for (const discovered of group) {
         if (options.signal?.aborted) {
@@ -335,7 +335,7 @@ export async function runDiscoveredEvals(
             configModel: config.judge?.model,
             caller: options.judgeCaller ?? callJudgeModel,
           },
-          onEvent: (event) => {
+          onEvent: event => {
             options.onCaseEvent?.(discovered.id, event);
             options.onEvent?.(event);
           },
@@ -392,7 +392,7 @@ function buildReporterHub(
   ];
   const perEval = skip
     ? []
-    : selected.flatMap((e) => e.definition.reporters ?? []);
+    : selected.flatMap(e => e.definition.reporters ?? []);
   const everyReporter = [...new Set([...runWide, ...perEval])];
   if (everyReporter.length === 0) {
     return undefined;
@@ -406,7 +406,7 @@ function buildReporterHub(
   return {
     async runStart(evals, target) {
       await all.onRunStart?.(
-        evals.map((e) => ({
+        evals.map(e => ({
           id: e.id,
           fileId: e.fileId,
           description: e.definition.description,
@@ -466,7 +466,7 @@ export function groupEvalsForIterationSchedule(
     }
     group.push(discovered);
   }
-  return order.map((key) => {
+  return order.map(key => {
     const group = groups.get(key)!;
     return group.sort(
       (a, b) => (a.definition.iteration ?? 1) - (b.definition.iteration ?? 1)
@@ -523,13 +523,13 @@ async function runOneEval(
   let reply: string | null = null;
 
   const toolsUsed = (): string[] =>
-    buildTrajectory(allEvents).turns.flatMap((t) =>
-      t.toolCalls.map((c) => c.toolName)
+    buildTrajectory(allEvents).turns.flatMap(t =>
+      t.toolCalls.map(c => c.toolName)
     );
 
   const toolCallIo = () =>
-    buildTrajectory(allEvents).turns.flatMap((turn) =>
-      turn.toolCalls.map((c) => ({
+    buildTrajectory(allEvents).turns.flatMap(turn =>
+      turn.toolCalls.map(c => ({
         toolName: c.toolName,
         ...(c.args === undefined ? {} : { args: c.args }),
         ...(c.output === undefined ? {} : { output: c.output }),
@@ -583,8 +583,8 @@ async function runOneEval(
 
   const judge = createJudgeSurface({
     recorder,
-    grader: (name) => EVAL_JUDGE_GRADERS[name],
-    resolveModel: (callModel) =>
+    grader: name => EVAL_JUDGE_GRADERS[name],
+    resolveModel: callModel =>
       resolveJudgeModel({
         call: callModel,
         evalLevel: def.judge?.model,
@@ -593,7 +593,7 @@ async function runOneEval(
       }),
     caller: opts.judge.caller,
     defaultValue: () => reply,
-    onUnavailable: (message) => {
+    onUnavailable: message => {
       judgeUnavailable = judgeUnavailable ?? message;
     },
   });
@@ -663,15 +663,15 @@ async function runOneEval(
         message: result.trajectory.finalText,
         sessionId: result.sessionId,
         events: turnEvents,
-        toolCalls: result.trajectory.turns.flatMap((turn) =>
-          turn.toolCalls.map((c) => c.toolName)
+        toolCalls: result.trajectory.turns.flatMap(turn =>
+          turn.toolCalls.map(c => c.toolName)
         ),
         ok: result.ok,
         index,
         expectOk() {
           if (!result.ok) {
             throw new Error(
-              `turn[${index}] failed: ${result.trajectory.turns.find((x) => x.failed)?.error ?? "unknown error"}`
+              `turn[${index}] failed: ${result.trajectory.turns.find(x => x.failed)?.error ?? "unknown error"}`
             );
           }
           return turn;

package/src/internal/evals-client.ts

@@ -165,17 +165,17 @@ export async function listRemoteEvals(args: {
 
   let selected = listed;
   if (args.filterIds !== undefined && args.filterIds.length > 0) {
-    selected = selected.filter((e) =>
-      args.filterIds!.some((f) => matchesEvalIdFilter(e.id, f))
+    selected = selected.filter(e =>
+      args.filterIds!.some(f => matchesEvalIdFilter(e.id, f))
     );
   }
   if (args.tags !== undefined && args.tags.length > 0) {
-    selected = selected.filter((e) =>
-      (e.tags ?? []).some((t) => args.tags!.includes(t))
+    selected = selected.filter(e =>
+      (e.tags ?? []).some(t => args.tags!.includes(t))
     );
   }
   // Match server-side filterDiscoveredEvals: summary → whole file.
-  return expandSummarySuiteSelection(listed, selected, (e) =>
+  return expandSummarySuiteSelection(listed, selected, e =>
     isEvalSummaryCase(e.tags)
   );
 }
@@ -483,7 +483,7 @@ export async function pollRemoteEvalRun(args: {
 export function snapshotToEvalRunResults(
   snapshot: EvalRunSnapshot
 ): EvalRunResult[] {
-  return snapshot.cases.map((c) => ({
+  return snapshot.cases.map(c => ({
     id: c.id,
     path: c.fileId,
     ...(c.description === undefined ? {} : { description: c.description }),

package/src/internal/event-log.ts

@@ -101,7 +101,7 @@ export class SessionEventLog {
 
   private async readNextIndex(): Promise<void> {
     let next = 0;
-    await readNdjsonEvents(this.filePath, (event) => {
+    await readNdjsonEvents(this.filePath, event => {
       if (typeof event.index === "number" && event.index >= next) {
         next = event.index + 1;
       }
@@ -155,7 +155,7 @@ export class SessionEventLog {
       .then(() => {
         this.dropInflight(index);
       })
-      .catch((error) => this.onPersistError(error));
+      .catch(error => this.onPersistError(error));
     return event;
   }
 
@@ -164,7 +164,7 @@ export class SessionEventLog {
       this.inflight.shift();
       return;
     }
-    const i = this.inflight.findIndex((event) => event.index === index);
+    const i = this.inflight.findIndex(event => event.index === index);
     if (i >= 0) {
       this.inflight.splice(i, 1);
     }
@@ -181,7 +181,7 @@ export class SessionEventLog {
    */
   async snapshot(startIndex = 0): Promise<SessionEvent[]> {
     const byIndex = new Map<number, SessionEvent>();
-    await readNdjsonEvents(this.filePath, (event) => {
+    await readNdjsonEvents(this.filePath, event => {
       if (event.index >= startIndex) {
         byIndex.set(event.index, event);
       }
@@ -232,7 +232,7 @@ export class SessionEventLog {
     const encoder = new TextEncoder();
     let unsubscribe: (() => void) | undefined;
     return new ReadableStream<Uint8Array>({
-      start: async (controller) => {
+      start: async controller => {
         const push = (event: SessionEvent): void => {
           try {
             controller.enqueue(encoder.encode(`${JSON.stringify(event)}\n`));
@@ -242,7 +242,7 @@ export class SessionEventLog {
         };
         let following = false;
         const buffered: SessionEvent[] = [];
-        unsubscribe = this.subscribe((event) => {
+        unsubscribe = this.subscribe(event => {
           if (event.index < startIndex) {
             return;
           }
@@ -308,10 +308,10 @@ export class EventLogStore {
           SessionEventLog.open({
             sessionId,
             filePath,
-            onPersistError: (error) => this.onPersistError(sessionId, error),
+            onPersistError: error => this.onPersistError(sessionId, error),
           })
         )
-        .then((opened) => {
+        .then(opened => {
           this.opened.set(sessionId, opened);
           return opened;
         });
@@ -337,8 +337,8 @@ export class EventLogStore {
 
   async flushAll(): Promise<void> {
     await Promise.all(
-      [...this.logs.values()].map((logPromise) =>
-        logPromise.then((log) => log.flush()).catch(() => {})
+      [...this.logs.values()].map(logPromise =>
+        logPromise.then(log => log.flush()).catch(() => {})
       )
     );
   }

package/src/internal/event-mapper.ts

@@ -108,6 +108,41 @@ export class TurnEventMapper {
     return this.lastAssistantText;
   }
 
+  /**
+   * Unflushed `text-delta` buffer, else the last completed parent block.
+   * Used by `defineResult` before `finish()` so commit can read a
+   * text-only run without emitting `message.completed`.
+   */
+  get pendingText(): string | undefined {
+    if (this.textAccumulator !== "") {
+      return this.textAccumulator;
+    }
+    return this.lastAssistantText;
+  }
+
+  /**
+   * Drop streamed parent text so a same-turn repair does not concatenate
+   * or recommit the rejected attempt. Does not emit.
+   */
+  clearPendingText(): void {
+    this.textAccumulator = "";
+    this.lastAssistantText = undefined;
+  }
+
+  /**
+   * Drop rejected parent text and emit an empty `stop` `message.completed`.
+   * Slack `finalizeEmpty`s the open stream so a repair starts a new one
+   * instead of appending onto the rejected block. Origin/GitHub skip
+   * empty text and do not post.
+   */
+  abandonPendingText(): void {
+    this.clearPendingText();
+    this.emit({
+      type: "message.completed",
+      data: { text: "", finishReason: "stop" },
+    });
+  }
+
   /** Conversation summary produced by the harness (used as session title). */
   get title(): string | undefined {
     return this.summaryTitle;
@@ -434,8 +469,8 @@ export function describeToolResult(toolCall: ToolCall): ToolResultDescription {
       isError?: boolean;
     };
     const text = (value.content ?? [])
-      .map((item) => item.text?.text ?? "")
-      .filter((part) => part !== "")
+      .map(item => item.text?.text ?? "")
+      .filter(part => part !== "")
       .join("\n");
     return {
       output: text === "" ? value : text,

package/src/internal/filesystem/format.ts

@@ -140,16 +140,15 @@ function renderDirectoryTree(
       | { type: "file"; name: string }
       | { type: "dir"; name: string; dir: LsDirectoryTreeNode };
     const allChildren: LsChild[] = [
-      ...dir.childrenFiles.map(
-        (file): LsChild => ({ type: "file", name: file.name })
-      ),
-      ...dir.childrenDirs.map(
-        (childDir): LsChild => ({
-          type: "dir",
-          name: posix.basename(childDir.absPath),
-          dir: childDir,
-        })
-      ),
+      ...dir.childrenFiles.map((file): LsChild => ({
+        type: "file",
+        name: file.name,
+      })),
+      ...dir.childrenDirs.map((childDir): LsChild => ({
+        type: "dir",
+        name: posix.basename(childDir.absPath),
+        dir: childDir,
+      })),
     ];
     allChildren.sort((left, right) => left.name.localeCompare(right.name));
 
@@ -195,7 +194,7 @@ export function formatGlobOutput(
 ): string {
   const normalizedRoot = dir.replace(/\/+$/, "") || "/";
   const prefix = normalizedRoot === "/" ? "/" : `${normalizedRoot}/`;
-  const relative = files.map((filePath) =>
+  const relative = files.map(filePath =>
     filePath.startsWith(prefix) ? filePath.slice(prefix.length) : filePath
   );
   if (relative.length === 0) {
@@ -228,7 +227,7 @@ export function formatGrepOutput(union: GrepUnionResult | undefined): string {
       return "No matches found";
     }
     return union.output.counts
-      .map((row) => `${row.file}:${row.count}`)
+      .map(row => `${row.file}:${row.count}`)
       .join("\n");
   }
   if (union.output.matches.length === 0) {

package/src/internal/filesystem/scratch.ts

@@ -107,7 +107,7 @@ export function rewriteWebScratchValue(args: {
     return rewriteWebScratchText({ cwd, text: value });
   }
   if (Array.isArray(value)) {
-    return value.map((item) => rewriteWebScratchValue({ cwd, value: item }));
+    return value.map(item => rewriteWebScratchValue({ cwd, value: item }));
   }
   if (value !== null && typeof value === "object") {
     const next: Record<string, unknown> = {};
@@ -207,8 +207,8 @@ async function listHostAgentToolsFiles(cwd: string): Promise<string[]> {
   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));
+      .filter(entry => entry.isFile() && UUID_TXT.test(entry.name))
+      .map(entry => path.join(dir, entry.name));
   } catch (error) {
     if (isEnoent(error)) {
       return [];

package/src/internal/filesystem/tools.ts

@@ -12,6 +12,7 @@ import { z } from "zod";
 import {
   canonicalizeFileSystemToolName,
   collectGrepMatches,
+  FILE_SYSTEM_SCAN_LIMIT,
   type FileSystem,
   type FileSystemToolName,
   fileSystemImage,
@@ -130,9 +131,7 @@ export function hostFileToolsFromAuthored(
 }
 
 const HOST_DEFAULT_SYNTHESIZED_NAMES: readonly SynthesizedFileSystemToolName[] =
-  SYNTHESIZED_FILE_SYSTEM_TOOL_NAMES.filter(
-    (name) => name !== "SemanticSearch"
-  );
+  SYNTHESIZED_FILE_SYSTEM_TOOL_NAMES.filter(name => name !== "SemanticSearch");
 
 /**
  * Names July will actually synthesize for this agent. Discovery reserves
@@ -151,7 +150,7 @@ export function synthesizedFileSystemToolNames(options: {
   if (filter === undefined) {
     return catalog;
   }
-  return catalog.filter((name) => filter.includes(name));
+  return catalog.filter(name => filter.includes(name));
 }
 
 function wantsTool(
@@ -248,7 +247,7 @@ async function collectMultilineGrepFiles(
     pattern: recursiveGrepGlob(input.glob),
     ...(input.path === undefined ? {} : { dir: input.path }),
   });
-  return entries.map((entry) => entry.path);
+  return entries.map(entry => entry.path);
 }
 
 function recursiveGrepGlob(glob: string | undefined): string {
@@ -536,8 +535,9 @@ Tool to search for files matching a glob pattern
           await collectGlob(root, {
             pattern: globPattern,
             ...(targetDirectory === undefined ? {} : { dir: targetDirectory }),
+            limit: FILE_SYSTEM_SCAN_LIMIT,
           })
-        ).map((entry) => entry.path);
+        ).map(entry => entry.path);
         return formatGlobOutput(dir, files);
       },
     }),
@@ -546,7 +546,7 @@ Tool to search for files matching a glob pattern
 }
 
 const grepInputSchema = z.preprocess(
-  (raw) => {
+  raw => {
     const aliased = aliasKeys({
       output_mode: "outputMode",
       head_limit: "headLimit",
@@ -743,7 +743,7 @@ function semanticSearchTool(root: FileSystem): DiscoveredTool {
             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 }

package/src/internal/filesystem/walk.ts

@@ -7,8 +7,14 @@
 
 import { posix } from "node:path";
 import { minimatch } from "minimatch";
-import type { DirEntry, FileInfo, FileSystem } from "../../filesystem.js";
-import { normalizeFsPath } from "../../filesystem.js";
+import type {
+  DirEntry,
+  FileInfo,
+  FileSystem,
+  GlobOptions,
+  ListOptions,
+} from "../../filesystem.js";
+import { FILE_SYSTEM_SCAN_LIMIT, normalizeFsPath } from "../../filesystem.js";
 import { mergeSorted } from "./merge.js";
 
 /**
@@ -29,13 +35,22 @@ export interface LsDirectoryTreeNode {
 /** Filename-character ingest budget; matches LocalLsExecutor. */
 export const LS_INGEST_CHARACTER_BUDGET = 2_500;
 
+function takeLimit(entries: readonly DirEntry[], limit?: number): DirEntry[] {
+  if (limit === undefined || !Number.isFinite(limit)) {
+    return [...entries];
+  }
+  const cap = Math.max(0, Math.floor(limit));
+  return entries.slice(0, cap);
+}
+
 /**
  * Yield the files under `prefix`, sorted. A file whose path equals
  * `prefix` is not under itself.
  */
 export async function* listFilesFromPaths(
   files: Iterable<DirEntry>,
-  prefix?: string
+  prefix?: string,
+  options?: ListOptions
 ): AsyncGenerator<DirEntry> {
   const scope = normalizeListPrefix(prefix);
   const withSlash = scope === "/" ? "/" : `${scope}/`;
@@ -60,7 +75,7 @@ export async function* listFilesFromPaths(
     );
   }
   matches.sort((left, right) => left.path.localeCompare(right.path));
-  yield* matches;
+  yield* takeLimit(applyIgnores(matches, options?.excludes), options?.limit);
 }
 
 export function normalizeListPrefix(prefix?: string): string {
@@ -97,13 +112,14 @@ export function statFromFilePaths(
 
 export async function collectList(
   root: Pick<FileSystem, "list">,
-  prefix?: string
+  prefix?: string,
+  options?: ListOptions
 ): Promise<DirEntry[]> {
   const entries: DirEntry[] = [];
   if (root.list === undefined) {
     return entries;
   }
-  for await (const entry of root.list(prefix)) {
+  for await (const entry of root.list(prefix, options)) {
     entries.push(entry);
   }
   return entries;
@@ -111,13 +127,19 @@ export async function collectList(
 
 export async function collectGlob(
   root: Pick<FileSystem, "glob">,
-  options: { pattern: string; dir?: string }
+  options: { pattern: string; dir?: string; limit?: number }
 ): Promise<DirEntry[]> {
   const entries: DirEntry[] = [];
   if (root.glob === undefined) {
     return entries;
   }
-  for await (const entry of root.glob(options.pattern, options.dir)) {
+  const globOptions: GlobOptions | undefined =
+    options.limit === undefined ? undefined : { limit: options.limit };
+  for await (const entry of root.glob(
+    options.pattern,
+    options.dir,
+    globOptions
+  )) {
     entries.push(entry);
   }
   return entries;
@@ -129,9 +151,10 @@ export async function collectGlob(
  */
 export async function collectListOrStat(
   root: Pick<FileSystem, "list" | "stat">,
-  path?: string
+  path?: string,
+  options?: ListOptions
 ): Promise<{ kind: FileInfo["kind"]; files: DirEntry[] }> {
-  const files = await collectList(root, path);
+  const files = await collectList(root, path, options);
   if (files.length > 0) {
     return { kind: "directory", files };
   }
@@ -288,7 +311,7 @@ export function applyIgnores(
     return [...entries];
   }
   return entries.filter(
-    (entry) => !ignoreGlobs.some((glob) => matchesIgnoreGlob(entry.path, glob))
+    entry => !ignoreGlobs.some(glob => matchesIgnoreGlob(entry.path, glob))
   );
 }
 
@@ -298,10 +321,27 @@ function matchesIgnoreGlob(filePath: string, glob: string): boolean {
     ? glob
     : recursivePrefix + glob;
   const relative = filePath.replace(/^\//, "");
-  return (
-    minimatch(relative, pattern, { dot: true }) ||
-    minimatch(filePath, pattern, { dot: true })
-  );
+  const candidates = [relative, filePath];
+  for (const candidate of candidates) {
+    if (
+      minimatch(candidate, pattern, { dot: true }) ||
+      minimatch(candidate, `${pattern}/**`, { dot: true })
+    ) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/** True when `path` matches any {@link ListOptions.excludes} glob. */
+export function isExcludedPath(
+  path: string,
+  excludes?: readonly string[]
+): boolean {
+  if (excludes === undefined || excludes.length === 0) {
+    return false;
+  }
+  return excludes.some(glob => matchesIgnoreGlob(path, glob));
 }
 
 export async function lsFromList(
@@ -312,7 +352,12 @@ export async function lsFromList(
   | { status: "success"; value: { directoryTreeRoot: LsDirectoryTreeNode } }
   | { status: "error"; error: { message: string } }
 > {
-  const listed = await collectListOrStat(root, path);
+  const listed = await collectListOrStat(root, path, {
+    limit: FILE_SYSTEM_SCAN_LIMIT,
+    ...(ignoreGlobs === undefined || ignoreGlobs.length === 0
+      ? {}
+      : { excludes: ignoreGlobs }),
+  });
   const treePath = path ?? inferListedRoot(listed.files);
   switch (listed.kind) {
     case "missing":