@craft-ng/dev-tools 0.5.0-beta.1 → 0.5.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@craft-ng/dev-tools",
-  "version": "0.5.0-beta.1",
+  "version": "0.5.0-beta.2",
   "description": "Development tools for ng-craft: ESLint configs, ESLint rules, and codemods",
   "type": "module",
   "main": "./src/index.js",

package/src/eslint-rules/craft-computed-name-match.cjs

@@ -0,0 +1,125 @@
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        "Ensure craftComputed(name, ...) is called with a string literal first argument that matches the declared variable or class property name.",
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      missingName:
+        "craftComputed must be called with a string literal name matching '{{declaredName}}' as the first argument.",
+      mismatchedName:
+        "craftComputed first argument '{{actual}}' must match the declared name '{{declaredName}}'.",
+    },
+  },
+  create(context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+
+    return {
+      CallExpression(node) {
+        if (
+          node.callee.type !== 'Identifier' ||
+          node.callee.name !== 'craftComputed'
+        ) {
+          return;
+        }
+
+        const declaredName = getDeclaredName(node);
+        if (!declaredName) {
+          return;
+        }
+
+        const firstArg = node.arguments[0];
+
+        if (!firstArg) {
+          context.report({
+            node,
+            messageId: 'missingName',
+            data: { declaredName },
+            fix(fixer) {
+              const openParen = sourceCode.getTokenAfter(
+                node.callee,
+                (token) => token.type === 'Punctuator' && token.value === '(',
+              );
+              if (!openParen) return null;
+              return fixer.insertTextAfter(openParen, `'${declaredName}'`);
+            },
+          });
+          return;
+        }
+
+        if (isStringLiteral(firstArg)) {
+          const actual = getStringLiteralValue(firstArg);
+          if (actual === declaredName) {
+            return;
+          }
+          context.report({
+            node: firstArg,
+            messageId: 'mismatchedName',
+            data: { declaredName, actual },
+            fix(fixer) {
+              return fixer.replaceText(firstArg, `'${declaredName}'`);
+            },
+          });
+          return;
+        }
+
+        context.report({
+          node: firstArg,
+          messageId: 'missingName',
+          data: { declaredName },
+          fix(fixer) {
+            return fixer.insertTextBefore(firstArg, `'${declaredName}', `);
+          },
+        });
+      },
+    };
+  },
+};
+
+function getDeclaredName(callNode) {
+  const parent = callNode.parent;
+  if (!parent) return undefined;
+
+  if (
+    parent.type === 'VariableDeclarator' &&
+    parent.init === callNode &&
+    parent.id.type === 'Identifier'
+  ) {
+    return parent.id.name;
+  }
+
+  if (
+    parent.type === 'PropertyDefinition' &&
+    parent.value === callNode &&
+    !parent.computed &&
+    parent.key.type === 'Identifier'
+  ) {
+    return parent.key.name;
+  }
+
+  return undefined;
+}
+
+function isStringLiteral(node) {
+  if (node.type === 'Literal' && typeof node.value === 'string') {
+    return true;
+  }
+  if (
+    node.type === 'TemplateLiteral' &&
+    node.expressions.length === 0 &&
+    node.quasis.length === 1
+  ) {
+    return true;
+  }
+  return false;
+}
+
+function getStringLiteralValue(node) {
+  if (node.type === 'Literal') {
+    return node.value;
+  }
+  return node.quasis[0].value.cooked;
+}

package/src/eslint-rules/craft-method-name-match.cjs

@@ -0,0 +1,166 @@
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        "Ensure craftMethod(name, ...) is called with a string literal first argument (or { name } object) that matches the declared variable or class property name.",
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      missingName:
+        "craftMethod must be called with a string literal name matching '{{declaredName}}' as the first argument.",
+      mismatchedName:
+        "craftMethod first argument '{{actual}}' must match the declared name '{{declaredName}}'.",
+    },
+  },
+  create(context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+
+    return {
+      CallExpression(node) {
+        if (
+          node.callee.type !== 'Identifier' ||
+          node.callee.name !== 'craftMethod'
+        ) {
+          return;
+        }
+
+        const declaredName = getDeclaredName(node);
+        if (!declaredName) {
+          return;
+        }
+
+        const firstArg = node.arguments[0];
+
+        if (!firstArg) {
+          context.report({
+            node,
+            messageId: 'missingName',
+            data: { declaredName },
+            fix(fixer) {
+              const openParen = sourceCode.getTokenAfter(
+                node.callee,
+                (token) => token.type === 'Punctuator' && token.value === '(',
+              );
+              if (!openParen) return null;
+              return fixer.insertTextAfter(openParen, `'${declaredName}'`);
+            },
+          });
+          return;
+        }
+
+        // Handle object config form: { name: 'methodName', providers: [...] }
+        if (firstArg.type === 'ObjectExpression') {
+          const nameProp = firstArg.properties.find(
+            (p) =>
+              p.type === 'Property' &&
+              !p.computed &&
+              p.key.type === 'Identifier' &&
+              p.key.name === 'name',
+          );
+          if (!nameProp) {
+            context.report({
+              node: firstArg,
+              messageId: 'missingName',
+              data: { declaredName },
+            });
+            return;
+          }
+          const nameValue = nameProp.value;
+          if (isStringLiteral(nameValue)) {
+            const actual = getStringLiteralValue(nameValue);
+            if (actual === declaredName) {
+              return;
+            }
+            context.report({
+              node: nameValue,
+              messageId: 'mismatchedName',
+              data: { declaredName, actual },
+              fix(fixer) {
+                return fixer.replaceText(nameValue, `'${declaredName}'`);
+              },
+            });
+          } else {
+            context.report({
+              node: nameValue,
+              messageId: 'mismatchedName',
+              data: { declaredName, actual: sourceCode.getText(nameValue) },
+            });
+          }
+          return;
+        }
+
+        if (isStringLiteral(firstArg)) {
+          const actual = getStringLiteralValue(firstArg);
+          if (actual === declaredName) {
+            return;
+          }
+          context.report({
+            node: firstArg,
+            messageId: 'mismatchedName',
+            data: { declaredName, actual },
+            fix(fixer) {
+              return fixer.replaceText(firstArg, `'${declaredName}'`);
+            },
+          });
+          return;
+        }
+
+        context.report({
+          node: firstArg,
+          messageId: 'missingName',
+          data: { declaredName },
+          fix(fixer) {
+            return fixer.insertTextBefore(firstArg, `'${declaredName}', `);
+          },
+        });
+      },
+    };
+  },
+};
+
+function getDeclaredName(callNode) {
+  const parent = callNode.parent;
+  if (!parent) return undefined;
+
+  if (
+    parent.type === 'VariableDeclarator' &&
+    parent.init === callNode &&
+    parent.id.type === 'Identifier'
+  ) {
+    return parent.id.name;
+  }
+
+  if (
+    parent.type === 'PropertyDefinition' &&
+    parent.value === callNode &&
+    !parent.computed &&
+    parent.key.type === 'Identifier'
+  ) {
+    return parent.key.name;
+  }
+
+  return undefined;
+}
+
+function isStringLiteral(node) {
+  if (node.type === 'Literal' && typeof node.value === 'string') {
+    return true;
+  }
+  if (
+    node.type === 'TemplateLiteral' &&
+    node.expressions.length === 0 &&
+    node.quasis.length === 1
+  ) {
+    return true;
+  }
+  return false;
+}
+
+function getStringLiteralValue(node) {
+  if (node.type === 'Literal') {
+    return node.value;
+  }
+  return node.quasis[0].value.cooked;
+}

package/src/eslint-rules/index.cjs

@@ -2,11 +2,16 @@ const brandAngularGenDepsRequired = require('./brand-angular-gen-deps-required.c
 const brandAngularDepsMatch = require('./brand-angular-deps-match.cjs');
 const appStartRegistryMatch = require('./app-start-registry-match.cjs');
 const componentTestGenDepsMatch = require('./component-test-gen-deps-match.cjs');
+const craftMethodNameMatch = require('./craft-method-name-match.cjs');
+const craftComputedNameMatch = require('./craft-computed-name-match.cjs');
+const preferCraftComputed = require('./prefer-craft-computed.cjs');
 const noAngularInject = require('./no-angular-inject.cjs');
 const noAngularSignalForms = require('./no-angular-signal-forms.cjs');
+const provideHostNameMatchComponent = require('./provide-host-name-match-component.cjs');
 const preferCraftHttpClient = require('./prefer-craft-http-client.cjs');
 const preferCraftService = require('./prefer-craft-service.cjs');
 const preferBrowserBoundaries = require('./prefer-browser-boundaries.cjs');
+const requireComponentMonitoring = require('./require-component-monitoring.cjs');
 
 module.exports = {
   rules: {
@@ -14,10 +19,15 @@ module.exports = {
     'brand-angular-gen-deps-required': brandAngularGenDepsRequired,
     'brand-angular-deps-match': brandAngularDepsMatch,
     'component-test-gen-deps-match': componentTestGenDepsMatch,
+    'craft-method-name-match': craftMethodNameMatch,
+    'craft-computed-name-match': craftComputedNameMatch,
+    'prefer-craft-computed': preferCraftComputed,
     'no-angular-inject': noAngularInject,
     'no-angular-signal-forms': noAngularSignalForms,
+    'provide-host-name-match-component': provideHostNameMatchComponent,
     'prefer-craft-http-client': preferCraftHttpClient,
     'prefer-craft-service': preferCraftService,
     'prefer-browser-boundaries': preferBrowserBoundaries,
+    'require-component-monitoring': requireComponentMonitoring,
   },
 };

package/src/eslint-rules/prefer-craft-computed.cjs

@@ -0,0 +1,105 @@
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        "Prefer craftComputed() over computed() from @angular/core for better observability and host name tracking.",
+    },
+    hasSuggestions: true,
+    schema: [],
+    messages: {
+      preferCraftComputed:
+        "Use craftComputed('{{name}}', ...) instead of computed() for better observability. craftComputed adds HostName tracking to the computed signal.",
+      preferCraftComputedUnnamed:
+        "Use craftComputed('name', ...) instead of computed() for better observability. craftComputed adds HostName tracking to the computed signal.",
+    },
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (
+          node.callee.type !== 'Identifier' ||
+          node.callee.name !== 'computed'
+        ) {
+          return;
+        }
+
+        if (!isAngularComputedImport(node, context)) {
+          return;
+        }
+
+        const declaredName = getDeclaredName(node);
+
+        if (declaredName) {
+          context.report({
+            node,
+            messageId: 'preferCraftComputed',
+            data: { name: declaredName },
+            suggest: [
+              {
+                desc: `Replace with craftComputed('${declaredName}', ...)`,
+                fix(fixer) {
+                  return fixer.replaceText(node.callee, 'craftComputed');
+                },
+              },
+            ],
+          });
+        } else {
+          context.report({
+            node,
+            messageId: 'preferCraftComputedUnnamed',
+          });
+        }
+      },
+    };
+  },
+};
+
+function getDeclaredName(callNode) {
+  const parent = callNode.parent;
+  if (!parent) return undefined;
+
+  if (
+    parent.type === 'VariableDeclarator' &&
+    parent.init === callNode &&
+    parent.id.type === 'Identifier'
+  ) {
+    return parent.id.name;
+  }
+
+  if (
+    parent.type === 'PropertyDefinition' &&
+    parent.value === callNode &&
+    !parent.computed &&
+    parent.key.type === 'Identifier'
+  ) {
+    return parent.key.name;
+  }
+
+  return undefined;
+}
+
+function isAngularComputedImport(callNode, context) {
+  const scope = context.getScope ? context.getScope() : context.sourceCode.getScope(callNode);
+
+  let currentScope = scope;
+  while (currentScope) {
+    for (const variable of currentScope.variables) {
+      if (variable.name === 'computed') {
+        for (const def of variable.defs) {
+          if (
+            def.type === 'ImportBinding' &&
+            def.parent &&
+            def.parent.source &&
+            def.parent.source.value === '@angular/core'
+          ) {
+            return true;
+          }
+        }
+      }
+    }
+    currentScope = currentScope.upper;
+  }
+
+  return false;
+}

package/src/eslint-rules/provide-host-name-match-component.cjs

@@ -0,0 +1,455 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const {
+  IndentationText,
+  Node,
+  Project,
+  QuoteKind,
+  SyntaxKind,
+} = require('ts-morph');
+
+const projectCache = new Map();
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        "Ensure Angular @Component and @Directive classes provide provideHostName('ClassName') in providers.",
+    },
+    fixable: 'code',
+    schema: [],
+  },
+  create(context) {
+    return {
+      'Program:exit'() {
+        const sourceCode = context.sourceCode ?? context.getSourceCode();
+        const filePath = getFilePath(context);
+        if (!filePath || !filePath.endsWith('.ts')) {
+          return;
+        }
+
+        const text = sourceCode.getText();
+        if (!text.includes('@Component') && !text.includes('@Directive')) {
+          return;
+        }
+
+        const sourceFile = getProjectSourceFile(
+          getProject(getCwd(context)),
+          filePath,
+          text,
+        );
+        const issues = collectHostNameIssues(sourceFile);
+        if (issues.length === 0) {
+          return;
+        }
+
+        const reportLoc = getNodeLoc(sourceCode, issues[0].reportNode);
+
+        for (const issue of issues) {
+          applyIssueFix(issue);
+        }
+        ensureProvideHostNameImport(sourceFile);
+
+        const fixedText = sourceFile.getFullText();
+        if (fixedText === text) {
+          return;
+        }
+
+        context.report({
+          loc: reportLoc,
+          message: formatIssueMessage(issues),
+          fix(fixer) {
+            return fixer.replaceTextRange([0, text.length], fixedText);
+          },
+        });
+      },
+    };
+  },
+};
+
+function getProject(cwd) {
+  let project = projectCache.get(cwd);
+  if (project) {
+    return project;
+  }
+
+  const manipulationSettings = {
+    indentationText: IndentationText.TwoSpaces,
+    quoteKind: QuoteKind.Single,
+  };
+  const tsConfigFilePath = path.join(cwd, 'tsconfig.json');
+  project = fs.existsSync(tsConfigFilePath)
+    ? new Project({
+        tsConfigFilePath,
+        manipulationSettings,
+      })
+    : new Project({
+        compilerOptions: {
+          experimentalDecorators: true,
+          target: 9,
+        },
+        manipulationSettings,
+      });
+
+  projectCache.set(cwd, project);
+  return project;
+}
+
+function getProjectSourceFile(project, filePath, text) {
+  const normalizedPath = path.resolve(filePath);
+  const existingSourceFile = project.getSourceFile(normalizedPath);
+  if (existingSourceFile) {
+    existingSourceFile.replaceWithText(text);
+    return existingSourceFile;
+  }
+
+  const sourceFile = project.addSourceFileAtPathIfExists(normalizedPath);
+  if (sourceFile) {
+    sourceFile.replaceWithText(text);
+    return sourceFile;
+  }
+
+  return project.createSourceFile(normalizedPath, text, { overwrite: true });
+}
+
+function getFilePath(context) {
+  const filePath = context.filename ?? context.getFilename();
+  if (!filePath || filePath === '<input>') {
+    return undefined;
+  }
+
+  return filePath;
+}
+
+function getCwd(context) {
+  return context.cwd ?? process.cwd();
+}
+
+function getNodeLoc(sourceCode, node) {
+  return {
+    start: sourceCode.getLocFromIndex(node.getStart()),
+    end: sourceCode.getLocFromIndex(node.getEnd()),
+  };
+}
+
+function collectHostNameIssues(sourceFile) {
+  const angularDecorators = collectAngularDecoratorNames(sourceFile);
+  if (
+    angularDecorators.componentNames.size === 0 &&
+    angularDecorators.directiveNames.size === 0 &&
+    angularDecorators.namespaceNames.size === 0
+  ) {
+    return [];
+  }
+
+  const issues = [];
+
+  for (const classDeclaration of sourceFile.getClasses()) {
+    const className = classDeclaration.getName();
+    if (!className) {
+      continue;
+    }
+
+    const decoratorMatch = findAngularDecorator(
+      classDeclaration,
+      angularDecorators,
+    );
+    if (!decoratorMatch) {
+      continue;
+    }
+
+    const metadata = getDecoratorMetadata(decoratorMatch.decorator);
+    if (!metadata) {
+      continue;
+    }
+
+    const providersProperty = getObjectProperty(metadata, 'providers');
+    if (!providersProperty) {
+      issues.push({
+        kind: 'missing-providers',
+        decoratorKind: decoratorMatch.kind,
+        className,
+        metadata,
+        reportNode: classDeclaration,
+      });
+      continue;
+    }
+
+    const providersArray = getArrayInitializer(providersProperty);
+    if (!providersArray) {
+      continue;
+    }
+
+    const hostNameCalls = findProvideHostNameCalls(providersArray);
+    if (hostNameCalls.length === 0) {
+      issues.push({
+        kind: 'missing-call',
+        decoratorKind: decoratorMatch.kind,
+        className,
+        providersArray,
+        reportNode: classDeclaration,
+      });
+      continue;
+    }
+
+    const expectedHostName = `${getHostNamePrefix(decoratorMatch.kind)}${className}`;
+    const matchingCall = hostNameCalls.find((callExpression) =>
+      isMatchingHostNameCall(callExpression, expectedHostName),
+    );
+    if (matchingCall) {
+      continue;
+    }
+
+    issues.push({
+      kind: 'mismatched-call',
+      decoratorKind: decoratorMatch.kind,
+      className,
+      callExpression: hostNameCalls[0],
+      reportNode: classDeclaration,
+    });
+  }
+
+  return issues;
+}
+
+function collectAngularDecoratorNames(sourceFile) {
+  const componentNames = new Set();
+  const directiveNames = new Set();
+  const namespaceNames = new Set();
+
+  for (const importDeclaration of sourceFile.getImportDeclarations()) {
+    if (importDeclaration.getModuleSpecifierValue() !== '@angular/core') {
+      continue;
+    }
+
+    for (const namedImport of importDeclaration.getNamedImports()) {
+      const importedName = namedImport.getName();
+      const localName = namedImport.getAliasNode()?.getText() ?? importedName;
+
+      if (importedName === 'Component') {
+        componentNames.add(localName);
+      }
+      if (importedName === 'Directive') {
+        directiveNames.add(localName);
+      }
+    }
+
+    const namespaceImport = importDeclaration.getNamespaceImport();
+    if (namespaceImport) {
+      namespaceNames.add(namespaceImport.getText());
+    }
+  }
+
+  return {
+    componentNames,
+    directiveNames,
+    namespaceNames,
+  };
+}
+
+function findAngularDecorator(classDeclaration, angularDecorators) {
+  for (const decorator of classDeclaration.getDecorators()) {
+    const expression = decorator.getExpression();
+    if (!Node.isCallExpression(expression)) {
+      continue;
+    }
+
+    const callee = expression.getExpression();
+    if (Node.isIdentifier(callee)) {
+      const decoratorName = callee.getText();
+      if (angularDecorators.componentNames.has(decoratorName)) {
+        return { decorator, kind: 'component' };
+      }
+      if (angularDecorators.directiveNames.has(decoratorName)) {
+        return { decorator, kind: 'directive' };
+      }
+      continue;
+    }
+
+    if (!Node.isPropertyAccessExpression(callee)) {
+      continue;
+    }
+
+    const objectExpression = callee.getExpression();
+    const propertyName = callee.getName();
+    if (
+      Node.isIdentifier(objectExpression) &&
+      angularDecorators.namespaceNames.has(objectExpression.getText())
+    ) {
+      if (propertyName === 'Component') {
+        return { decorator, kind: 'component' };
+      }
+      if (propertyName === 'Directive') {
+        return { decorator, kind: 'directive' };
+      }
+    }
+  }
+
+  return undefined;
+}
+
+function getHostNamePrefix(kind) {
+  return kind === 'directive' ? 'directive:' : 'component:';
+}
+
+function getDecoratorMetadata(decorator) {
+  const expression = decorator.getExpression();
+  if (!Node.isCallExpression(expression)) {
+    return undefined;
+  }
+
+  const [metadataArgument] = expression.getArguments();
+  if (!metadataArgument || !Node.isObjectLiteralExpression(metadataArgument)) {
+    return undefined;
+  }
+
+  return metadataArgument;
+}
+
+function getObjectProperty(objectLiteralExpression, name) {
+  const property = objectLiteralExpression
+    .getProperties()
+    .find(
+      (candidate) =>
+        Node.isPropertyAssignment(candidate) && candidate.getName() === name,
+    );
+
+  return Node.isPropertyAssignment(property) ? property : undefined;
+}
+
+function getArrayInitializer(propertyAssignment) {
+  const initializer = propertyAssignment.getInitializer();
+  if (!initializer || !Node.isArrayLiteralExpression(initializer)) {
+    return undefined;
+  }
+
+  return initializer;
+}
+
+function findProvideHostNameCalls(arrayLiteralExpression) {
+  return arrayLiteralExpression
+    .getElements()
+    .filter((element) => Node.isCallExpression(element))
+    .filter((callExpression) => isProvideHostNameCall(callExpression));
+}
+
+function isProvideHostNameCall(callExpression) {
+  const expression = callExpression.getExpression();
+  if (Node.isIdentifier(expression)) {
+    return expression.getText() === 'provideHostName';
+  }
+
+  if (Node.isPropertyAccessExpression(expression)) {
+    return expression.getName() === 'provideHostName';
+  }
+
+  return false;
+}
+
+function isMatchingHostNameCall(callExpression, expectedHostName) {
+  const [nameArgument] = callExpression.getArguments();
+  if (
+    !nameArgument ||
+    (!Node.isStringLiteral(nameArgument) &&
+      !Node.isNoSubstitutionTemplateLiteral(nameArgument))
+  ) {
+    return false;
+  }
+
+  return nameArgument.getLiteralText() === expectedHostName;
+}
+
+function applyIssueFix(issue) {
+  const expectedHostName = `${getHostNamePrefix(issue.decoratorKind)}${issue.className}`;
+  const expectedCall = `provideHostName('${expectedHostName}')`;
+
+  if (issue.kind === 'missing-providers') {
+    issue.metadata.addPropertyAssignment({
+      name: 'providers',
+      initializer: `[${expectedCall}]`,
+    });
+    return;
+  }
+
+  if (issue.kind === 'missing-call') {
+    issue.providersArray.addElement(expectedCall);
+    return;
+  }
+
+  if (issue.kind === 'mismatched-call') {
+    issue.callExpression.replaceWithText(expectedCall);
+  }
+}
+
+function ensureProvideHostNameImport(sourceFile) {
+  const coreImports = sourceFile
+    .getImportDeclarations()
+    .filter(
+      (importDeclaration) =>
+        importDeclaration.getModuleSpecifierValue() === '@craft-ng/core',
+    );
+
+  for (const importDeclaration of coreImports) {
+    const namedImports = importDeclaration.getNamedImports();
+    const directImport = namedImports.find(
+      (namedImport) =>
+        namedImport.getName() === 'provideHostName' &&
+        !namedImport.getAliasNode(),
+    );
+    if (directImport) {
+      return;
+    }
+  }
+
+  for (const importDeclaration of coreImports) {
+    for (const namedImport of importDeclaration.getNamedImports()) {
+      if (
+        namedImport.getName() === 'provideHostName' &&
+        namedImport.getAliasNode()
+      ) {
+        namedImport.remove();
+      }
+    }
+  }
+
+  const targetImport = coreImports.find(
+    (importDeclaration) => !importDeclaration.getNamespaceImport(),
+  );
+  if (targetImport) {
+    const hasNamedImport = targetImport
+      .getNamedImports()
+      .some((namedImport) => namedImport.getName() === 'provideHostName');
+    if (!hasNamedImport) {
+      targetImport.addNamedImport('provideHostName');
+    }
+    return;
+  }
+
+  const insertIndex = sourceFile
+    .getStatements()
+    .findIndex(
+      (statement) => statement.getKind() !== SyntaxKind.ImportDeclaration,
+    );
+
+  sourceFile.insertImportDeclaration(
+    insertIndex < 0 ? sourceFile.getImportDeclarations().length : insertIndex,
+    {
+      moduleSpecifier: '@craft-ng/core',
+      namedImports: ['provideHostName'],
+    },
+  );
+}
+
+function formatIssueMessage(issues) {
+  if (issues.length === 1) {
+    const issue = issues[0];
+    const expectedHostName = `${getHostNamePrefix(issue.decoratorKind)}${issue.className}`;
+    return `${issue.className} must include provideHostName('${expectedHostName}') in providers.`;
+  }
+
+  const classNames = [...new Set(issues.map((issue) => issue.className))].join(
+    ', ',
+  );
+  return `Classes must include provideHostName('<kind>:<ClassName>') in providers: ${classNames}.`;
+}

package/src/eslint-rules/require-component-monitoring.cjs

@@ -0,0 +1,212 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const {
+  IndentationText,
+  Project,
+  QuoteKind,
+  Scope,
+  SyntaxKind,
+} = require('ts-morph');
+
+const projectCache = new Map();
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        "Ensure Angular @Component and @Directive classes declare 'private readonly _monitoring = componentMonitoring()'.",
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      missingMonitoring:
+        "Component/Directive '{{className}}' must declare 'private readonly _monitoring = componentMonitoring()'.",
+    },
+  },
+  create(context) {
+    return {
+      'Program:exit'() {
+        const sourceCode = context.sourceCode ?? context.getSourceCode();
+        const filePath = getFilePath(context);
+        if (!filePath || !filePath.endsWith('.ts')) {
+          return;
+        }
+
+        const text = sourceCode.getText();
+        if (!text.includes('@Component') && !text.includes('@Directive')) {
+          return;
+        }
+
+        const sourceFile = getProjectSourceFile(
+          getProject(getCwd(context)),
+          filePath,
+          text,
+        );
+
+        const issues = collectMonitoringIssues(sourceFile);
+        if (issues.length === 0) {
+          return;
+        }
+
+        const reportLoc = getNodeLoc(sourceCode, issues[0].classDeclaration);
+
+        for (const issue of issues) {
+          applyMonitoringFix(issue);
+        }
+        ensureComponentMonitoringImport(sourceFile);
+
+        const fixedText = sourceFile.getFullText();
+        if (fixedText === text) {
+          return;
+        }
+
+        const classNames = issues.map((i) => i.className).join(', ');
+
+        context.report({
+          loc: reportLoc,
+          message: `Component(s) missing componentMonitoring(): ${classNames}`,
+          fix(fixer) {
+            return fixer.replaceTextRange([0, text.length], fixedText);
+          },
+        });
+      },
+    };
+  },
+};
+
+function getProject(cwd) {
+  let project = projectCache.get(cwd);
+  if (project) {
+    return project;
+  }
+
+  const manipulationSettings = {
+    indentationText: IndentationText.TwoSpaces,
+    quoteKind: QuoteKind.Single,
+  };
+  const tsConfigFilePath = path.join(cwd, 'tsconfig.json');
+  project = fs.existsSync(tsConfigFilePath)
+    ? new Project({ tsConfigFilePath, manipulationSettings })
+    : new Project({
+        compilerOptions: { experimentalDecorators: true, target: 9 },
+        manipulationSettings,
+      });
+
+  projectCache.set(cwd, project);
+  return project;
+}
+
+function getProjectSourceFile(project, filePath, text) {
+  const normalizedPath = path.resolve(filePath);
+  const existingSourceFile = project.getSourceFile(normalizedPath);
+  if (existingSourceFile) {
+    existingSourceFile.replaceWithText(text);
+    return existingSourceFile;
+  }
+
+  const sourceFile = project.addSourceFileAtPathIfExists(normalizedPath);
+  if (sourceFile) {
+    sourceFile.replaceWithText(text);
+    return sourceFile;
+  }
+
+  return project.createSourceFile(normalizedPath, text, { overwrite: true });
+}
+
+function getFilePath(context) {
+  const filePath = context.filename ?? context.getFilename();
+  if (!filePath || filePath === '<input>') {
+    return undefined;
+  }
+  return filePath;
+}
+
+function getCwd(context) {
+  return context.cwd ?? process.cwd();
+}
+
+function getNodeLoc(sourceCode, node) {
+  return {
+    start: sourceCode.getLocFromIndex(node.getStart()),
+    end: sourceCode.getLocFromIndex(node.getEnd()),
+  };
+}
+
+function isAngularComponentOrDirective(classDeclaration) {
+  for (const decorator of classDeclaration.getDecorators()) {
+    const name = decorator.getName();
+    if (name === 'Component' || name === 'Directive') {
+      return true;
+    }
+  }
+  return false;
+}
+
+function hasMonitoringProperty(classDeclaration) {
+  for (const prop of classDeclaration.getProperties()) {
+    if (
+      prop.getName() === '_monitoring' &&
+      prop.hasModifier(SyntaxKind.PrivateKeyword) &&
+      prop.isReadonly()
+    ) {
+      const initializer = prop.getInitializer();
+      if (
+        initializer &&
+        initializer.getKindName() === 'CallExpression' &&
+        initializer.getText().startsWith('componentMonitoring(')
+      ) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+function collectMonitoringIssues(sourceFile) {
+  const issues = [];
+
+  for (const classDeclaration of sourceFile.getClasses()) {
+    const className = classDeclaration.getName();
+    if (!className) continue;
+    if (!isAngularComponentOrDirective(classDeclaration)) continue;
+    if (hasMonitoringProperty(classDeclaration)) continue;
+
+    issues.push({ className, classDeclaration });
+  }
+
+  return issues;
+}
+
+function applyMonitoringFix(issue) {
+  const { classDeclaration } = issue;
+
+  // Insert as first property of the class
+  classDeclaration.insertProperty(0, {
+    name: '_monitoring',
+    scope: Scope.Private,
+    isReadonly: true,
+    initializer: 'componentMonitoring()',
+  });
+}
+
+function ensureComponentMonitoringImport(sourceFile) {
+  const craftNgCoreImport = sourceFile
+    .getImportDeclarations()
+    .find((imp) => imp.getModuleSpecifierValue() === '@craft-ng/core');
+
+  if (craftNgCoreImport) {
+    const namedImports = craftNgCoreImport.getNamedImports();
+    const alreadyImported = namedImports.some(
+      (ni) => ni.getName() === 'componentMonitoring',
+    );
+    if (!alreadyImported) {
+      craftNgCoreImport.addNamedImport('componentMonitoring');
+    }
+  } else {
+    sourceFile.addImportDeclaration({
+      moduleSpecifier: '@craft-ng/core',
+      namedImports: ['componentMonitoring'],
+    });
+  }
+}