feat: add codemod to migrate template-lint-disable comments

Adds a one-shot codemod that rewrites ember-template-lint comment
directives to ESLint-native equivalents, so projects migrating to
eslint-plugin-ember can keep their in-template suppression comments
working without reimplementing ETL's directive semantics as an ESLint
processor.

Scope is grounded in what ETL itself parses today
(lib/rules/_base.js:247-337):

  - Mustache comments only ({{! ... }} and {{!-- ... --}}); HTML
    comments are skipped because ETL does not honour directives in
    them either.
  - template-lint-disable / template-lint-enable rewrite to
    eslint-disable / eslint-enable with rules remapped from the bare
    ETL name (no-foo) to the plugin rule ID (ember/template-no-foo).
  - template-lint-disable-tree / -enable-tree and
    template-lint-configure[-tree] are left unchanged with a warning;
    they have no ESLint equivalent (tree scope / in-template rule
    config respectively).
  - Unknown rule names are still rewritten so they surface in lint
    output, with a warning.

Includes a CLI entry (dry-run by default, --write to apply) and 26
tests covering simple and block forms, multi-line block comments,
quoted and whitespace-separated rule lists, skip+warn paths, line
numbers in warnings, idempotency, and context preservation.

README gains a "Rewriting {{! template-lint-disable }} comments"
subsection under the ETL migration guide.

Author: johanrd

README.md

@@ -174,6 +174,49 @@ export default [
 
 `recommended-template` mirrors the ember-template-lint `recommended` preset.
 
+### Rewriting `{{! template-lint-disable }}` comments
+
+ESLint does not recognise `template-lint-disable` / `template-lint-enable`
+comments. The plugin ships a codemod that rewrites them to the equivalent
+ESLint-native directives, which this plugin already honours in mustache
+comments inside `.hbs`, `.gjs`, and `.gts` files.
+
+```sh
+# Dry run — reports planned changes and warnings, writes nothing.
+node node_modules/eslint-plugin-ember/scripts/migrate-template-lint-directives.js app/ tests/
+
+# Apply.
+node node_modules/eslint-plugin-ember/scripts/migrate-template-lint-directives.js --write app/ tests/
+```
+
+Example rewrites:
+
+| Before | After |
+| --- | --- |
+| `{{! template-lint-disable no-bare-strings }}` | `{{! eslint-disable ember/template-no-bare-strings }}` |
+| `{{!-- template-lint-disable no-bare-strings --}}` | `{{!-- eslint-disable ember/template-no-bare-strings --}}` |
+| `{{! template-lint-enable no-bare-strings }}` | `{{! eslint-enable ember/template-no-bare-strings }}` |
+| `{{! template-lint-disable }}` (all rules) | `{{! eslint-disable }}` |
+
+Scope carries over directly: a bare disable is line-based block scope — open
+until a matching `eslint-enable` or end of file — which is how ESLint itself
+treats `eslint-disable` / `eslint-enable` pairs.
+
+Directives with no ESLint equivalent are left **unchanged** with a warning:
+
+- `template-lint-disable-tree` / `template-lint-enable-tree` — ESLint has no
+  tree scope. Rewrite manually as a block-scoped `eslint-disable` /
+  `eslint-enable` pair spanning the relevant element.
+- `template-lint-configure` / `template-lint-configure-tree` — in-template
+  rule configuration has no ESLint equivalent. Move the configuration to
+  your flat config file.
+
+Unknown rule names (no matching `ember/template-*` rule in this plugin) are
+still rewritten with a warning so you can review and remove them.
+
+HTML comments (`<!-- template-lint-disable -->`) are not transformed —
+ember-template-lint itself does not parse directives from HTML comments.
+
 ## 🧰 Configurations
 
 <!-- begin auto-generated configs list -->

scripts/migrate-template-lint-directives.js

@@ -0,0 +1,158 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const BLOCK_REGEX = /\{\{!--([\s\S]*?)--\}\}/g;
+const SIMPLE_REGEX = /\{\{!(?!--)([^}]*?)\}\}/g;
+const DIRECTIVE_RE =
+  /^template-lint-(disable-tree|enable-tree|configure-tree|disable|enable|configure)(?:\s+([\s\S]*))?$/;
+
+function parseRules(rest) {
+  return rest
+    .split(/\s+/)
+    .filter(Boolean)
+    .map((r) => r.replace(/^['"]|['"]$/g, ''));
+}
+
+function rewriteDirective(body, form, knownRules, warn) {
+  const match = body.trim().match(DIRECTIVE_RE);
+  if (!match) return null;
+  const name = match[1];
+  const rest = (match[2] || '').trim();
+
+  if (name.startsWith('configure')) {
+    warn(
+      `template-lint-${name} has no ESLint equivalent; move configuration to your flat config file`
+    );
+    return null;
+  }
+  if (name.endsWith('-tree')) {
+    warn(
+      `template-lint-${name} (tree scope) has no ESLint equivalent; rewrite manually as a block-scoped eslint-disable/enable pair`
+    );
+    return null;
+  }
+
+  const rules = parseRules(rest);
+  const unknown = [];
+  const mapped = rules.map((r) => {
+    const pluginRuleId = `template-${r}`;
+    if (!knownRules.has(pluginRuleId)) unknown.push(r);
+    return `ember/${pluginRuleId}`;
+  });
+  if (unknown.length > 0) {
+    warn(
+      `no matching rule in eslint-plugin-ember for: ${unknown.join(
+        ', '
+      )} (comment still rewritten — verify or remove)`
+    );
+  }
+
+  const action = name === 'disable' ? 'eslint-disable' : 'eslint-enable';
+  const ruleList = mapped.length > 0 ? ' ' + mapped.join(', ') : '';
+  return form === 'block'
+    ? `{{!-- ${action}${ruleList} --}}`
+    : `{{! ${action}${ruleList} }}`;
+}
+
+function computeLine(text, offset) {
+  let line = 1;
+  for (let i = 0; i < offset && i < text.length; i++) {
+    if (text.charCodeAt(i) === 10) line++;
+  }
+  return line;
+}
+
+function transform(source, { knownRules, onWarn } = {}) {
+  const warnings = [];
+  const emit = (msg) => {
+    warnings.push(msg);
+    if (onWarn) onWarn(msg);
+  };
+  const changes = [];
+
+  const scan = (regex, form) => {
+    for (const m of source.matchAll(regex)) {
+      const line = computeLine(source, m.index);
+      const rewritten = rewriteDirective(m[1], form, knownRules, (w) =>
+        emit(`line ${line}: ${w}`)
+      );
+      if (rewritten != null) {
+        changes.push({ start: m.index, end: m.index + m[0].length, replacement: rewritten });
+      }
+    }
+  };
+  scan(BLOCK_REGEX, 'block');
+  scan(SIMPLE_REGEX, 'simple');
+
+  changes.sort((a, b) => b.start - a.start);
+  let output = source;
+  for (const c of changes) {
+    output = output.slice(0, c.start) + c.replacement + output.slice(c.end);
+  }
+
+  return { output, warnings, changed: changes.length > 0 };
+}
+
+function loadKnownRules() {
+  const rulesDir = path.join(__dirname, '..', 'lib', 'rules');
+  return new Set(
+    fs
+      .readdirSync(rulesDir)
+      .filter((f) => f.endsWith('.js'))
+      .map((f) => f.slice(0, -3))
+  );
+}
+
+module.exports = { transform, parseRules, loadKnownRules };
+
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const write = args.includes('--write');
+  const inputs = args.filter((a) => !a.startsWith('--'));
+
+  if (inputs.length === 0) {
+    console.error(
+      'usage: migrate-template-lint-directives.js [--write] <files-or-dirs>...\n' +
+        '  Without --write, performs a dry run and reports planned changes.'
+    );
+    process.exit(1);
+  }
+
+  const knownRules = loadKnownRules();
+  const files = [];
+  for (const p of inputs) {
+    const stat = fs.statSync(p);
+    if (stat.isDirectory()) {
+      for (const e of fs.readdirSync(p, { recursive: true })) {
+        if (/\.(hbs|gjs|gts)$/.test(e)) files.push(path.join(p, e));
+      }
+    } else {
+      files.push(p);
+    }
+  }
+
+  let changedFiles = 0;
+  let warningCount = 0;
+  for (const file of files) {
+    const src = fs.readFileSync(file, 'utf8');
+    const { output, warnings, changed } = transform(src, { knownRules });
+    if (changed) {
+      changedFiles++;
+      if (write) fs.writeFileSync(file, output, 'utf8');
+      console.log(`${write ? 'wrote' : 'would write'}: ${file}`);
+    }
+    for (const w of warnings) {
+      warningCount++;
+      console.warn(`${file}: ${w}`);
+    }
+  }
+
+  console.log(
+    `\n${changedFiles} file(s) ${write ? 'rewritten' : 'would be rewritten'}, ${warningCount} warning(s)`
+  );
+  if (!write && changedFiles > 0) {
+    console.log('Re-run with --write to apply changes.');
+  }
+}