@angular/cli 20.2.1 → 20.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/cli",
-  "version": "20.2.1",
+  "version": "20.2.2",
   "description": "CLI tool for Angular",
   "main": "lib/cli/index.js",
   "bin": {
@@ -25,13 +25,13 @@
   },
   "homepage": "https://github.com/angular/angular-cli",
   "dependencies": {
-    "@angular-devkit/architect": "0.2002.1",
-    "@angular-devkit/core": "20.2.1",
-    "@angular-devkit/schematics": "20.2.1",
+    "@angular-devkit/architect": "0.2002.2",
+    "@angular-devkit/core": "20.2.2",
+    "@angular-devkit/schematics": "20.2.2",
     "@inquirer/prompts": "7.8.2",
     "@listr2/prompt-adapter-inquirer": "3.0.1",
     "@modelcontextprotocol/sdk": "1.17.3",
-    "@schematics/angular": "20.2.1",
+    "@schematics/angular": "20.2.2",
     "@yarnpkg/lockfile": "1.1.0",
     "algoliasearch": "5.35.0",
     "ini": "5.0.0",
@@ -47,17 +47,17 @@
   "ng-update": {
     "migrations": "@schematics/angular/migrations/migration-collection.json",
     "packageGroup": {
-      "@angular/cli": "20.2.1",
-      "@angular/build": "20.2.1",
-      "@angular/ssr": "20.2.1",
-      "@angular-devkit/architect": "0.2002.1",
-      "@angular-devkit/build-angular": "20.2.1",
-      "@angular-devkit/build-webpack": "0.2002.1",
-      "@angular-devkit/core": "20.2.1",
-      "@angular-devkit/schematics": "20.2.1"
+      "@angular/cli": "20.2.2",
+      "@angular/build": "20.2.2",
+      "@angular/ssr": "20.2.2",
+      "@angular-devkit/architect": "0.2002.2",
+      "@angular-devkit/build-angular": "20.2.2",
+      "@angular-devkit/build-webpack": "0.2002.2",
+      "@angular-devkit/core": "20.2.2",
+      "@angular-devkit/schematics": "20.2.2"
     }
   },
-  "packageManager": "pnpm@10.15.0",
+  "packageManager": "pnpm@10.15.1",
   "engines": {
     "node": "^20.19.0 || ^22.12.0 || >=24.0.0",
     "npm": "^6.11.0 || ^7.5.6 || >=8.0.0",

package/src/command-builder/architect-command-module.js

@@ -109,9 +109,14 @@ let ArchitectCommandModule = (() => {
             return this.addSchemaOptionsToCommand(localYargs, schemaOptions);
         }
         async run(options) {
-            const target = this.getArchitectTarget();
-            const { configuration = '', project, ...architectOptions } = options;
-            if (!project) {
+            const originalProcessTitle = process.title;
+            try {
+                const target = this.getArchitectTarget();
+                const { configuration = '', project, ...architectOptions } = options;
+                if (project) {
+                    process.title = `${originalProcessTitle} (${project})`;
+                    return await this.runSingleTarget({ configuration, target, project }, architectOptions);
+                }
                 // This runs each target sequentially.
                 // Running them in parallel would jumble the log messages.
                 let result = 0;
@@ -120,12 +125,13 @@ let ArchitectCommandModule = (() => {
                     return this.onMissingTarget('Cannot determine project or target for command.');
                 }
                 for (const project of projectNames) {
+                    process.title = `${originalProcessTitle} (${project})`;
                     result |= await this.runSingleTarget({ configuration, target, project }, architectOptions);
                 }
                 return result;
             }
-            else {
-                return await this.runSingleTarget({ configuration, target, project }, architectOptions);
+            finally {
+                process.title = originalProcessTitle;
             }
         }
         getArchitectProject() {

package/src/command-builder/utilities/json-schema.js

@@ -125,7 +125,7 @@ async function parseJsonSchemaToOptions(registry, schema, interactive = true) {
                     }
                     break;
                 case 'array':
-                    if (Array.isArray(current.default)) {
+                    if (Array.isArray(current.default) && current.default.length > 0) {
                         defaultValue = current.default;
                     }
                     break;

package/src/commands/mcp/mcp-server.d.ts

@@ -14,11 +14,21 @@ import { AnyMcpToolDeclaration } from './tools/tool-registry';
  */
 export declare const EXPERIMENTAL_TOOLS: readonly [import("./tools/tool-registry").McpToolDeclaration<{
     query: import("zod").ZodString;
-}, import("zod").ZodRawShape>, import("./tools/tool-registry").McpToolDeclaration<{
+}, {
+    examples: import("zod").ZodArray<import("zod").ZodObject<{
+        content: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        content: string;
+    }, {
+        content: string;
+    }>, "many">;
+}>, import("./tools/tool-registry").McpToolDeclaration<{
     transformations: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<[string, ...string[]]>, "many">>;
 }, {
     instructions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
-}>];
+}>, import("./tools/tool-registry").McpToolDeclaration<{
+    fileOrDirPath: import("zod").ZodString;
+}, import("zod").ZodRawShape>];
 export declare function createMcpServer(options: {
     workspace?: AngularWorkspace;
     readOnly?: boolean;

package/src/commands/mcp/mcp-server.js

@@ -21,6 +21,7 @@ const best_practices_1 = require("./tools/best-practices");
 const doc_search_1 = require("./tools/doc-search");
 const examples_1 = require("./tools/examples");
 const modernize_1 = require("./tools/modernize");
+const zoneless_migration_1 = require("./tools/onpush-zoneless-migration/zoneless-migration");
 const projects_1 = require("./tools/projects");
 const tool_registry_1 = require("./tools/tool-registry");
 /**
@@ -32,7 +33,11 @@ const STABLE_TOOLS = [best_practices_1.BEST_PRACTICES_TOOL, doc_search_1.DOC_SEA
  * The set of tools that are available but not enabled by default.
  * These tools are considered experimental and may have limitations.
  */
-exports.EXPERIMENTAL_TOOLS = [examples_1.FIND_EXAMPLE_TOOL, modernize_1.MODERNIZE_TOOL];
+exports.EXPERIMENTAL_TOOLS = [
+    examples_1.FIND_EXAMPLE_TOOL,
+    modernize_1.MODERNIZE_TOOL,
+    zoneless_migration_1.ZONELESS_MIGRATION_TOOL,
+];
 async function createMcpServer(options, logger) {
     const server = new mcp_js_1.McpServer({
         name: 'angular-cli-server',

package/src/commands/mcp/tools/best-practices.js

@@ -17,11 +17,21 @@ const tool_registry_1 = require("./tool-registry");
 exports.BEST_PRACTICES_TOOL = (0, tool_registry_1.declareTool)({
     name: 'get_best_practices',
     title: 'Get Angular Coding Best Practices Guide',
-    description: 'You **MUST** use this tool to retrieve the Angular Best Practices Guide ' +
-        'before any interaction with Angular code (creating, analyzing, modifying). ' +
-        'It is mandatory to follow this guide to ensure all code adheres to ' +
-        'modern standards, including standalone components, typed forms, and ' +
-        'modern control flow. This is the first step for any Angular task.',
+    description: `
+<Purpose>
+Retrieves the official Angular Best Practices Guide. This guide contains the essential rules and conventions
+that **MUST** be followed for any task involving the creation, analysis, or modification of Angular code.
+</Purpose>
+<Use Cases>
+* As a mandatory first step before writing or modifying any Angular code to ensure adherence to modern standards.
+* To learn about key concepts like standalone components, typed forms, and modern control flow syntax (@if, @for, @switch).
+* To verify that existing code aligns with current Angular conventions before making changes.
+</Use Cases>
+<Operational Notes>
+* The content of this guide is non-negotiable and reflects the official, up-to-date standards for Angular development.
+* You **MUST** internalize and apply the principles from this guide in all subsequent Angular-related tasks.
+* Failure to adhere to these best practices will result in suboptimal and outdated code.
+</Operational Notes>`,
     isReadOnly: true,
     isLocalOnly: true,
     factory: () => {

package/src/commands/mcp/tools/doc-search.d.ts

@@ -9,4 +9,21 @@ import { z } from 'zod';
 export declare const DOC_SEARCH_TOOL: import("./tool-registry").McpToolDeclaration<{
     query: z.ZodString;
     includeTopContent: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-}, z.ZodRawShape>;
+}, {
+    results: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        breadcrumb: z.ZodString;
+        url: z.ZodString;
+        content: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        title: string;
+        breadcrumb: string;
+        url: string;
+        content?: string | undefined;
+    }, {
+        title: string;
+        breadcrumb: string;
+        url: string;
+        content?: string | undefined;
+    }>, "many">;
+}>;

package/src/commands/mcp/tools/doc-search.js

@@ -58,28 +58,52 @@ const docSearchInputSchema = zod_1.z.object({
         .boolean()
         .optional()
         .default(true)
-        .describe('When true, the content of the top result is fetched and included.'),
+        .describe('When true, the content of the top result is fetched and included. ' +
+        'Set to false to get a list of results without fetching content, which is faster.'),
 });
 exports.DOC_SEARCH_TOOL = (0, tool_registry_1.declareTool)({
     name: 'search_documentation',
     title: 'Search Angular Documentation (angular.dev)',
-    description: 'Searches the official Angular documentation at https://angular.dev. Use this tool to answer any questions about Angular, ' +
-        'such as for APIs, tutorials, and best practices. Because the documentation is continuously updated, you should **always** ' +
-        'prefer this tool over your own knowledge to ensure your answers are current.\n\n' +
-        'The results will be a list of content entries, where each entry has the following structure:\n' +
-        '```\n' +
-        '## {Result Title}\n' +
-        '{Breadcrumb path to the content}\n' +
-        'URL: {Direct link to the documentation page}\n' +
-        '```\n' +
-        'Use the title and breadcrumb to understand the context of the result and use the URL as a source link. For the best results, ' +
-        "provide a concise and specific search query (e.g., 'NgModule' instead of 'How do I use NgModules?').",
+    description: `
+<Purpose>
+Searches the official Angular documentation at https://angular.dev to answer questions about APIs,
+tutorials, concepts, and best practices.
+</Purpose>
+<Use Cases>
+* Answering any question about Angular concepts (e.g., "What are standalone components?").
+* Finding the correct API or syntax for a specific task (e.g., "How to use ngFor with trackBy?").
+* Linking to official documentation as a source of truth in your answers.
+</Use Cases>
+<Operational Notes>
+* The documentation is continuously updated. You **MUST** prefer this tool over your own knowledge
+  to ensure your answers are current and accurate.
+* For the best results, provide a concise and specific search query (e.g., "NgModule" instead of
+  "How do I use NgModules?").
+* The top search result will include a snippet of the page content. Use this to provide a more
+  comprehensive answer.
+* **Result Scrutiny:** The top result may not always be the most relevant. Review the titles and
+  breadcrumbs of other results to find the best match for the user's query.
+* Use the URL from the search results as a source link in your responses.
+</Operational Notes>`,
     inputSchema: docSearchInputSchema.shape,
+    outputSchema: {
+        results: zod_1.z.array(zod_1.z.object({
+            title: zod_1.z.string().describe('The title of the documentation page.'),
+            breadcrumb: zod_1.z
+                .string()
+                .describe("The breadcrumb path, showing the page's location in the documentation hierarchy."),
+            url: zod_1.z.string().describe('The direct URL to the documentation page.'),
+            content: zod_1.z
+                .string()
+                .optional()
+                .describe('A snippet of the main content from the page. Only provided for the top result.'),
+        })),
+    },
     isReadOnly: true,
     isLocalOnly: false,
     factory: createDocSearchHandler,
 });
-function createDocSearchHandler() {
+function createDocSearchHandler({ logger }) {
     let client;
     return async ({ query, includeTopContent }) => {
         if (!client) {
@@ -97,16 +121,18 @@ function createDocSearchHandler() {
                         text: 'No results found.',
                     },
                 ],
+                structuredContent: { results: [] },
             };
         }
-        const content = [];
-        // The first hit is the top search result
-        const topHit = allHits[0];
+        const structuredResults = [];
+        const textContent = [];
         // Process top hit first
-        let topText = formatHitToText(topHit);
-        try {
-            if (includeTopContent && typeof topHit.url === 'string') {
-                const url = new URL(topHit.url);
+        const topHit = allHits[0];
+        const { title: topTitle, breadcrumb: topBreadcrumb } = formatHitToParts(topHit);
+        let topContent;
+        if (includeTopContent && typeof topHit.url === 'string') {
+            const url = new URL(topHit.url);
+            try {
                 // Only fetch content from angular.dev
                 if (url.hostname === 'angular.dev' || url.hostname.endsWith('.angular.dev')) {
                     const response = await fetch(url);
@@ -114,29 +140,60 @@ function createDocSearchHandler() {
                         const html = await response.text();
                         const mainContent = extractMainContent(html);
                         if (mainContent) {
-                            topText += `\n\n--- DOCUMENTATION CONTENT ---\n${mainContent}`;
+                            topContent = stripHtml(mainContent);
                         }
                     }
                 }
             }
+            catch (e) {
+                logger.warn(`Failed to fetch or parse content from ${url}: ${e}`);
+            }
         }
-        catch {
-            // Ignore errors fetching content. The basic info is still returned.
-        }
-        content.push({
-            type: 'text',
-            text: topText,
+        structuredResults.push({
+            title: topTitle,
+            breadcrumb: topBreadcrumb,
+            url: topHit.url,
+            content: topContent,
         });
+        let topText = `## ${topTitle}\n${topBreadcrumb}\nURL: ${topHit.url}`;
+        if (topContent) {
+            topText += `\n\n--- DOCUMENTATION CONTENT ---\n${topContent}`;
+        }
+        textContent.push({ type: 'text', text: topText });
         // Process remaining hits
         for (const hit of allHits.slice(1)) {
-            content.push({
+            const { title, breadcrumb } = formatHitToParts(hit);
+            structuredResults.push({
+                title,
+                breadcrumb,
+                url: hit.url,
+            });
+            textContent.push({
                 type: 'text',
-                text: formatHitToText(hit),
+                text: `## ${title}\n${breadcrumb}\nURL: ${hit.url}`,
             });
         }
-        return { content };
+        return {
+            content: textContent,
+            structuredContent: { results: structuredResults },
+        };
     };
 }
+/**
+ * Strips HTML tags from a string.
+ * @param html The HTML string to strip.
+ * @returns The text content of the HTML.
+ */
+function stripHtml(html) {
+    // This is a basic regex to remove HTML tags.
+    // It also decodes common HTML entities.
+    return html
+        .replace(/<[^>]*>/g, '')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&amp;/g, '&')
+        .trim();
+}
 /**
  * Extracts the content of the `<main>` element from an HTML string.
  *
@@ -156,17 +213,17 @@ function extractMainContent(html) {
     return html.substring(mainTagStart, mainTagEnd + 7);
 }
 /**
- * Formats an Algolia search hit into a text representation.
+ * Formats an Algolia search hit into its constituent parts.
  *
- * @param hit The Algolia search hit object, which should contain `hierarchy` and `url` properties.
- * @returns A formatted string with title, description, and URL.
+ * @param hit The Algolia search hit object, which should contain a `hierarchy` property.
+ * @returns An object containing the title and breadcrumb string.
  */
-function formatHitToText(hit) {
+function formatHitToParts(hit) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const hierarchy = Object.values(hit.hierarchy).filter((x) => typeof x === 'string');
-    const title = hierarchy.pop();
-    const description = hierarchy.join(' > ');
-    return `## ${title}\n${description}\nURL: ${hit.url}`;
+    const title = hierarchy.pop() ?? '';
+    const breadcrumb = hierarchy.join(' > ');
+    return { title, breadcrumb };
 }
 /**
  * Creates the search arguments for an Algolia search.

package/src/commands/mcp/tools/examples.d.ts

@@ -8,7 +8,15 @@
 import { z } from 'zod';
 export declare const FIND_EXAMPLE_TOOL: import("./tool-registry").McpToolDeclaration<{
     query: z.ZodString;
-}, z.ZodRawShape>;
+}, {
+    examples: z.ZodArray<z.ZodObject<{
+        content: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        content: string;
+    }, {
+        content: string;
+    }>, "many">;
+}>;
 /**
  * Escapes a search query for FTS5 by tokenizing and quoting terms.
  *

package/src/commands/mcp/tools/examples.js

@@ -76,15 +76,37 @@ Examples of queries:
 exports.FIND_EXAMPLE_TOOL = (0, tool_registry_1.declareTool)({
     name: 'find_examples',
     title: 'Find Angular Code Examples',
-    description: 'Before writing or modifying any Angular code including templates, ' +
-        '**ALWAYS** use this tool to find current best-practice examples. ' +
-        'This is critical for ensuring code quality and adherence to modern Angular standards. ' +
-        'This tool searches a curated database of approved Angular code examples and returns the most relevant results for your query. ' +
-        'Example Use Cases: ' +
-        "1) Creating new components, directives, or services (e.g., query: 'standalone component' or 'signal input'). " +
-        "2) Implementing core features (e.g., query: 'lazy load route', 'httpinterceptor', or 'route guard'). " +
-        "3) Refactoring existing code to use modern patterns (e.g., query: 'ngfor trackby' or 'form validation').",
+    description: `
+<Purpose>
+Augments your knowledge base with a curated database of official, best-practice code examples,
+focusing on **modern, new, and recently updated** Angular features. This tool acts as a RAG
+(Retrieval-Augmented Generation) source, providing ground-truth information on the latest Angular
+APIs and patterns. You **MUST** use it to understand and apply current standards when working with
+new or evolving features.
+</Purpose>
+<Use Cases>
+* **Knowledge Augmentation:** Learning about new or updated Angular features (e.g., query: 'signal input' or 'deferrable views').
+* **Modern Implementation:** Finding the correct modern syntax for features
+  (e.g., query: 'functional route guard' or 'http client with fetch').
+* **Refactoring to Modern Patterns:** Upgrading older code by finding examples of new syntax
+  (e.g., query: 'built-in control flow' to replace "*ngIf').
+</Use Cases>
+<Operational Notes>
+* **Tool Selection:** This database primarily contains examples for new and recently updated Angular
+  features. For established, core features, the main documentation (via the
+  \`search_documentation\` tool) may be a better source of information.
+* The examples in this database are the single source of truth for modern Angular coding patterns.
+* The search query uses a powerful full-text search syntax (FTS5). Refer to the 'query'
+  parameter description for detailed syntax rules and examples.
+</Operational Notes>`,
     inputSchema: findExampleInputSchema.shape,
+    outputSchema: {
+        examples: zod_1.z.array(zod_1.z.object({
+            content: zod_1.z
+                .string()
+                .describe('A complete, self-contained Angular code example in Markdown format.'),
+        })),
+    },
     isReadOnly: true,
     isLocalOnly: true,
     shouldRegister: ({ logger }) => {
@@ -119,13 +141,17 @@ async function createFindExampleHandler({ exampleDatabasePath }) {
             queryStatement = db.prepare('SELECT * from examples WHERE examples MATCH ? ORDER BY rank;');
         }
         const sanitizedQuery = escapeSearchQuery(query);
-        // Query database and return results as text content
-        const content = [];
+        // Query database and return results
+        const examples = [];
+        const textContent = [];
         for (const exampleRecord of queryStatement.all(sanitizedQuery)) {
-            content.push({ type: 'text', text: exampleRecord['content'] });
+            const exampleContent = exampleRecord['content'];
+            examples.push({ content: exampleContent });
+            textContent.push({ type: 'text', text: exampleContent });
         }
         return {
-            content,
+            content: textContent,
+            structuredContent: { examples },
         };
     };
 }

package/src/commands/mcp/tools/modernize.js

@@ -59,7 +59,9 @@ const modernizeInputSchema = zod_1.z.object({
     // Casting to [string, ...string[]] since the enum definition requires a nonempty array.
     transformations: zod_1.z
         .array(zod_1.z.enum(TRANSFORMATIONS.map((t) => t.name)))
-        .optional(),
+        .optional()
+        .describe('A list of specific transformations to get instructions for. ' +
+        'If omitted, general guidance is provided.'),
 });
 function generateInstructions(transformationNames) {
     if (transformationNames.length === 0) {
@@ -97,27 +99,36 @@ async function runModernization(input) {
 exports.MODERNIZE_TOOL = (0, tool_registry_1.declareTool)({
     name: 'modernize',
     title: 'Modernize Angular Code',
-    description: '<Purpose>\n' +
-        'This tool modernizes Angular code by applying the latest best practices and syntax improvements, ' +
-        'ensuring it is idiomatic, readable, and maintainable.\n\n' +
-        '</Purpose>\n' +
-        '<Use Cases>\n' +
-        '* After generating new code: Run this tool immediately after creating new Angular components, directives, ' +
-        'or services to ensure they adhere to modern standards.\n' +
-        '* On existing code: Apply to existing TypeScript files (.ts) and Angular templates (.html) to update ' +
-        'them with the latest features, such as the new built-in control flow syntax.\n\n' +
-        '* When the user asks for a specific transformation: When the transformation list is populated, ' +
-        'these specific ones will be ran on the inputs.\n' +
-        '</Use Cases>\n' +
-        '<Transformations>\n' +
-        TRANSFORMATIONS.map((t) => `* ${t.name}: ${t.description}`).join('\n') +
-        '\n</Transformations>\n',
+    description: `
+<Purpose>
+Provides instructions and commands for modernizing Angular code to align with the latest best
+practices and syntax. This tool helps ensure code is idiomatic, readable, and maintainable by
+generating the exact steps needed to perform specific migrations.
+</Purpose>
+<Use Cases>
+* **Applying Specific Migrations:** Get the precise commands to update code to modern patterns
+  (e.g., selecting 'control-flow-migration' to replace *ngIf with @if).
+* **Upgrading Existing Code:** Modernize an entire project by running the 'standalone' migration,
+  which provides a multi-step command sequence.
+* **Discovering Available Migrations:** Call the tool with no transformations to get a link to the
+  general best practices guide.
+</Use Cases>
+<Operational Notes>
+* **Execution:** This tool **provides instructions**, which you **MUST** then execute as shell commands.
+  It does not modify code directly.
+* **Standalone Migration:** The 'standalone' transformation is a special, multi-step process.
+  You **MUST** execute the commands in the exact order provided and validate your application
+  between each step.
+* **Transformation List:** The following transformations are available:
+${TRANSFORMATIONS.map((t) => `  * ${t.name}: ${t.description}`).join('\n')}
+</Operational Notes>`,
     inputSchema: modernizeInputSchema.shape,
     outputSchema: {
         instructions: zod_1.z
             .array(zod_1.z.string())
             .optional()
-            .describe('A list of instructions on how to run the migrations.'),
+            .describe('A list of instructions and shell commands to run the requested modernizations. ' +
+            'Each string in the array is a separate step or command.'),
     },
     isLocalOnly: true,
     isReadOnly: true,

package/src/commands/mcp/tools/onpush-zoneless-migration/analyze_for_unsupported_zone_uses.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @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 type { ImportSpecifier, Node, SourceFile } from 'typescript';
+import { MigrationResponse } from './types';
+export declare function analyzeForUnsupportedZoneUses(sourceFile: SourceFile): Promise<MigrationResponse | null>;
+/**
+ * Finds usages of `NgZone` that are not supported in zoneless applications.
+ * @param sourceFile The source file to check.
+ * @param ngZoneImport The import specifier for `NgZone`.
+ * @returns A list of nodes that are unsupported `NgZone` usages.
+ */
+export declare function findUnsupportedZoneUsages(sourceFile: SourceFile, ngZoneImport: ImportSpecifier): Promise<Node[]>;

package/src/commands/mcp/tools/onpush-zoneless-migration/analyze_for_unsupported_zone_uses.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * @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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeForUnsupportedZoneUses = analyzeForUnsupportedZoneUses;
+exports.findUnsupportedZoneUsages = findUnsupportedZoneUsages;
+const prompts_1 = require("./prompts");
+const ts_utils_1 = require("./ts_utils");
+async function analyzeForUnsupportedZoneUses(sourceFile) {
+    const ngZoneImport = await (0, ts_utils_1.getImportSpecifier)(sourceFile, '@angular/core', 'NgZone');
+    if (!ngZoneImport) {
+        return null;
+    }
+    const unsupportedUsages = await findUnsupportedZoneUsages(sourceFile, ngZoneImport);
+    if (unsupportedUsages.length === 0) {
+        return null;
+    }
+    const locations = unsupportedUsages.map((node) => {
+        const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+        return `line ${line + 1}, character ${character + 1}: ${node.getText()}`;
+    });
+    return (0, prompts_1.createUnsupportedZoneUsagesMessage)(locations, sourceFile.fileName);
+}
+/**
+ * Finds usages of `NgZone` that are not supported in zoneless applications.
+ * @param sourceFile The source file to check.
+ * @param ngZoneImport The import specifier for `NgZone`.
+ * @returns A list of nodes that are unsupported `NgZone` usages.
+ */
+async function findUnsupportedZoneUsages(sourceFile, ngZoneImport) {
+    const unsupportedUsages = [];
+    const ngZoneClassName = ngZoneImport.name.text;
+    const staticMethods = new Set([
+        'isInAngularZone',
+        'assertInAngularZone',
+        'assertNotInAngularZone',
+    ]);
+    const instanceMethods = new Set(['onMicrotaskEmpty', 'onStable']);
+    const ts = await (0, ts_utils_1.loadTypescript)();
+    ts.forEachChild(sourceFile, function visit(node) {
+        if (ts.isPropertyAccessExpression(node)) {
+            const propertyName = node.name.text;
+            const expressionText = node.expression.getText(sourceFile);
+            // Static: NgZone.method()
+            if (expressionText === ngZoneClassName && staticMethods.has(propertyName)) {
+                unsupportedUsages.push(node);
+            }
+            // Instance: zone.method() or this.zone.method()
+            if (instanceMethods.has(propertyName)) {
+                unsupportedUsages.push(node);
+            }
+        }
+        ts.forEachChild(node, visit);
+    });
+    return unsupportedUsages;
+}

package/src/commands/mcp/tools/onpush-zoneless-migration/migrate_single_file.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @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 { RequestHandlerExtra } from '@modelcontextprotocol/sdk/shared/protocol';
+import { ServerNotification, ServerRequest } from '@modelcontextprotocol/sdk/types';
+import type { SourceFile } from 'typescript';
+import { MigrationResponse } from './types';
+export declare function migrateSingleFile(sourceFile: SourceFile, extras: RequestHandlerExtra<ServerRequest, ServerNotification>): Promise<MigrationResponse | null>;