Context center

.agents/skills/java-checkstyle/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: java-checkstyle
+description: Run `mvn spotless:apply` to fix Java checkstyle / formatting failures and verify the result. Run after authoring or modifying any `.java` files, or when CI reports a "Java checkstyle failed" / "Fix Java checkstyle" issue on a PR.
+---
+
+# Java Checkstyle / Spotless (Codex agent)
+
+OpenMetadata enforces Java formatting via the Spotless Maven plugin. Every CI
+build runs `mvn spotless:check` and fails the PR if any file is not formatted.
+
+## When to activate
+
+- The user asks to "fix checkstyle", "fix Java formatting", "apply spotless",
+  "run spotless", "format Java", or similar.
+- CI posts a `Java checkstyle failed` / `Fix Java checkstyle` comment on a PR
+  (the bot's exact phrasing is "Please run `mvn spotless:apply` in the root of
+  your repository and commit the changes to this PR").
+- After you have finished authoring or editing any `.java` files — before
+  opening a PR or pushing a commit that touches Java.
+
+## Procedure
+
+1. From the repo root run Spotless:
+
+   ```bash
+   mvn spotless:apply                 # formats everything
+   # or
+   mvn -pl <module> spotless:apply    # scope to a single Maven module for speed
+   # or
+   mvn spotless:check                 # verify only, without rewriting files
+   ```
+
+   Spotless is fast (seconds, no compilation). If it fails with a plugin error
+   rather than a formatting diff, surface the error and stop — do not try to
+   hand-edit formatting around the failure.
+
+2. Inspect the diff:
+
+   ```bash
+   git status --short
+   git diff --stat
+   ```
+
+   Expect changes only in `.java` (and possibly `pom.xml`) files. If Spotless
+   keeps rewriting a change you just made, re-read the root `pom.xml`'s
+   `spotless-maven-plugin` config — Spotless is the source of truth, not the
+   IDE.
+
+3. Only commit if the user asked to. Report the changed-file list first so the
+   user can decide whether to fold the reformat into the in-progress commit or
+   make a separate "Fix Java checkstyle" commit (matches the repo's existing
+   history for bot-triggered formatting-only commits).
+
+## Out of scope
+
+- UI / TypeScript formatting — use `yarn pretty` / ESLint flow (see AGENTS.md
+  UI section).
+- Python formatting — use `make py_format` (black + isort + pycln).

.agents/skills/ui-checkstyle/SKILL.md

@@ -0,0 +1,86 @@
+---
+name: ui-checkstyle
+description: Run the ESLint + Prettier + organize-imports sequence that CI's `UI Checkstyle` jobs (`lint-src`, `lint-playwright`, `lint-core-components`) run — on just the files the PR changed — and fail if any file ends up with a diff. Run after authoring or modifying any `.ts`/`.tsx`/`.js`/`.jsx`/`.json` under `openmetadata-ui/src/main/resources/ui/src/`, `.../playwright/`, or `openmetadata-ui-core-components/src/main/resources/ui/src/`, or when CI reports a `UI Checkstyle` failure on a PR.
+---
+
+# UI Checkstyle / ESLint + Prettier + organize-imports (Codex agent)
+
+The `UI Checkstyle` workflow (`.github/workflows/ui-checkstyle.yml`) has three
+per-area jobs — `lint-src`, `lint-playwright`, `lint-core-components`. Each
+reformats the files changed in the PR and fails if the reformat produces a
+diff, so the committed tree must already be formatted.
+
+## When to activate
+
+- The user asks to "fix UI checkstyle", "fix UI lint", "run prettier", "run
+  eslint", "fix UI format", or similar.
+- CI posts a `UI Checkstyle / lint-src|lint-playwright|lint-core-components`
+  failure (the bot surfaces the modified files in the job summary).
+- After you have finished authoring or editing any `.ts`/`.tsx`/`.js`/
+  `.jsx`/`.json` under the three UI trees — before opening a PR or pushing
+  a commit that touches UI.
+
+## Procedure
+
+1. Build the file list for each affected area:
+
+   ```bash
+   # repo root
+   git diff --name-only origin/main...HEAD -- \
+     'openmetadata-ui/src/main/resources/ui/src/**/*.{ts,tsx,js,jsx,json}' \
+     | sed 's|openmetadata-ui/src/main/resources/ui/||' > /tmp/src_files.txt
+
+   git diff --name-only origin/main...HEAD -- \
+     'openmetadata-ui/src/main/resources/ui/playwright/**/*.{ts,tsx,js,jsx}' \
+     | sed 's|openmetadata-ui/src/main/resources/ui/||' > /tmp/pw_files.txt
+
+   git diff --name-only origin/main...HEAD -- \
+     'openmetadata-ui-core-components/**/*.{ts,tsx,js,jsx,json}' \
+     | sed 's|openmetadata-ui-core-components/src/main/resources/ui/||' \
+     > /tmp/core_files.txt
+   ```
+
+   Skip any empty list — CI won't run that area's job either.
+
+2. From the matching working directory (`openmetadata-ui/src/main/resources/ui`
+   or `openmetadata-ui-core-components/src/main/resources/ui`), run the
+   three-step sequence that CI runs:
+
+   ```bash
+   # 1) imports first
+   cat /tmp/src_files.txt | xargs ./node_modules/.bin/organize-imports-cli
+
+   # 2) ESLint --fix
+   NODE_OPTIONS='--max-old-space-size=8192' cat /tmp/src_files.txt \
+     | xargs ./node_modules/.bin/eslint --no-error-on-unmatched-pattern --fix
+
+   # 3) prettier --write — MUST be last, because organize-imports-cli uses
+   #    4-space indentation and drops trailing commas; prettier restores them
+   #    to the repo's 2-space + trailing-comma style. Reversing the order
+   #    leaves CI with a dirty diff.
+   cat /tmp/src_files.txt \
+     | xargs ./node_modules/.bin/prettier \
+         --config './.prettierrc.yaml' --ignore-path './.prettierignore' \
+         --write
+   ```
+
+   Core-components has no `organize-imports-cli` wired up — skip step 1 there.
+
+3. Check the diff from the repo root:
+
+   ```bash
+   git status --short
+   git diff --stat
+   ```
+
+   If `git status --short` is empty you're done. Otherwise commit the
+   reformatting diff as its own `Fix UI checkstyle` commit, matching the
+   existing history for bot-triggered formatting-only commits — unless the
+   user asked you to fold it into the in-progress commit.
+
+## Out of scope
+
+- TypeScript type-check errors (`tsc`) — different jobs, different failure
+  modes, not auto-fixable by this skill.
+- Java formatting — use the `java-checkstyle` skill (`mvn spotless:apply`).
+- Python formatting — use `make py_format` (black + isort + pycln).

.claude/skills/java-checkstyle/SKILL.md

@@ -0,0 +1,83 @@
+---
+name: java-checkstyle
+description: Run `mvn spotless:apply` to fix Java checkstyle / formatting failures and verify the result. Invoke after authoring or modifying any `.java` files, or when CI reports a "Java checkstyle failed" or "Fix Java checkstyle" issue on a PR.
+user-invocable: true
+argument-hint: "[-pl <module>] [--check]"
+allowed-tools:
+  - Bash
+  - Read
+  - Grep
+  - Glob
+---
+
+# Java Checkstyle / Spotless
+
+OpenMetadata enforces Java formatting via the Spotless Maven plugin. Every CI
+build runs `mvn spotless:check` and fails the PR if any file is not formatted.
+This skill keeps the fix on a single, consistent command so reviewers never have
+to ask for it manually again.
+
+## When to activate
+
+- The user asks to "fix checkstyle", "fix Java formatting", "apply spotless",
+  "run spotless", "format Java", or similar.
+- CI posts a `Java checkstyle failed` / `Fix Java checkstyle` comment on a PR
+  (the project's bot phrases the instruction as "Please run
+  `mvn spotless:apply` in the root of your repository and commit the changes").
+- After the assistant has finished authoring or editing any `.java` files —
+  before opening a PR or pushing a commit that touches Java.
+
+## Arguments
+
+- No arguments: run `mvn spotless:apply` at the repo root across all modules.
+- `-pl <module>`: scope to a single Maven module (e.g.
+  `-pl openmetadata-service`). Useful when only one module changed and you want
+  a faster run.
+- `--check`: run `mvn spotless:check` instead of `apply`. Use to confirm the
+  tree is clean without touching files (e.g. to verify before push).
+
+## Process
+
+### Step 1: Run Spotless
+
+From the repo root:
+
+```bash
+mvn spotless:apply                 # default — formats everything
+# or
+mvn -pl <module> spotless:apply    # scoped to one module
+# or
+mvn spotless:check                 # verify only, don't write
+```
+
+Spotless is fast (seconds, no compilation). If it fails with a plugin error
+(not a formatting diff), surface the error and stop — do not try to hand-edit
+formatting around the failure.
+
+### Step 2: Check what changed
+
+```bash
+git status --short
+git diff --stat
+```
+
+Expect reformatting in `.java` files only. If Spotless touches `pom.xml` or
+other non-Java files, that's also fine — Spotless is configured for those too
+in this repo.
+
+### Step 3: Stage and commit (only if the user asked to commit)
+
+Do NOT auto-commit. Report the changed file list to the user and let them
+decide whether to fold the formatting into the in-progress commit or make a
+separate "Fix Java checkstyle" commit. Follow the repo convention: the
+existing branch history already uses `Fix Java checkstyle` as the commit title
+for bot-triggered formatting-only commits.
+
+## Notes
+
+- Spotless config lives in the root `pom.xml` (`spotless-maven-plugin`
+  section). Do not redefine formatting rules inline in source files.
+- If Spotless keeps rewriting a change the user just made, re-read the config
+  — Spotless is the source of truth, not the IDE.
+- The analogous UI command is `yarn pretty` (see the `test-locally` skill /
+  CLAUDE.md for the UI lint flow); this skill is Java-only.

.claude/skills/ui-checkstyle/SKILL.md

@@ -0,0 +1,132 @@
+---
+name: ui-checkstyle
+description: Run the exact ESLint + Prettier + organize-imports sequence that CI's `UI Checkstyle` jobs (`lint-src`, `lint-playwright`, `lint-core-components`) run — on just the files the PR changed — and fail the task if any file ends up with a diff. Invoke after authoring or modifying any `.ts`, `.tsx`, `.js`, `.jsx`, or `.json` file under `openmetadata-ui/src/main/resources/ui/src/`, `.../playwright/`, or `openmetadata-ui-core-components/src/main/resources/ui/src/`, or when CI reports a "UI Checkstyle" job failure on the PR.
+user-invocable: true
+argument-hint: "[--src] [--playwright] [--core-components] [--all] [--check]"
+allowed-tools:
+  - Bash
+  - Read
+  - Grep
+  - Glob
+---
+
+# UI Checkstyle / ESLint + Prettier + organize-imports
+
+The `UI Checkstyle` GitHub workflow
+(`.github/workflows/ui-checkstyle.yml`) runs three per-area jobs:
+`lint-src` (`openmetadata-ui/src/main/resources/ui/src/...`),
+`lint-playwright` (`.../playwright/...`),
+`lint-core-components`
+(`openmetadata-ui-core-components/src/main/resources/ui/src/...`). Each job
+reformats only the files changed in the PR and fails if the reformat produces
+any diff — i.e. the committed tree must already be formatted.
+
+This skill runs the same sequence locally so the CI never has to ask.
+
+## When to activate
+
+- The user asks to "fix UI checkstyle", "fix UI lint", "run prettier", "run
+  eslint", "fix the UI format", "apply UI format", or similar.
+- CI posts a `UI Checkstyle / lint-src|lint-playwright|lint-core-components`
+  failure (the bot lists the modified files in the job summary).
+- After the assistant has finished authoring or editing any `.ts`/`.tsx`/
+  `.js`/`.jsx`/`.json` under the three UI trees — before opening a PR or
+  pushing a commit that touches UI.
+
+## Arguments
+
+- `--src` (default for files under `openmetadata-ui/.../ui/src/`)
+- `--playwright` (files under `.../ui/playwright/`)
+- `--core-components` (files under `openmetadata-ui-core-components/...`)
+- `--all` — run all three areas
+- `--check` — verify only: run the sequence in a dry-run pass and report
+  which files are still dirty, without writing. Useful before push.
+
+If invoked with no flag, auto-detect the affected areas from
+`git diff --name-only origin/main...HEAD` and run only those.
+
+## Process
+
+### Step 1: Compute the file list
+
+For each area you are running against:
+
+```bash
+# from the repo root
+git diff --name-only origin/main...HEAD -- \
+  'openmetadata-ui/src/main/resources/ui/src/**/*.{ts,tsx,js,jsx,json}' \
+  | sed 's|openmetadata-ui/src/main/resources/ui/||' > /tmp/src_files.txt
+
+git diff --name-only origin/main...HEAD -- \
+  'openmetadata-ui/src/main/resources/ui/playwright/**/*.{ts,tsx,js,jsx}' \
+  | sed 's|openmetadata-ui/src/main/resources/ui/||' > /tmp/pw_files.txt
+
+git diff --name-only origin/main...HEAD -- \
+  'openmetadata-ui-core-components/**/*.{ts,tsx,js,jsx,json}' \
+  | sed 's|openmetadata-ui-core-components/src/main/resources/ui/||' \
+  > /tmp/core_files.txt
+```
+
+Skip any list that is empty — that area has no changes so the CI job for it
+wouldn't run anyway.
+
+### Step 2: Run the CI sequence
+
+From the corresponding working directory:
+
+```bash
+cd openmetadata-ui/src/main/resources/ui   # or .../openmetadata-ui-core-components/src/main/resources/ui
+
+# 1) imports first — organize-imports-cli only exists for the ui module
+cat /tmp/src_files.txt | xargs ./node_modules/.bin/organize-imports-cli
+
+# 2) eslint --fix (same flags CI uses)
+NODE_OPTIONS='--max-old-space-size=8192' cat /tmp/src_files.txt \
+  | xargs ./node_modules/.bin/eslint --no-error-on-unmatched-pattern --fix
+
+# 3) prettier --write — this MUST run after organize-imports because
+#    organize-imports uses 4-space indentation / drops trailing commas,
+#    and prettier then puts them back to the repo's 2-space + trailing-comma
+#    style. Running them in the other order leaves a dirty diff.
+cat /tmp/src_files.txt \
+  | xargs ./node_modules/.bin/prettier \
+      --config './.prettierrc.yaml' --ignore-path './.prettierignore' \
+      --write
+```
+
+For playwright, use the same three commands on `/tmp/pw_files.txt`.
+For core-components, the organize-imports step is skipped (no CLI there) —
+just eslint + prettier.
+
+### Step 3: Report what changed
+
+```bash
+cd <repo root>
+git status --short   # should list only .ts/.tsx/.js/.jsx/.json files
+git diff --stat
+```
+
+If `git status --short` is empty, the tree is already clean — tell the user
+and stop.
+
+### Step 4: Commit (only if the user asked to)
+
+Do NOT auto-commit. Surface the list of modified files to the user; they
+decide whether to fold the reformat into the in-progress commit or create a
+dedicated "Fix UI checkstyle" commit (matches the repo's existing history for
+bot-triggered formatting-only commits).
+
+## Notes
+
+- The `--check` mode mirrors CI's behavior: run the three commands and then
+  verify `git status --short` is empty. Revert any writes before exiting so
+  the user's working tree isn't touched.
+- If ESLint reports hard errors (not warnings, not auto-fixable), stop and
+  surface them — they need a real code change, not a format pass. Warnings
+  (e.g. `playwright/no-wait-for-selector`) don't fail CI and can be left.
+- The analogous Java command is `mvn spotless:apply` — see the
+  `java-checkstyle` skill.
+- TypeScript type-check errors (`tsc`) are a separate concern and are
+  *not* fixed by this skill — the `tsc-src` / `tsc-playwright` jobs are
+  currently either skipped or have their own failures surfaced via the CI
+  report.

AGENTS.md

@@ -193,7 +193,12 @@ yarn parse-schema              # Parse JSON schemas for frontend (connection and
 - If the code needs a comment to be understood, refactor the code to be clearer instead
 
 ### Java Code Requirements
-- **Always mention** running `mvn spotless:apply` when generating/modifying .java files
+- **Always run `mvn spotless:apply`** before finishing any task that touched
+  `.java` files. CI runs `mvn spotless:check` and will fail the PR otherwise
+  (bot's exact phrasing: "Please run `mvn spotless:apply` in the root of your
+  repository and commit the changes to this PR"). Scope with `-pl <module>`
+  for speed if only one module changed. A reusable procedure is written up at
+  `.agents/skills/java-checkstyle/SKILL.md`.
 - Use clear, descriptive variable and method names instead of comments
 - Follow existing project patterns and conventions
 - Generate production-ready code, not tutorial code
@@ -202,6 +207,14 @@ yarn parse-schema              # Parse JSON schemas for frontend (connection and
 - Do not import wild-card packages instead import exactly required packages
 
 ### TypeScript/Frontend Code Requirements
+- **Always run the UI checkstyle sequence** before finishing any task that
+  touched `.ts`/`.tsx`/`.js`/`.jsx`/`.json` under
+  `openmetadata-ui/src/main/resources/ui/src/`, `.../playwright/`, or
+  `openmetadata-ui-core-components/src/main/resources/ui/src/`. CI's
+  `UI Checkstyle / lint-src|lint-playwright|lint-core-components` jobs fail
+  the PR otherwise. Order matters: `organize-imports-cli` → `eslint --fix` →
+  `prettier --write`. A reusable procedure lives at
+  `.agents/skills/ui-checkstyle/SKILL.md`.
 - **NEVER use `any` type** in TypeScript code - always use proper types
 - Use `unknown` when the type is truly unknown and add type guards
 - Import types from existing type definitions (e.g., `RJSFSchema` from `@rjsf/utils`)