feat(@angular-devkit/schematics): add schematics to generate ai context files.

* `ng generate config ai` to prompt support tools.
* `ng generate config ai --tool=gemini` to specify the tool.

Supported ai tools: gemini, claude, copilot, windsurf, cursor.

Author: JeanMeche

packages/angular_devkit/schematics/src/index.ts

@@ -23,6 +23,7 @@ export * from './rules/base';
 export * from './rules/call';
 export * from './rules/move';
 export * from './rules/random';
+export * from './rules/rename';
 export * from './rules/schematic';
 export * from './rules/template';
 export * from './rules/url';

packages/angular_devkit/schematics/src/rules/move.ts

@@ -10,6 +10,8 @@ import { join, normalize } from '@angular-devkit/core';
 import { Rule } from '../engine/interface';
 import { noop } from './base';
 
+export function move(from: string, to: string): Rule;
+export function move(to: string): Rule;
 export function move(from: string, to?: string): Rule {
   if (to === undefined) {
     to = from;

packages/angular_devkit/schematics/src/rules/rename.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+
+import { posix as path } from 'node:path';
+import { Rule } from '../engine';
+
+export function rename(filePath: string, fromFileName: string, fileName: string): Rule {
+  return (tree) => {
+    tree.rename(path.join(filePath, fromFileName), path.join(filePath, fileName));
+
+    return tree;
+  };
+}

packages/schematics/angular/config/files/best-practices.md.template

@@ -0,0 +1,34 @@
+You are an expert in TypeScript, Angular, and scalable web application development. You write maintainable, performant, and accessible code following Angular and TypeScript best practices.
+## TypeScript Best Practices
+- Use strict type checking
+- Prefer type inference when the type is obvious
+- Avoid the `any` type; use `unknown` when type is uncertain
+## Angular Best Practices
+- Always use standalone components over NgModules
+- Do NOT set `standalone: true` inside the `@Component`, `@Directive` and `@Pipe` decorators
+- Use signals for state management
+- Implement lazy loading for feature routes
+- Use `NgOptimizedImage` for all static images.
+- Do NOT use the `@HostBinding` and `@HostListener` decorators. Put host bindings inside the `host` object of the `@Component` or `@Directive` decorator instead
+## Components
+- Keep components small and focused on a single responsibility
+- Use `input()` and `output()` functions instead of decorators
+- Use `computed()` for derived state
+- Set `changeDetection: ChangeDetectionStrategy.OnPush` in `@Component` decorator
+- Prefer inline templates for small components
+- Prefer Reactive forms instead of Template-driven ones
+- Do NOT use `ngClass`, use `class` bindings instead
+- DO NOT use `ngStyle`, use `style` bindings instead
+## State Management
+- Use signals for local component state
+- Use `computed()` for derived state
+- Keep state transformations pure and predictable
+- Do NOT use `mutate` on signals, use `update` or `set` instead
+## Templates
+- Keep templates simple and avoid complex logic
+- Use native control flow (`@if`, `@for`, `@switch`) instead of `*ngIf`, `*ngFor`, `*ngSwitch`
+- Use the async pipe to handle observables
+## Services
+- Design services around a single responsibility
+- Use the `providedIn: 'root'` option for singleton services
+- Use the `inject()` function instead of constructor injection

packages/schematics/angular/config/index.ts

@@ -14,6 +14,7 @@ import {
   filter,
   mergeWith,
   move,
+  rename,
   strings,
   url,
 } from '@angular-devkit/schematics';
@@ -30,6 +31,8 @@ export default function (options: ConfigOptions): Rule {
       return addKarmaConfig(options);
     case ConfigType.Browserslist:
       return addBrowserslistConfig(options);
+    case ConfigType.Ai:
+      return addAiContextFile(options);
     default:
       throw new SchematicsException(`"${options.type}" is an unknown configuration file type.`);
   }
@@ -103,3 +106,53 @@ function addKarmaConfig(options: ConfigOptions): Rule {
     );
   });
 }
+
+function addAiContextFile(options: ConfigOptions): Rule {
+  let fileName: string;
+  let filePath: string;
+  switch (options.tool) {
+    case 'gemini':
+      fileName = 'GEMINI.md';
+      filePath = '.gemini';
+      break;
+    case 'copilot':
+      fileName = 'copilot-instructions.md';
+      filePath = '.github';
+      break;
+    case 'claude':
+      fileName = 'CLAUDE.md';
+      filePath = '.claude';
+      break;
+    case 'cursor':
+      fileName = 'cursor.md';
+      filePath = path.join('.cursor', 'rules');
+      break;
+    case 'windsurf':
+      fileName = 'guidelines.md';
+      filePath = path.join('.windsurf', 'rules');
+      break;
+    default:
+      throw new SchematicsException(`Unsupported AI tool: ${options.tool}`);
+  }
+
+  return async (host) => {
+    const workspace = await readWorkspace(host);
+    const project = workspace.projects.get(options.project);
+    if (!project) {
+      throw new SchematicsException(`Project name "${options.project}" doesn't not exist.`);
+    }
+
+    // Keep this file in sync with the one presented here https://angular.dev/ai/develop-with-ai
+    // The file is located in the framework repo at adev/src/context/best-practices.md
+    const templateName = 'best-practices.md';
+
+    return mergeWith(
+      apply(url('./files'), [
+        filter((p) => p.endsWith(`${templateName}.template`)),
+        applyTemplates({}),
+        move(filePath),
+        rename(filePath, templateName, fileName),
+      ]),
+    );
+  };
+}

packages/schematics/angular/config/index_spec.ts

@@ -9,7 +9,7 @@
 import { SchematicTestRunner, UnitTestTree } from '@angular-devkit/schematics/testing';
 import { Schema as ApplicationOptions } from '../application/schema';
 import { Schema as WorkspaceOptions } from '../workspace/schema';
-import { Schema as ConfigOptions, Type as ConfigType } from './schema';
+import { Schema as ConfigOptions, Tool as ConfigTool, Type as ConfigType } from './schema';
 
 describe('Config Schematic', () => {
   const schematicRunner = new SchematicTestRunner(
@@ -32,12 +32,15 @@ describe('Config Schematic', () => {
   };
 
   let applicationTree: UnitTestTree;
-  function runConfigSchematic(type: ConfigType): Promise<UnitTestTree> {
+  function runConfigSchematic(type: ConfigType, tool?: ConfigTool): Promise<UnitTestTree>;
+  function runConfigSchematic(type: ConfigType.Ai, tool: ConfigTool): Promise<UnitTestTree>;
+  function runConfigSchematic(type: ConfigType, tool?: ConfigTool): Promise<UnitTestTree> {
     return schematicRunner.runSchematic<ConfigOptions>(
       'config',
       {
         project: 'foo',
         type,
+        tool,
       },
       applicationTree,
     );
@@ -97,4 +100,37 @@ describe('Config Schematic', () => {
       expect(tree.readContent('projects/foo/.browserslistrc')).toContain('Chrome >=');
     });
   });
+
+  describe(`when 'type' is 'ai'`, () => {
+    it('should create a GEMINI.MD file', async () => {
+      const tree = await runConfigSchematic(ConfigType.Ai, ConfigTool.Gemini);
+      expect(tree.readContent('.gemini/GEMINI.md')).toContain('You are an expert in TypeScript');
+    });
+
+    it('should create a copilot-instructions.md file', async () => {
+      const tree = await runConfigSchematic(ConfigType.Ai, ConfigTool.Copilot);
+      expect(tree.readContent('.github/copilot-instructions.md')).toContain(
+        'You are an expert in TypeScript',
+      );
+    });
+
+    it('should create a cursor file', async () => {
+      const tree = await runConfigSchematic(ConfigType.Ai, ConfigTool.Cursor);
+      expect(tree.readContent('.cursor/rules/cursor.md')).toContain(
+        'You are an expert in TypeScript',
+      );
+    });
+
+    it('should create a windsurf file', async () => {
+      const tree = await runConfigSchematic(ConfigType.Ai, ConfigTool.Windsurf);
+      expect(tree.readContent('.windsurf/rules/guidelines.md')).toContain(
+        'You are an expert in TypeScript',
+      );
+    });
+
+    it('should create a claude file', async () => {
+      const tree = await runConfigSchematic(ConfigType.Ai, ConfigTool.Claude);
+      expect(tree.readContent('.claude/CLAUDE.md')).toContain('You are an expert in TypeScript');
+    });
+  });
 });

packages/schematics/angular/config/schema.json

@@ -16,12 +16,21 @@
     "type": {
       "type": "string",
       "description": "Specifies the type of configuration file to generate.",
-      "enum": ["karma", "browserslist"],
+      "enum": ["karma", "browserslist", "ai"],
       "x-prompt": "Which type of configuration file would you like to create?",
       "$default": {
         "$source": "argv",
         "index": 0
       }
+    },
+    "tool": {
+      "type": "string",
+      "description": "Specifies the AI tool to configure when type is 'ai'.",
+      "enum": ["gemini", "copilot", "claude", "cursor", "windsurf"],
+      "x-prompt": {
+        "message": "Which AI tool would you like to configure?",
+        "when": "type === 'ai'"
+      }
     }
   },
   "required": ["project", "type"]