@cursor/bdk 0.2.23 → 0.2.25

package/templates/agentic-owners/bot/lib/owners/parse.ts

@@ -143,6 +143,131 @@ function parseGlobalExclusions({
   return paths;
 }
 
+const GLOBAL_OVERRIDE_KEYS = [
+  "paths",
+  "team",
+  "teams",
+  "user",
+  "users",
+  "self_review",
+  "skip_teams",
+  "skip_paths",
+] as const;
+
+function parseGlobalOverrides({
+  value,
+  sourcePath,
+  issues,
+}: {
+  value: unknown;
+  sourcePath: string;
+  issues: string[];
+}): AgenticOwnersPathRule[] {
+  if (value === undefined) {
+    return [];
+  }
+  if (sourcePath !== ROOT_POLICY_SOURCE_PATH) {
+    issues.push(`${sourcePath}: global_overrides is only allowed in ${ROOT_POLICY_SOURCE_PATH}`);
+    return [];
+  }
+  if (!Array.isArray(value)) {
+    issues.push(`${sourcePath}: global_overrides must be a list`);
+    return [];
+  }
+  const rules: AgenticOwnersPathRule[] = [];
+  for (const [index, entry] of value.entries()) {
+    const label = `${sourcePath}: global_overrides[${index}]`;
+    if (!isRecord(entry)) {
+      issues.push(`${label} must be a mapping`);
+      continue;
+    }
+    const unknownKeys = Object.keys(entry).filter(
+      (key) => !(GLOBAL_OVERRIDE_KEYS as readonly string[]).includes(key),
+    );
+    if (unknownKeys.length > 0) {
+      issues.push(
+        `${label}: unknown key(s) ${unknownKeys.join(", ")} (allowed: ${GLOBAL_OVERRIDE_KEYS.join(", ")})`,
+      );
+    }
+    const paths = parsePaths(entry.paths, `${label}.paths`, issues);
+    const selfReview = parseBooleanField(
+      entry.self_review,
+      `${label}.self_review`,
+      "self_review",
+      issues,
+    );
+    const teams = parseOwnerList({
+      singular: entry.team,
+      plural: entry.teams,
+      label,
+      field: "teams",
+      issues,
+      parseEntry: parseTeamSlug,
+    });
+    const users = parseOwnerList({
+      singular: entry.user,
+      plural: entry.users,
+      label,
+      field: "users",
+      issues,
+      parseEntry: parseUserHandle,
+    });
+    const skipTeams = parseOwnerList({
+      singular: undefined,
+      plural: entry.skip_teams,
+      label,
+      field: "skip_teams",
+      issues,
+      parseEntry: parseTeamSlug,
+    });
+    const skipPaths =
+      entry.skip_paths === undefined
+        ? []
+        : parsePaths(entry.skip_paths, `${label}.skip_paths`, issues);
+    if (paths === undefined || selfReview === undefined || skipPaths === undefined) {
+      continue;
+    }
+    validatePathsStayWithinRepository({
+      paths,
+      sourcePath,
+      label: `${label}.paths`,
+      issues,
+    });
+    validatePathsStayWithinRepository({
+      paths: skipPaths,
+      sourcePath,
+      label: `${label}.skip_paths`,
+      issues,
+    });
+    if (teams.length === 0 && users.length === 0) {
+      issues.push(`${label}: team or user is required`);
+    }
+    if (!selfReview) {
+      issues.push(
+        `${label}: self_review: true is required (an override only lets its owners clear matching files by self-review)`,
+      );
+    }
+    rules.push({
+      sourcePath,
+      scopeDepth: 0,
+      globalOverride: true,
+      paths,
+      teams,
+      users,
+      team: teams[0],
+      user: users[0],
+      prompt: undefined,
+      alwaysApprove: false,
+      mode: "advisory",
+      humanReviewRequired: false,
+      selfReview,
+      ...(skipTeams.length > 0 ? { skipTeams } : {}),
+      ...(skipPaths.length > 0 ? { skipPaths } : {}),
+    });
+  }
+  return rules;
+}
+
 function parsePromptPath(value: unknown, label: string, issues: string[]): string | undefined {
   if (value === undefined) {
     return undefined;
@@ -228,12 +353,12 @@ function parseOwnerList({
   singular: unknown;
   plural: unknown;
   label: string;
-  field: "teams" | "users";
+  field: "teams" | "users" | "skip_teams";
   issues: string[];
   parseEntry: (value: unknown, label: string, issues: string[]) => string | undefined;
 }): string[] {
   const owners: string[] = [];
-  const singularField = field === "teams" ? "team" : "user";
+  const singularField = field === "users" ? "user" : "team";
   const parsedSingular = parseEntry(singular, `${label}.${singularField}`, issues);
   if (parsedSingular !== undefined) {
     owners.push(parsedSingular);
@@ -507,6 +632,11 @@ export function parseAgenticOwnersPolicyYaml({
     sourcePath,
     issues,
   });
+  const globalOverrides = parseGlobalOverrides({
+    value: parsed.global_overrides,
+    sourcePath,
+    issues,
+  });
 
   if (parsed.rules !== undefined) {
     issues.push(`${sourcePath}: use policies instead of rules`);
@@ -548,6 +678,7 @@ export function parseAgenticOwnersPolicyYaml({
     if (rules.length === 0) {
       throw new AgenticOwnersConfigValidationError([`${sourcePath}: policies must not be empty`]);
     }
+    rules.push(...globalOverrides);
     if (globalExclusions.length > 0) {
       rules.push(
         globalExclusionsRule({

package/templates/agentic-owners/bot/lib/owners/types.ts

@@ -12,12 +12,27 @@ export type AgenticOwnersPathRule = {
    * no owners, so they never enroll a review.
    */
   readonly globalExclusion?: boolean;
+  /**
+   * True for a root `global_overrides` entry. These rules are not precedence
+   * candidates. After a file's winning rule is chosen, a matching override
+   * adds its owners to an advisory winner, or becomes the owner when no
+   * committed rule owns the file. `self_review` on the override applies to
+   * the override's owners either way, and does not extend to the existing
+   * winner's owners. Exclusions, always-approve, hard, and notify winners
+   * stay unchanged, as do winners owned by a `skip_teams` team and paths
+   * listed in `skip_paths`.
+   */
+  readonly globalOverride?: boolean;
   /**
    * Glob patterns relative to the directory containing `.agentic-owners`.
    * Root-policy paths are relative to the repository root.
    * Leading `../` segments may address sibling trees but cannot leave the repo.
    */
   readonly paths: readonly string[];
+  /** Teams whose winning rule a `global_overrides` entry must not change. */
+  readonly skipTeams?: readonly string[];
+  /** Paths a `global_overrides` entry must not change. */
+  readonly skipPaths?: readonly string[];
   /**
    * Team slugs (or `org/team` handles) that own these paths. A policy may
    * list more than one. `team` is the first entry, kept for convenience.
@@ -39,6 +54,14 @@ export type AgenticOwnersPathRule = {
   readonly mode: AgenticOwnersPolicyMode;
   readonly humanReviewRequired: boolean;
   readonly selfReview: boolean;
+  /**
+   * Owners who may use {@link selfReview}. Absent means every owner on the
+   * rule. A merged override lists the winner's owners when that rule sets
+   * `self_review`, and the override's owners when the override sets it.
+   */
+  readonly selfReviewTeams?: readonly string[];
+  /** User owners who may use {@link selfReview}. See {@link selfReviewTeams}. */
+  readonly selfReviewUsers?: readonly string[];
 };
 
 export type AgenticOwnersRepoConfig = {