@cursor/bdk 0.2.3 → 0.2.4

package/src/internal/expected-delivery-failure.ts

@@ -1,34 +0,0 @@
-/**
- * Customer-account states that end a delivery without a platform bug.
- * Hosted guests still surface these as `turn_failed` plus human copy, so
- * the reason is matched from that copy. Metric tags stay this closed set
- * and never include the message.
- */
-const USAGE_LIMIT_PHRASES = [
-  "reached its usage limit",
-  "reached your usage limit",
-  "reached the usage limit",
-  // Billing titles insert "monthly", or say "hit" instead of "reached".
-  "monthly usage limit",
-  "hit your usage limit",
-] as const;
-
-const UNPAID_INVOICE_PHRASES = ["unpaid invoice"] as const;
-
-export type ExpectedDeliveryFailureReason = "usage_limit" | "unpaid_invoice";
-
-export function classifyExpectedDeliveryFailure(
-  message: string | undefined,
-): ExpectedDeliveryFailureReason | undefined {
-  if (message === undefined || message.length === 0) {
-    return undefined;
-  }
-  const text = message.toLowerCase();
-  if (UNPAID_INVOICE_PHRASES.some(phrase => text.includes(phrase))) {
-    return "unpaid_invoice";
-  }
-  if (USAGE_LIMIT_PHRASES.some(phrase => text.includes(phrase))) {
-    return "usage_limit";
-  }
-  return undefined;
-}

package/src/internal/factory-resource-channel.ts

@@ -1,103 +0,0 @@
-import type { z } from "zod";
-import { defineChannel, localDevStrict, POST } from "../channels.js";
-import type { ChannelDefinition, ChannelHandlerArgs } from "../types.js";
-import { tagOutcome } from "./channel-dispatch.js";
-import type { ContinuationIdentity } from "./continuation-identity.js";
-import { attachHostedAdmissionAdapter } from "./hosted-admission-adapter.js";
-import { bindLocalIngressSend } from "./local-ingress.js";
-
-type FactoryResourceChannelOptions<TEvent> = {
-  onEvent: (event: TEvent, args: ChannelHandlerArgs) => Promise<unknown> | unknown;
-  continuation?: ContinuationIdentity;
-  path?: string;
-  auth?: ChannelDefinition["auth"];
-  onStart?: ChannelDefinition["onStart"];
-  onStop?: ChannelDefinition["onStop"];
-};
-
-type FactoryResourceChannelSpec<TEvent extends { eventType: string }> = {
-  kind: string;
-  eventTypes: readonly string[];
-  eventSchema: z.ZodType<TEvent>;
-  replayDescription: string;
-  invalidError: string;
-};
-
-type FactoryResourceChannelPack<TEvent> = {
-  channel: (options: FactoryResourceChannelOptions<TEvent>) => ChannelDefinition;
-  getOptions: (definition: object) => FactoryResourceChannelOptions<TEvent> | undefined;
-};
-
-/**
- * Shared pack for Factory resource channels that have one event type, no
- * subscription filter, and the same local-replay / hosted-admission path.
- */
-export function createFactoryResourceChannel<TEvent extends { eventType: string }>(
-  spec: FactoryResourceChannelSpec<TEvent>,
-): FactoryResourceChannelPack<TEvent> {
-  const optionsByDefinition = new WeakMap<object, FactoryResourceChannelOptions<TEvent>>();
-
-  async function dispatchEvent(input: {
-    options: FactoryResourceChannelOptions<TEvent>;
-    event: TEvent;
-    args: ChannelHandlerArgs;
-  }): Promise<Response> {
-    await input.options.onEvent(
-      input.event,
-      bindLocalIngressSend(input.args, {
-        identity: input.options.continuation,
-        kind: spec.kind,
-        eventType: input.event.eventType,
-        payload: input.event,
-      }),
-    );
-    return tagOutcome(Response.json({ ok: true }), "task");
-  }
-
-  function channel(options: FactoryResourceChannelOptions<TEvent>): ChannelDefinition {
-    const routePath = options.path ?? "/";
-    const definition = defineChannel({
-      auth: options.auth ?? [localDevStrict()],
-      meta: {
-        kind: spec.kind,
-        factoryEventTypes: spec.eventTypes,
-      },
-      onStart: options.onStart,
-      onStop: options.onStop,
-      routes: [
-        POST(routePath, {
-          description: spec.replayDescription,
-          bodySchema: spec.eventSchema,
-          handler: async (_request, args) =>
-            dispatchEvent({
-              options,
-              event: args.body,
-              args,
-            }),
-        }),
-      ],
-    });
-    optionsByDefinition.set(definition, options);
-    attachHostedAdmissionAdapter(definition, {
-      kind: spec.kind,
-      dispatch: async ({ payload, args }) => {
-        const parsed = spec.eventSchema.safeParse(payload);
-        if (!parsed.success) {
-          return Response.json({ ok: false, error: spec.invalidError }, { status: 400 });
-        }
-        return dispatchEvent({
-          options,
-          event: parsed.data,
-          args,
-        });
-      },
-    });
-    return definition;
-  }
-
-  function getOptions(definition: object): FactoryResourceChannelOptions<TEvent> | undefined {
-    return optionsByDefinition.get(definition);
-  }
-
-  return { channel, getOptions };
-}

package/src/internal/filesystem/errors.ts

@@ -1,207 +0,0 @@
-/**
- * Typed FileSystem throws. Every method error is a {@link PathError}
- * so composers (`unionFs`) can rewrite `path` without scraping
- * `error.message`.
- *
- * Messages stay the FileSystem contract strings. `path` is the
- * absolute posix path the error is about (child-root on a mount,
- * namespace path after `unionFs` remaps it).
- */
-
-import path from "node:path";
-
-function normalizeErrorPath(input: string): string {
-  const slashes = input.replace(/\\/g, "/");
-  if (slashes === "") {
-    return "/";
-  }
-  const withSlash = slashes.startsWith("/") ? slashes : `/${slashes}`;
-  const resolved = path.posix.normalize(withSlash);
-  if (resolved.length > 1 && resolved.endsWith("/")) {
-    return resolved.slice(0, -1);
-  }
-  return resolved === "." || resolved === "" ? "/" : resolved;
-}
-
-const ROOT_MESSAGE_PREFIX =
-  /^(not found|read-only mount|write failed|edit failed|no mount for path|delete is not supported): \/$/;
-
-function rewritePathInMessage(message: string, from: string, to: string): string {
-  if (from === to) {
-    return message;
-  }
-  if (from === "/") {
-    return ROOT_MESSAGE_PREFIX.test(message) ? message.replace(/\/$/, to) : message;
-  }
-  return message.includes(from) ? message.split(from).join(to) : message;
-}
-
-/**
- * Base of every FileSystem method throw. Config / factory errors
- * (`FileSystemConfigError`, empty `overlayFs`) are not PathErrors.
- */
-export class PathError extends Error {
-  readonly path: string;
-
-  constructor(path: string, message: string) {
-    super(message);
-    this.name = new.target.name;
-    this.path = normalizeErrorPath(path);
-  }
-
-  /**
-   * Same error at a rewritten path. `unionFs` prepends the mount
-   * prefix this way. Subclass identity and extra fields stay.
-   */
-  withPath(path: string): this {
-    const next = normalizeErrorPath(path);
-    if (next === this.path) {
-      return this;
-    }
-    return this.recreate(next, rewritePathInMessage(this.message, this.path, next));
-  }
-
-  protected recreate(path: string, message: string): this {
-    return new PathError(path, message) as this;
-  }
-}
-
-export class FileNotFoundError extends PathError {
-  constructor(path: string, message?: string) {
-    super(path, message ?? `not found: ${normalizeErrorPath(path)}`);
-  }
-
-  protected override recreate(path: string, message: string): this {
-    return new FileNotFoundError(path, message) as this;
-  }
-}
-
-export class ReadOnlyMountError extends PathError {
-  constructor(path: string, message?: string) {
-    super(path, message ?? `read-only mount: ${normalizeErrorPath(path)}`);
-  }
-
-  protected override recreate(path: string, message: string): this {
-    return new ReadOnlyMountError(path, message) as this;
-  }
-}
-
-export class NoMountError extends PathError {
-  constructor(path: string, message?: string) {
-    super(path, message ?? `no mount for path: ${normalizeErrorPath(path)}`);
-  }
-
-  protected override recreate(path: string, message: string): this {
-    return new NoMountError(path, message) as this;
-  }
-}
-
-export class WriteFailedError extends PathError {
-  constructor(path: string, message?: string) {
-    super(path, message ?? `write failed: ${normalizeErrorPath(path)}`);
-  }
-
-  protected override recreate(path: string, message: string): this {
-    return new WriteFailedError(path, message) as this;
-  }
-}
-
-export class DeleteNotSupportedError extends PathError {
-  constructor(path: string, message?: string) {
-    super(path, message ?? `delete is not supported: ${normalizeErrorPath(path)}`);
-  }
-
-  protected override recreate(path: string, message: string): this {
-    return new DeleteNotSupportedError(path, message) as this;
-  }
-}
-
-/**
- * Exact-edit contract failures (`oldText is empty`, uniqueness).
- * `message` is the contract string; it does not embed `path`.
- */
-export class EditError extends PathError {
-  protected override recreate(path: string, message: string): this {
-    return new EditError(path, message) as this;
-  }
-}
-
-export class InvalidGrepPatternError extends PathError {
-  readonly pattern: string;
-
-  constructor(pattern: string, path = "/", message?: string) {
-    super(path, message ?? `invalid grep pattern: ${pattern}`);
-    this.pattern = pattern;
-  }
-
-  protected override recreate(path: string, message: string): this {
-    return new InvalidGrepPatternError(this.pattern, path, message) as this;
-  }
-}
-
-export function isFileNotFoundError(error: unknown): boolean {
-  return (
-    error instanceof FileNotFoundError ||
-    (error instanceof Error && error.message.startsWith("not found:"))
-  );
-}
-
-export function isInvalidGrepPatternError(error: unknown): boolean {
-  return (
-    error instanceof InvalidGrepPatternError ||
-    (error instanceof Error && error.message.startsWith("invalid grep pattern:"))
-  );
-}
-
-const CONTRACT_PATH_LABELS = [
-  "not found: ",
-  "read-only mount: ",
-  "write failed: ",
-  "edit failed: ",
-  "no mount for path: ",
-  "delete is not supported: ",
-] as const;
-
-/**
- * Remap a child throw onto a mount prefix. Typed {@link PathError}
- * keeps its class and rewrites `path`. Untyped `Error` still gets
- * a best-effort message rewrite so older custom trees keep working.
- */
-export function remapPathError(error: unknown, prefix: string): Error {
-  if (error instanceof PathError) {
-    return error.withPath(joinMountPath(error.path, prefix));
-  }
-  if (!(error instanceof Error)) {
-    return new PathError(prefix, String(error));
-  }
-  return rewriteUntypedMountError(error, prefix);
-}
-
-function joinMountPath(childPath: string, prefix: string): string {
-  const mount = normalizeErrorPath(prefix);
-  const child = normalizeErrorPath(childPath);
-  if (mount === "/") {
-    return child;
-  }
-  if (child === "/") {
-    return mount;
-  }
-  return `${mount}${child}`;
-}
-
-function rewriteUntypedMountError(error: Error, prefix: string): Error {
-  for (const label of CONTRACT_PATH_LABELS) {
-    if (!error.message.startsWith(label)) {
-      continue;
-    }
-    const childPath = error.message.slice(label.length);
-    const next = `${label}${joinMountPath(childPath, prefix)}`;
-    if (next === error.message) {
-      return error;
-    }
-    const rewritten = new Error(next);
-    rewritten.name = error.name;
-    return rewritten;
-  }
-  return error;
-}

package/src/internal/filesystem/format.ts

@@ -1,253 +0,0 @@
-/**
- * Model-facing strings that match Cursor SDK native tool output
- * (LocalLsExecutor / read / grep / glob formatters).
- */
-
-import { posix } from "node:path";
-
-import type { GrepUnionResult } from "../../filesystem.js";
-import type { LsDirectoryTreeNode } from "./walk.js";
-
-const LS_RENDER_CHARACTER_BUDGET = 10_000;
-const GLOB_TOTAL_CHARACTER_BUDGET = 5_000;
-
-/**
- * Number already-sliced Read content. `FileSystem.read` applies offset/
- * limit; do not window again or line numbers restart at 1.
- */
-export function slicedReadStartLine(totalLines: number, offset?: number): number {
-  if (offset === undefined) {
-    return 1;
-  }
-  if (offset < 0) {
-    return Math.max(1, totalLines + offset + 1);
-  }
-  return Math.max(1, offset);
-}
-
-export function formatNumberedLines(
-  content: string,
-  options: {
-    offset?: number;
-    limit?: number;
-    /** When set, `content` is already the window; number from this line. */
-    startLine?: number;
-    totalLines?: number;
-  } = {},
-): string {
-  const lines = content === "" ? [] : content.split("\n");
-  if (lines.length === 0) {
-    return "";
-  }
-  const { offset, limit, startLine } = options;
-  let start = 1;
-  let window = lines;
-  const total = options.totalLines ?? lines.length;
-  if (startLine !== undefined) {
-    start = startLine;
-  } else if (offset !== undefined || limit !== undefined) {
-    const effectiveOffset = offset ?? 1;
-    const effectiveLimit = limit ?? (effectiveOffset < 0 ? Math.abs(effectiveOffset) : total);
-    start =
-      effectiveOffset < 0 ? Math.max(1, total + effectiveOffset + 1) : Math.max(1, effectiveOffset);
-    const end = Math.min(total, start + effectiveLimit - 1);
-    window = lines.slice(start - 1, end);
-  }
-  return renderNumberedWindow(window, start, total);
-}
-
-function renderNumberedWindow(window: readonly string[], start: number, total: number): string {
-  const numbered = window.map((line, index) => `${String(start + index).padStart(6, " ")}|${line}`);
-  let result = numbered.join("\n");
-  if (start > 1) {
-    result = `... ${start - 1} ${start - 1 === 1 ? "line" : "lines"} not shown ...\n${result}`;
-  }
-  const end = start + window.length - 1;
-  if (end < total) {
-    result += `\n... ${total - end} ${total - end === 1 ? "line" : "lines"} not shown ...`;
-  }
-  return result;
-}
-
-export function formatLsTree(result: LsDirectoryTreeNode): string {
-  if (
-    result.childrenWereProcessed &&
-    result.childrenDirs.length === 0 &&
-    result.childrenFiles.length === 0
-  ) {
-    const trailingSlash = result.absPath.endsWith("/") ? "" : "/";
-    return `${result.absPath}${trailingSlash}\n... no children found ...`;
-  }
-
-  const characterBudget = LS_RENDER_CHARACTER_BUDGET;
-  let toolResponse = renderDirectoryTree(result).result;
-  if (toolResponse.length > characterBudget) {
-    toolResponse = renderDirectoryTree(result, true, 0).result;
-    if (toolResponse.length > characterBudget) {
-      toolResponse = renderDirectoryTree(result, false, 0).result;
-    }
-  }
-
-  const notes: string[] = [];
-  if (!result.childrenWereProcessed || toolResponse.length > characterBudget) {
-    if (toolResponse.length > characterBudget) {
-      toolResponse = toolResponse.slice(0, characterBudget);
-      const lastNewlineIndex = toolResponse.lastIndexOf("\n");
-      if (lastNewlineIndex > 0) {
-        toolResponse = toolResponse.slice(0, lastNewlineIndex + 1);
-      }
-    }
-    toolResponse += "    ...\n";
-    notes.push(
-      `target_directory is too large (either too many children or their names are too long).` +
-        ` Immediate children were truncated. Try doing more specific search or use the script tool.`,
-    );
-  }
-  if (notes.length === 1) {
-    toolResponse += `\nNote: ${notes[0]}`;
-  }
-  return toolResponse;
-}
-
-function renderDirectoryTree(
-  rootDirectory: LsDirectoryTreeNode,
-  renderExtensionCounts = true,
-  renderDepthLimit?: number,
-): { result: string } {
-  function render(dir: LsDirectoryTreeNode, depth: number): string {
-    const indent = "  ".repeat(depth);
-    let result: string;
-    if (depth === 0) {
-      const trailingSep = dir.absPath.endsWith("/") ? "" : "/";
-      result = `${dir.absPath}${trailingSep}\n`;
-    } else {
-      result = `${indent}- ${posix.basename(dir.absPath)}/\n`;
-    }
-
-    type LsChild =
-      | { 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,
-      })),
-    ];
-    allChildren.sort((left, right) => left.name.localeCompare(right.name));
-
-    const childIndent = "  ".repeat(depth + 1);
-    for (const child of allChildren) {
-      if (child.type === "file") {
-        result += `${childIndent}- ${child.name}\n`;
-        continue;
-      }
-      const childDir = child.dir;
-      if (
-        childDir.childrenWereProcessed &&
-        (renderDepthLimit === undefined || depth < renderDepthLimit)
-      ) {
-        result += render(childDir, depth + 1);
-        continue;
-      }
-      const extensionCounts = Object.entries(childDir.fullSubtreeExtensionCounts);
-      if (extensionCounts.length > 0 && renderExtensionCounts) {
-        const sorted = [...extensionCounts].sort(([, countA], [, countB]) => countB - countA);
-        const shown = sorted.slice(0, 3);
-        const summary = shown
-          .map(([ext, count]) => `${count} *${ext === "" ? "" : ext}`)
-          .join(", ");
-        result += `${childIndent}- ${child.name}/ (${childDir.numFiles} files: ${summary})\n`;
-      } else {
-        result += `${childIndent}- ${child.name}/\n`;
-      }
-    }
-    return result;
-  }
-
-  return { result: render(rootDirectory, 0) };
-}
-
-export function formatGlobOutput(dir: string, files: readonly string[]): string {
-  const normalizedRoot = dir.replace(/\/+$/, "") || "/";
-  const prefix = normalizedRoot === "/" ? "/" : `${normalizedRoot}/`;
-  const relative = files.map(filePath =>
-    filePath.startsWith(prefix) ? filePath.slice(prefix.length) : filePath,
-  );
-  if (relative.length === 0) {
-    return `Result of search in '${dir}': 0 files found\n`;
-  }
-  let output = `Result of search in '${dir}' (total ${relative.length} file${relative.length === 1 ? "" : "s"}):\n`;
-  for (let i = 0; i < relative.length; i++) {
-    const file = relative[i] ?? "";
-    if (output.length + file.length > GLOB_TOTAL_CHARACTER_BUDGET) {
-      output += `... ${relative.length - i} more files ... (Do a more specific search if needed)\n`;
-      break;
-    }
-    output += `- ${file}\n`;
-  }
-  return output;
-}
-
-export function formatGrepOutput(union: GrepUnionResult | undefined): string {
-  if (union === undefined) {
-    return "No matches found";
-  }
-  if (union.type === "files") {
-    if (union.output.files.length === 0) {
-      return "No files with matches found";
-    }
-    return union.output.files.join("\n");
-  }
-  if (union.type === "count") {
-    if (union.output.counts.length === 0) {
-      return "No matches found";
-    }
-    return union.output.counts.map(row => `${row.file}:${row.count}`).join("\n");
-  }
-  if (union.output.matches.length === 0) {
-    return "No matches found";
-  }
-  const lines: string[] = [];
-  let currentFile: string | undefined;
-  for (const match of union.output.matches) {
-    if (match.file !== currentFile) {
-      if (currentFile !== undefined) {
-        lines.push("");
-      }
-      currentFile = match.file;
-      lines.push(match.file);
-    }
-    const before = match.beforeContext ?? [];
-    const matchLine = match.lineNumber ?? 1;
-    before.forEach((line, index) => {
-      lines.push(`  ${matchLine - before.length + index}-${line}`);
-    });
-    lines.push(`  ${match.lineNumber ?? ""}:${match.line}`);
-    (match.afterContext ?? []).forEach((line, index) => {
-      lines.push(`  ${matchLine + 1 + index}-${line}`);
-    });
-  }
-  return lines.join("\n");
-}
-
-export function formatWriteOutput(path: string): string {
-  return `Wrote contents to ${path}`;
-}
-
-export function formatStrReplaceOutput(args: {
-  path: string;
-  replaceAll: boolean;
-  occurrencesModified: number;
-}): string {
-  if (!args.replaceAll) {
-    return `The file ${args.path} has been updated.`;
-  }
-  const occurrenceLabel = args.occurrencesModified === 1 ? "occurrence" : "occurrences";
-  const verb = args.occurrencesModified === 1 ? "has" : "have";
-  return `${args.occurrencesModified} ${occurrenceLabel} in file ${args.path} ${verb} been updated.`;
-}