@cursor/july 0.1.108 → 0.1.111

package/src/channels/bitbucket/api.ts

@@ -290,6 +290,8 @@ export interface BitbucketApiPullRequest {
   title?: string;
   description?: string;
   state?: string;
+  draft?: boolean;
+  authorUsername?: string;
   sourceBranch?: string;
   targetBranch?: string;
   headSha?: string;
@@ -298,6 +300,20 @@ export interface BitbucketApiPullRequest {
   raw: unknown;
 }
 
+export interface BitbucketApiChangedFile {
+  path: string;
+  previousPath?: string;
+  status: "added" | "modified" | "removed" | "renamed";
+  patch?: string;
+}
+
+export interface BitbucketPullRequestDiffInput {
+  headSha?: string;
+  baseSha?: string;
+  mergeBaseSha?: string;
+  mergeBaseResolved?: boolean;
+}
+
 /**
  * The handful of operations review products need, implemented once per
  * dialect. `ctx.bitbucket.api` is the repo-bound instance.
@@ -318,6 +334,30 @@ export interface BitbucketApi {
   getFileAtRef(path: string, ref: string): Promise<string>;
 }
 
+export interface BitbucketPullRequestReadApi {
+  getPullRequest(id: number): Promise<BitbucketApiPullRequest>;
+  getMergeBaseSha(
+    id: number,
+    base: string,
+    headSha: string
+  ): Promise<string | undefined>;
+  listChangedFiles(
+    id: number,
+    input?: BitbucketPullRequestDiffInput
+  ): Promise<BitbucketApiChangedFile[]>;
+}
+
+export interface BitbucketPullRequestReadClient {
+  readonly repository: BitbucketRepositoryRef;
+  readonly api: Pick<BitbucketApi, "getPullRequest" | "getPullRequestDiff">;
+  request<T = unknown>(input: BitbucketRequestInput): Promise<T>;
+}
+
+export type BitbucketPullRequestReadDiagnostic =
+  | { kind: "commit-expansion-failed"; sha: string; error: unknown }
+  | { kind: "diff-fallback"; status: number }
+  | { kind: "metadata-fallback"; status: number };
+
 function asRecord(value: unknown): Record<string, unknown> | undefined {
   return typeof value === "object" && value !== null && !Array.isArray(value)
     ? (value as Record<string, unknown>)
@@ -334,11 +374,116 @@ function num(value: unknown): number | undefined {
     : undefined;
 }
 
+function errorStatus(error: unknown): number | undefined {
+  return num(asRecord(error)?.status);
+}
+
+function bitbucketAuthorUsername(raw: unknown): string | undefined {
+  const author = asRecord(asRecord(raw)?.author);
+  const user = asRecord(author?.user);
+  return (
+    str(author?.nickname) ??
+    str(user?.name) ??
+    str(user?.slug) ??
+    str(author?.display_name) ??
+    str(user?.displayName)
+  );
+}
+
+const GIT_PATH_ESCAPES: Readonly<Record<string, string>> = {
+  a: "\u0007",
+  b: "\b",
+  f: "\f",
+  n: "\n",
+  r: "\r",
+  t: "\t",
+  v: "\v",
+  "\\": "\\",
+  '"': '"',
+};
+
+function unescapeGitPath(path: string, quoted: boolean): string {
+  if (!quoted) {
+    return path;
+  }
+  const bytes: number[] = [];
+  let output = "";
+  const flush = () => {
+    if (bytes.length > 0) {
+      output += Buffer.from(bytes).toString("utf8");
+      bytes.length = 0;
+    }
+  };
+  for (let index = 0; index < path.length; index += 1) {
+    const character = path[index] as string;
+    if (character !== "\\") {
+      flush();
+      output += character;
+      continue;
+    }
+    const octal = /^[0-7]{1,3}/.exec(path.slice(index + 1));
+    if (octal !== null) {
+      bytes.push(Number.parseInt(octal[0], 8));
+      index += octal[0].length;
+      continue;
+    }
+    flush();
+    const next = path[index + 1] ?? "";
+    output += GIT_PATH_ESCAPES[next] ?? next;
+    index += 1;
+  }
+  flush();
+  return output;
+}
+
+/** Split a Git-style unified diff into normalized changed files. */
+export function splitBitbucketUnifiedDiff(
+  diff: string
+): BitbucketApiChangedFile[] {
+  const files: BitbucketApiChangedFile[] = [];
+  const sections = diff.split(/^(?=diff --git )/m).filter(Boolean);
+  for (const section of sections) {
+    const lines = section.replace(/\n$/, "").split("\n");
+    const header = /^diff --git ("?)a\/(.+?)\1 ("?)b\/(.+?)\3$/.exec(
+      lines[0] ?? ""
+    );
+    if (header === null) {
+      continue;
+    }
+    const oldPath = unescapeGitPath(header[2] ?? "", header[1] !== "");
+    const newPath = unescapeGitPath(header[4] ?? "", header[3] !== "");
+    let status: BitbucketApiChangedFile["status"] = "modified";
+    let bodyStart = 1;
+    for (; bodyStart < lines.length; bodyStart += 1) {
+      const line = lines[bodyStart] ?? "";
+      if (line.startsWith("@@")) {
+        break;
+      }
+      if (line === "--- /dev/null") {
+        status = "added";
+      } else if (line === "+++ /dev/null") {
+        status = "removed";
+      }
+    }
+    if (status === "modified" && oldPath !== newPath) {
+      status = "renamed";
+    }
+    const patch = lines.slice(bodyStart).join("\n");
+    files.push({
+      path: newPath,
+      previousPath: status === "renamed" ? oldPath : undefined,
+      status,
+      patch: patch === "" ? undefined : patch,
+    });
+  }
+  return files;
+}
+
 function encodePath(path: string): string {
   return path
     .split("/")
-    .filter((segment) => segment !== "")
-    .map((segment) => encodeURIComponent(segment))
+    .filter(segment => segment !== "")
+    .map(segment => encodeURIComponent(segment))
     .join("/");
 }
 
@@ -367,6 +512,202 @@ export function bitbucketDataCenterRepoPath(repository: {
   return `/projects/${encodeURIComponent(repository.owner)}/repos/${encodeURIComponent(repository.slug)}`;
 }
 
+export async function expandBitbucketCloudCommitSha(
+  bitbucket: Pick<BitbucketClient, "request">,
+  repository: Pick<BitbucketRepositoryRef, "owner" | "slug">,
+  sha: string | undefined,
+  onError?: (error: unknown) => void
+): Promise<string | undefined> {
+  if (sha === undefined || !/^[0-9a-f]{7,39}$/i.test(sha)) {
+    return sha;
+  }
+  try {
+    const commit = await bitbucket.request<{ hash?: string }>({
+      method: "GET",
+      path: `${bitbucketCloudRepoPath(repository)}/commit/${encodeURIComponent(sha)}`,
+    });
+    return /^[0-9a-f]{40}$/i.test(commit.hash ?? "") ? commit.hash : sha;
+  } catch (error) {
+    onError?.(error);
+    return sha;
+  }
+}
+
+function bitbucketPullRequestFromRaw(
+  raw: Record<string, unknown>,
+  id: number,
+  htmlUrl?: string
+): BitbucketApiPullRequest {
+  const source = asRecord(raw.source);
+  const destination = asRecord(raw.destination);
+  return {
+    id,
+    title: str(raw.title),
+    description: str(raw.description),
+    state: str(raw.state),
+    draft: typeof raw.draft === "boolean" ? raw.draft : undefined,
+    authorUsername: bitbucketAuthorUsername(raw),
+    sourceBranch:
+      str(asRecord(source?.branch)?.name) ??
+      str(asRecord(raw.fromRef)?.displayId),
+    targetBranch:
+      str(asRecord(destination?.branch)?.name) ??
+      str(asRecord(raw.toRef)?.displayId),
+    headSha:
+      str(asRecord(source?.commit)?.hash) ??
+      str(asRecord(raw.fromRef)?.latestCommit),
+    baseSha:
+      str(asRecord(destination?.commit)?.hash) ??
+      str(asRecord(raw.toRef)?.latestCommit),
+    htmlUrl,
+    raw,
+  };
+}
+
+export function createBitbucketPullRequestReadApi(
+  bitbucket: BitbucketPullRequestReadClient,
+  options: {
+    onDiagnostic?: (diagnostic: BitbucketPullRequestReadDiagnostic) => void;
+  } = {}
+): BitbucketPullRequestReadApi {
+  const { repository } = bitbucket;
+  const repo =
+    repository.dialect === "cloud"
+      ? bitbucketCloudRepoPath(repository)
+      : bitbucketDataCenterRepoPath(repository);
+  const cloudPullRequestFromActivity = async (
+    id: number
+  ): Promise<BitbucketApiPullRequest | undefined> => {
+    let path = `${repo}/pullrequests/${id}/activity`;
+    let query: Record<string, string | number> | undefined = { pagelen: 50 };
+    for (let page = 0; page < 20; page += 1) {
+      const response = await bitbucket.request<Record<string, unknown>>({
+        method: "GET",
+        path,
+        query,
+      });
+      for (const value of Array.isArray(response.values)
+        ? response.values
+        : []) {
+        const update = asRecord(asRecord(value)?.update);
+        if (update !== undefined) {
+          return bitbucketPullRequestFromRaw(update, id);
+        }
+      }
+      const next = str(response.next);
+      if (next === undefined) {
+        return undefined;
+      }
+      const nextUrl = new URL(next);
+      const marker = nextUrl.pathname.indexOf("/repositories/");
+      path = marker === -1 ? nextUrl.pathname : nextUrl.pathname.slice(marker);
+      query = Object.fromEntries(nextUrl.searchParams.entries());
+    }
+    return undefined;
+  };
+  return {
+    async getPullRequest(id) {
+      let pullRequest: BitbucketApiPullRequest;
+      try {
+        pullRequest = await bitbucket.api.getPullRequest(id);
+      } catch (error) {
+        const status = errorStatus(error);
+        if (
+          repository.dialect !== "cloud" ||
+          status === undefined ||
+          status < 500
+        ) {
+          throw error;
+        }
+        options.onDiagnostic?.({ kind: "metadata-fallback", status });
+        const fallback = await cloudPullRequestFromActivity(id);
+        if (fallback === undefined) {
+          throw error;
+        }
+        pullRequest = fallback;
+      }
+      const normalized = {
+        ...pullRequest,
+        draft: asRecord(pullRequest.raw)?.draft === true,
+        authorUsername: bitbucketAuthorUsername(pullRequest.raw),
+      };
+      if (repository.dialect !== "cloud") {
+        return normalized;
+      }
+      const [headSha, baseSha] = await Promise.all([
+        expandBitbucketCloudCommitSha(
+          bitbucket,
+          repository,
+          pullRequest.headSha,
+          error =>
+            pullRequest.headSha === undefined
+              ? undefined
+              : options.onDiagnostic?.({
+                  kind: "commit-expansion-failed",
+                  sha: pullRequest.headSha,
+                  error,
+                })
+        ),
+        expandBitbucketCloudCommitSha(
+          bitbucket,
+          repository,
+          pullRequest.baseSha,
+          error =>
+            pullRequest.baseSha === undefined
+              ? undefined
+              : options.onDiagnostic?.({
+                  kind: "commit-expansion-failed",
+                  sha: pullRequest.baseSha,
+                  error,
+                })
+        ),
+      ]);
+      return { ...normalized, headSha, baseSha };
+    },
+    async getMergeBaseSha(id, base, headSha) {
+      if (repository.dialect === "cloud") {
+        const commit = await bitbucket.request<{ hash?: string }>({
+          method: "GET",
+          path: `${repo}/merge-base/${encodeURIComponent(headSha)}..${encodeURIComponent(base)}`,
+        });
+        return str(commit.hash);
+      }
+      const commit = await bitbucket.request<{ id?: string }>({
+        method: "GET",
+        path: `${repo}/pull-requests/${id}/merge-base`,
+      });
+      return str(commit.id);
+    },
+    async listChangedFiles(id, input) {
+      try {
+        return splitBitbucketUnifiedDiff(
+          await bitbucket.api.getPullRequestDiff(id)
+        );
+      } catch (error) {
+        const status = errorStatus(error);
+        const comparisonBase = input?.mergeBaseSha ?? input?.baseSha;
+        if (
+          repository.dialect !== "cloud" ||
+          status === undefined ||
+          status < 500 ||
+          input?.headSha === undefined ||
+          comparisonBase === undefined
+        ) {
+          throw error;
+        }
+        options.onDiagnostic?.({ kind: "diff-fallback", status });
+        const diff = await bitbucket.request<string>({
+          method: "GET",
+          path: `${repo}/diff/${encodeURIComponent(input.headSha)}..${encodeURIComponent(comparisonBase)}`,
+          query: { topic: input.mergeBaseResolved === true ? "false" : "true" },
+          accept: "text/plain",
+        });
+        return splitBitbucketUnifiedDiff(diff);
+      }
+    },
+  };
+}
+
 export function cloudBitbucketApi(
   client: BitbucketClient,
   repository: BitbucketRepositoryRef
@@ -407,7 +748,7 @@ export function cloudBitbucketApi(
         raw,
       };
     },
-    getPullRequestDiff: (id) =>
+    getPullRequestDiff: id =>
       client.request<string>({
         method: "GET",
         path: `${repo}/pullrequests/${id}/diff`,
@@ -461,7 +802,7 @@ export function cloudBitbucketApi(
       });
       return mapComment(raw);
     },
-    setBuildStatus: (input) =>
+    setBuildStatus: input =>
       client.request({
         method: "POST",
         path: `${repo}/commit/${encodeURIComponent(input.sha)}/statuses/build`,
@@ -528,7 +869,7 @@ export function dcBitbucketApi(
     },
     // `/pull-requests/{id}.diff` streams the raw unified diff; the sibling
     // `/pull-requests/{id}/diff` route returns a JSON `RestDiff` instead.
-    getPullRequestDiff: (id) =>
+    getPullRequestDiff: id =>
       client.request<string>({
         method: "GET",
         path: `${repo}/pull-requests/${id}.diff`,
@@ -588,7 +929,7 @@ export function dcBitbucketApi(
     // Repository-scoped build status (DC 7.14+), which lives under
     // `rest/api/1.0` so the proxy's single upstream base reaches it; the
     // older `rest/build-status/1.0/commits/{sha}` sits outside that base.
-    setBuildStatus: (input) =>
+    setBuildStatus: input =>
       client.request({
         method: "POST",
         path: `${repo}/commits/${encodeURIComponent(input.sha)}/builds`,

package/src/channels/bitbucket/binding.ts

@@ -92,9 +92,9 @@ export function buildBitbucketBinding(input: {
     get api() {
       return getApi();
     },
-    request: (request) => getClient().request(request),
-    setBuildStatus: (status) => getApi().setBuildStatus(status),
-    createCheck: (check) =>
+    request: request => getClient().request(request),
+    setBuildStatus: status => getApi().setBuildStatus(status),
+    createCheck: check =>
       createBitbucketCheck({ ...check, bitbucket: getApi() }),
   };
 }
@@ -265,6 +265,31 @@ export function bitbucketPullRequestUrl(
     : `${repository.htmlUrl.replace(/\/browse\/?$/, "")}/pull-requests/${id}`;
 }
 
+/** Absolute PR URL, or undefined when a Data Center payload has no repo URL. */
+export function bitbucketAbsolutePullRequestUrl(
+  repository: BitbucketRepositoryRef,
+  id: number,
+  explicit?: string
+): string | undefined {
+  if (explicit !== undefined) {
+    return explicit;
+  }
+  if (repository.dialect === "cloud") {
+    return `https://bitbucket.org/${repository.fullName}/pull-requests/${id}`;
+  }
+  return repository.htmlUrl === undefined
+    ? undefined
+    : `${repository.htmlUrl.replace(/\/+$/, "").replace(/\/browse$/, "")}/pull-requests/${id}`;
+}
+
+/** Whether a Data Center `updated` payload publishes a draft pull request. */
+export function bitbucketDraftMarkedReady(
+  payload: Record<string, unknown>,
+  draft: boolean | undefined
+): boolean {
+  return payload.previousDraft === true && draft === false;
+}
+
 /**
  * Normalize the pull request from either dialect. `action` is the suffix of
  * the Cloud-normalized event key (`pullrequest:created` → `created`).
@@ -374,7 +399,7 @@ export function bitbucketPushFromPayload(
     return undefined;
   }
   return {
-    changes: changes.flatMap((entry) => {
+    changes: changes.flatMap(entry => {
       const change = asRecord(entry);
       if (change === undefined) {
         return [];

package/src/channels/bitbucket/bitbucket-channel.ts

@@ -168,7 +168,7 @@ export function findBitbucketChannelTargets(
         continue;
       }
       const postRoute = (channel.definition.routes ?? []).find(
-        (route) => route.method === "POST"
+        route => route.method === "POST"
       );
       targets.push({
         slug,

package/src/channels/bitbucket/bitbucket-webhook.ts

@@ -219,7 +219,7 @@ function configuredRepoAllowlist(
     repos.push(...options.cursorAccount.repos);
   }
   const normalized = repos
-    .map((repo) =>
+    .map(repo =>
       repo
         .trim()
         .replace(/^\/+|\/+$/g, "")

package/src/channels/bitbucket/checks.ts

@@ -69,8 +69,7 @@ export interface BitbucketCheckIdentityInput {
 }
 
 export interface BitbucketCheckCreateInput
-  extends BitbucketCheckIdentityInput,
-    CiCheckCreateInput {}
+  extends BitbucketCheckIdentityInput, CiCheckCreateInput {}
 
 /**
  * Bitbucket writer: every write re-posts the status row for `(sha, key)`.
@@ -82,7 +81,7 @@ function bitbucketCheckWriter(
 ): CiCheckWriter {
   let lastStatus: CiCheckStatus = input.status ?? "in_progress";
   let lastUrl: string | undefined = input.url;
-  return async (write) => {
+  return async write => {
     const status =
       write.status ??
       (write.conclusion === undefined ? lastStatus : "completed");
@@ -148,7 +147,7 @@ export function bindBitbucketChecks(input: {
   bitbucket: BitbucketCheckClient;
 }): CiChecksClient {
   return {
-    createCheck: (check) =>
+    createCheck: check =>
       createBitbucketCheck({ ...check, bitbucket: input.bitbucket }),
   };
 }

package/src/channels/bitbucket/cursor-account.ts

@@ -50,7 +50,7 @@ export function parseCursorBitbucketRepoScope(
   const repos = [
     ...new Set(
       values
-        .map((repo) =>
+        .map(repo =>
           repo
             .trim()
             .replace(/^\/+|\/+$/g, "")

package/src/channels/bitbucket/events.ts

@@ -69,7 +69,7 @@ export function deriveBitbucketWebhookEvents(
     return [
       ...new Set(
         options.webhookEvents
-          .map((event) => normalizeBitbucketEventKey(event))
+          .map(event => normalizeBitbucketEventKey(event))
           .filter(Boolean)
       ),
     ];

package/src/channels/bitbucket/index.ts

@@ -24,8 +24,10 @@
 export * from "./api.js";
 export {
   type BitbucketHandle,
+  bitbucketAbsolutePullRequestUrl,
   bitbucketCommentFromPayload,
   bitbucketDialectOf,
+  bitbucketDraftMarkedReady,
   bitbucketPullRequestFromPayload,
   bitbucketPullRequestUrl,
   bitbucketPushFromPayload,

package/src/channels/change-monitors/change-monitors-channel.ts

@@ -25,9 +25,9 @@ const checkpointResourceSchema = z
   })
   .passthrough()
   .refine(
-    (checkpoint) =>
+    checkpoint =>
       [checkpoint.clear, checkpoint.issues, checkpoint.inconclusive].filter(
-        (arm) => arm !== undefined
+        arm => arm !== undefined
       ).length === 1,
     { message: "checkpoint must have exactly one result arm" }
   );

package/src/channels/checks.ts

@@ -109,8 +109,9 @@ export interface CiChecksClient<
 }
 
 /** One desired check state for a writer to persist. */
-export interface CiCheckWrite<TConclusion extends string = CiCheckConclusion>
-  extends CiCheckUpdateInput<TConclusion> {
+export interface CiCheckWrite<
+  TConclusion extends string = CiCheckConclusion,
+> extends CiCheckUpdateInput<TConclusion> {
   startedAt?: string;
   completedAt?: string;
 }
@@ -167,13 +168,13 @@ export function resumeCiCheck<TConclusion extends string = CiCheckConclusion>(
     get url() {
       return url;
     },
-    update: (update) =>
+    update: update =>
       write({
         ...update,
         completedAt:
           update.status === "completed" ? new Date().toISOString() : undefined,
       }),
-    conclude: (conclude) =>
+    conclude: conclude =>
       write({
         status: "completed",
         conclusion: conclude.conclusion,

package/src/channels/deployments/deployments-channel.ts

@@ -128,7 +128,7 @@ export function deploymentEventMatchesChannel(
     return true;
   }
   return subscriptions.some(
-    (subscription) =>
+    subscription =>
       subscription.deploySourceUri === event.deploySourceUri.toLowerCase() &&
       deploymentEventMatches(subscription, event)
   );

package/src/channels/github/api.ts

@@ -114,7 +114,7 @@ export async function createGitHubOctokit(input: {
       ...transport,
       baseUrl: transport.baseUrl ?? proxyTransport?.apiBaseUrl,
     });
-    octokit.hook.before("request", async (request) => {
+    octokit.hook.before("request", async request => {
       const token = await resolveCredentialValue(dynamicToken);
       if (token === undefined) {
         throw new Error("githubChannel: dynamic GitHub token is unavailable.");

package/src/channels/github/checks.ts

@@ -61,7 +61,7 @@ function githubCheckWriter(input: {
   checkRunId?: number;
 }): CiCheckWriter {
   let checkRunId = input.checkRunId;
-  return async (write) => {
+  return async write => {
     const octokit = await input.github.getOctokit();
     const base = {
       owner: input.owner,

package/src/channels/github/cursor-account.ts

@@ -125,7 +125,7 @@ export function resolveCursorGithubCredentialScope(
   permissions: CursorGithubPermissions = "pr-write"
 ): CursorGithubRepoScope | undefined {
   const repos = [
-    ...new Set(values.map((repo) => repo.trim().toLowerCase()).filter(Boolean)),
+    ...new Set(values.map(repo => repo.trim().toLowerCase()).filter(Boolean)),
   ];
   if (repos.length === 0) {
     return undefined;
@@ -138,7 +138,7 @@ export function parseCursorGithubRepoScope(
   permissions: CursorGithubPermissions = "pr-write"
 ): CursorGithubRepoScope {
   const repos = [
-    ...new Set(values.map((repo) => repo.trim().toLowerCase()).filter(Boolean)),
+    ...new Set(values.map(repo => repo.trim().toLowerCase()).filter(Boolean)),
   ];
   if (repos.length === 0) {
     throw new Error(
@@ -161,7 +161,7 @@ export function parseCursorGithubRepoScope(
   if (owner === undefined) {
     throw new Error("Cursor account GitHub repository owner is missing.");
   }
-  if (repos.some((repo) => repo.split("/", 1)[0] !== owner)) {
+  if (repos.some(repo => repo.split("/", 1)[0] !== owner)) {
     throw new Error(
       "Cursor account GitHub repositories must share one owner for a single installation token."
     );

package/src/channels/github/defaults.ts

@@ -29,8 +29,8 @@ export function buildDefaultGitHubEvents(
   const deliverReplies = options.deliverReplies !== false;
   const requiredSuccessfulTools = new Set(
     options.progress?.requireSuccessfulTools
-      ?.map((toolName) => toolName.trim())
-      .filter((toolName) => toolName !== "") ?? []
+      ?.map(toolName => toolName.trim())
+      .filter(toolName => toolName !== "") ?? []
   );
   const toolOutcomesBySession = new Map<string, Map<string, boolean>>();
 
@@ -82,7 +82,7 @@ export function buildDefaultGitHubEvents(
       const pipelineSucceeded =
         requiredSuccessfulTools.size === 0 ||
         [...requiredSuccessfulTools].every(
-          (toolName) => outcomes?.get(toolName) === true
+          toolName => outcomes?.get(toolName) === true
         );
       toolOutcomesBySession.delete(event.sessionId);
       await applyGitHubProgress({
@@ -97,7 +97,11 @@ export function buildDefaultGitHubEvents(
       if (!deliverReplies) {
         return;
       }
-      if (event.data.finishReason === "tool_call" || event.data.text === "") {
+      if (
+        event.data.parentCallId !== undefined ||
+        event.data.finishReason === "tool_call" ||
+        event.data.text === ""
+      ) {
         return;
       }
       if (channel.state.owner === "" || channel.state.repo === "") {

package/src/channels/github/events.ts

@@ -68,5 +68,5 @@ export function deriveGitHubWebhookEvents(
 }
 
 function dedupe(events: readonly string[]): string[] {
-  return [...new Set(events.map((event) => event.trim()).filter(Boolean))];
+  return [...new Set(events.map(event => event.trim()).filter(Boolean))];
 }