[ci] Lint yamls upon commit (elastic#235181)

## Summary
We've seen earlier where we've edited yaml files, and managed to push
them with some syntax issues. This adds a safeguard locally to try to
avoid those issues.

- Refactors `run_precommit_hook.js` to allow for more checks
- Adds a yaml linting step to the pre-commit hook
- (unrelated) Clarifies missing bootstrap error (*)


(*)
If you've wanted to get the TS project list after a branch switch, it
gave this error:
```
ts_project.ts:48
    matches: knownPaths.filter(matcher),
                        ^
TypeError: knownPaths.filter is not a function
    at map (ts_project.ts:48:25)
```
Meaning, you should re-bootstrap. It's now more explicit with an error:
```
ts_project.ts:76
      throw new Error('TS Project map missing, make sure you run `yarn kbn bootstrap`');
            ^
Error: TS Project map missing, make sure you run `yarn kbn bootstrap`
    at Function.loadAll (ts_project.ts:76:13)
```

---------

Co-authored-by: Copilot <[email protected]>

Author: delanni

packages/kbn-ts-projects/ts_project.ts

@@ -72,6 +72,10 @@ export class TsProject {
 
     const tsConfigRepoRels: string[] = JSON.parse(Fs.readFileSync(mapPath, 'utf8'));
 
+    if (!tsConfigRepoRels || !tsConfigRepoRels.length) {
+      throw new Error('TS Project map missing, make sure you run `yarn kbn bootstrap`');
+    }
+
     const ignores = expand('ignore', options.ignore, tsConfigRepoRels);
     const disableTypeCheck = expand('disableTypeCheck', options.disableTypeCheck, tsConfigRepoRels);
 

src/dev/run_precommit_hook.js

@@ -10,18 +10,141 @@
 import SimpleGit from 'simple-git';
 
 import { run } from '@kbn/dev-cli-runner';
-import { createFlagError, combineErrors } from '@kbn/dev-cli-errors';
+import { createFlagError } from '@kbn/dev-cli-errors';
 import { REPO_ROOT } from '@kbn/repo-info';
 import * as Eslint from './eslint';
 import * as Stylelint from './stylelint';
 import { getFilesForCommit, checkFileCasing } from './precommit_hook';
+import { load as yamlLoad } from 'js-yaml';
+import { readFile } from 'fs/promises';
+import { extname } from 'path';
+
+class CheckResult {
+  constructor(checkName) {
+    this.checkName = checkName;
+    this.errors = [];
+    this.succeeded = true;
+  }
+
+  addError(error) {
+    this.succeeded = false;
+    this.errors.push(error);
+  }
+
+  toString() {
+    if (this.succeeded) {
+      return `✓ ${this.checkName}: Passed`;
+    } else {
+      return [`✗ ${this.checkName}: Failed`, ...this.errors.map((err) => `  - ${err}`)].join('\n');
+    }
+  }
+}
+
+class PrecommitCheck {
+  constructor(name) {
+    this.name = name;
+  }
+
+  async execute() {
+    throw new Error('execute() must be implemented by check class');
+  }
+
+  async runSafely(log, files, options) {
+    const result = new CheckResult(this.name);
+    try {
+      await this.execute(log, files, options);
+    } catch (error) {
+      if (error.errors) {
+        error.errors.forEach((err) => result.addError(err.message || err.toString()));
+      } else {
+        result.addError(error.message || error.toString());
+      }
+    }
+    return result;
+  }
+}
+
+class FileCasingCheck extends PrecommitCheck {
+  constructor() {
+    super('File Casing');
+  }
+
+  async execute(log, files) {
+    await checkFileCasing(log, files);
+  }
+}
+
+class LinterCheck extends PrecommitCheck {
+  constructor(name, linter) {
+    super(name);
+    this.linter = linter;
+  }
+
+  async execute(log, files, options) {
+    const filesToLint = await this.linter.pickFilesToLint(log, files);
+    if (filesToLint.length > 0) {
+      await this.linter.lintFiles(log, filesToLint, {
+        fix: options.fix,
+      });
+
+      if (options.fix && options.stage) {
+        const simpleGit = new SimpleGit(REPO_ROOT);
+        await simpleGit.add(filesToLint);
+      }
+    }
+  }
+}
+
+class YamlLintCheck extends PrecommitCheck {
+  constructor() {
+    super('YAML Lint');
+  }
+
+  isYamlFile(filePath) {
+    const ext = extname(filePath).toLowerCase();
+    return ext === '.yml' || ext === '.yaml';
+  }
+
+  async execute(log, files) {
+    const yamlFiles = files.filter((file) => this.isYamlFile(file.getRelativePath()));
+
+    if (yamlFiles.length === 0) {
+      log.verbose('No YAML files to check');
+      return;
+    }
+
+    log.verbose(`Checking ${yamlFiles.length} YAML files for syntax errors`);
+
+    const errors = [];
+    for (const file of yamlFiles) {
+      try {
+        const content = await readFile(file.getAbsolutePath(), 'utf8');
+        yamlLoad(content, {
+          filename: file.getRelativePath(),
+        });
+      } catch (error) {
+        errors.push(`Error in ${file.getRelativePath()}:\n${error.message}`);
+      }
+    }
+
+    if (errors.length > 0) {
+      throw new Error(errors.join('\n\n'));
+    }
+  }
+}
+
+const PRECOMMIT_CHECKS = [
+  new FileCasingCheck(),
+  new LinterCheck('ESLint', Eslint),
+  new LinterCheck('StyleLint', Stylelint),
+  new YamlLintCheck(),
+];
 
 run(
   async ({ log, flags }) => {
     process.env.IS_KIBANA_PRECOMIT_HOOK = 'true';
 
     const files = await getFilesForCommit(flags.ref);
-    const errors = [];
 
     const maxFilesCount = flags['max-files']
       ? Number.parseInt(String(flags['max-files']), 10)
@@ -37,33 +160,33 @@ run(
       return;
     }
 
-    try {
-      await checkFileCasing(log, files);
-    } catch (error) {
-      errors.push(error);
-    }
+    log.verbose('Running pre-commit checks...');
+    const results = await Promise.all(
+      PRECOMMIT_CHECKS.map(async (check) => {
+        const startTime = Date.now();
+        const result = await check.runSafely(log, files, {
+          fix: flags.fix,
+          stage: flags.stage,
+        });
+        const duration = Date.now() - startTime;
+        log.verbose(`${check.name} completed in ${duration}ms`);
+        return result;
+      })
+    );
 
-    for (const Linter of [Eslint, Stylelint]) {
-      const filesToLint = await Linter.pickFilesToLint(log, files);
-      if (filesToLint.length > 0) {
-        try {
-          await Linter.lintFiles(log, filesToLint, {
-            fix: flags.fix,
-          });
-
-          if (flags.fix && flags.stage) {
-            const simpleGit = new SimpleGit(REPO_ROOT);
-            await simpleGit.add(filesToLint);
-          }
-        } catch (error) {
-          errors.push(error);
-        }
-      }
-    }
+    const failedChecks = results.filter((result) => !result.succeeded);
+
+    if (failedChecks.length > 0) {
+      const errorReport = [
+        '\nPre-commit checks failed:',
+        ...results.map((result) => result.toString()),
+        '\nPlease fix the above issues before committing.',
+      ].join('\n');
 
-    if (errors.length) {
-      throw combineErrors(errors);
+      throw new Error(errorReport);
     }
+
+    log.success('All pre-commit checks passed!');
   },
   {
     description: `
@@ -77,7 +200,7 @@ run(
         stage: true,
       },
       help: `
-        --fix              Execute eslint in --fix mode
+        --fix              Execute checks with possible fixes
         --max-files        Max files number to check against. If exceeded the script will skip the execution
         --ref              Run checks against any git ref files (example HEAD or <commit_sha>) instead of running against staged ones
         --no-stage         By default when using --fix the changes are staged, use --no-stage to disable that behavior

src/platform/packages/shared/kbn-dev-utils/src/precommit_hook/script_source.ts

@@ -99,7 +99,7 @@ execute_precommit_hook() {
 
 execute_precommit_hook || {
   echo "Pre-commit hook failed (add --no-verify to bypass)";
-  echo '  For eslint failures you can try running \`node scripts/precommit_hook --fix\`';
+  echo '  For fixable failures you can try running \`node scripts/precommit_hook --fix\`';
   exit 1;
 }