@angular/cli 21.0.0-next.1 → 21.0.0-next.2

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>;

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

@@ -0,0 +1,72 @@
+"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.migrateSingleFile = migrateSingleFile;
+const analyze_for_unsupported_zone_uses_1 = require("./analyze_for_unsupported_zone_uses");
+const migrate_test_file_1 = require("./migrate_test_file");
+const prompts_1 = require("./prompts");
+const send_debug_message_1 = require("./send_debug_message");
+const ts_utils_1 = require("./ts_utils");
+async function migrateSingleFile(sourceFile, extras) {
+    const testBedSpecifier = await (0, ts_utils_1.getImportSpecifier)(sourceFile, '@angular/core/testing', 'TestBed');
+    const isTestFile = sourceFile.fileName.endsWith('.spec.ts') || !!testBedSpecifier;
+    if (isTestFile) {
+        return (0, migrate_test_file_1.migrateTestFile)(sourceFile);
+    }
+    const unsupportedZoneUseResponse = await (0, analyze_for_unsupported_zone_uses_1.analyzeForUnsupportedZoneUses)(sourceFile);
+    if (unsupportedZoneUseResponse) {
+        return unsupportedZoneUseResponse;
+    }
+    let detectedStrategy;
+    let hasComponentDecorator = false;
+    const componentSpecifier = await (0, ts_utils_1.getImportSpecifier)(sourceFile, '@angular/core', 'Component');
+    if (!componentSpecifier) {
+        (0, send_debug_message_1.sendDebugMessage)(`No component decorator found in file: ${sourceFile.fileName}`, extras);
+        return null;
+    }
+    const ts = await (0, ts_utils_1.loadTypescript)();
+    ts.forEachChild(sourceFile, function visit(node) {
+        if (detectedStrategy) {
+            return; // Already found, no need to traverse further
+        }
+        if (ts.isDecorator(node) && ts.isCallExpression(node.expression)) {
+            const callExpr = node.expression;
+            if (callExpr.expression.getText(sourceFile) === 'Component') {
+                hasComponentDecorator = true;
+                if (callExpr.arguments.length > 0 && ts.isObjectLiteralExpression(callExpr.arguments[0])) {
+                    const componentMetadata = callExpr.arguments[0];
+                    for (const prop of componentMetadata.properties) {
+                        if (ts.isPropertyAssignment(prop) &&
+                            prop.name.getText(sourceFile) === 'changeDetection') {
+                            if (ts.isPropertyAccessExpression(prop.initializer) &&
+                                prop.initializer.expression.getText(sourceFile) === 'ChangeDetectionStrategy') {
+                                const strategy = prop.initializer.name.text;
+                                if (strategy === 'OnPush' || strategy === 'Default') {
+                                    detectedStrategy = strategy;
+                                    return;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    });
+    if (!hasComponentDecorator ||
+        // component uses OnPush. We don't have anything more to do here.
+        detectedStrategy === 'OnPush' ||
+        // Explicit default strategy, assume there's a reason for it (already migrated, or is a library that hosts Default components) and skip.
+        detectedStrategy === 'Default') {
+        (0, send_debug_message_1.sendDebugMessage)(`Component decorator found with strategy: ${detectedStrategy} in file: ${sourceFile.fileName}. Skipping migration for file.`, extras);
+        return null;
+    }
+    // Component decorator found, but no change detection strategy.
+    return (0, prompts_1.generateZonelessMigrationInstructionsForComponent)(sourceFile.fileName);
+}

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

@@ -0,0 +1,11 @@
+/**
+ * @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 { SourceFile } from 'typescript';
+import { MigrationResponse } from './types';
+export declare function migrateTestFile(sourceFile: SourceFile): Promise<MigrationResponse | null>;
+export declare function searchForGlobalZoneless(startPath: string): Promise<boolean>;

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

@@ -0,0 +1,105 @@
+"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
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateTestFile = migrateTestFile;
+exports.searchForGlobalZoneless = searchForGlobalZoneless;
+const fs = __importStar(require("node:fs"));
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const prompts_1 = require("./prompts");
+const ts_utils_1 = require("./ts_utils");
+async function migrateTestFile(sourceFile) {
+    const ts = await (0, ts_utils_1.loadTypescript)();
+    // Check if tests use zoneless either by default through `initTestEnvironment` or by explicitly calling `provideZonelessChangeDetection`.
+    let testsUseZonelessChangeDetection = await searchForGlobalZoneless(sourceFile.fileName);
+    if (!testsUseZonelessChangeDetection) {
+        ts.forEachChild(sourceFile, function visit(node) {
+            if (ts.isCallExpression(node) &&
+                node.expression.getText(sourceFile) === 'provideZonelessChangeDetection') {
+                testsUseZonelessChangeDetection = true;
+                return;
+            }
+            ts.forEachChild(node, visit);
+        });
+    }
+    if (!testsUseZonelessChangeDetection) {
+        // Tests do not use zoneless, so we provide instructions to set it up.
+        return (0, prompts_1.createProvideZonelessForTestsSetupPrompt)(sourceFile.fileName);
+    }
+    // At this point, tests are using zoneless, so we look for any explicit uses of `provideZoneChangeDetection` that need to be fixed.
+    return (0, prompts_1.createFixResponseForZoneTests)(sourceFile);
+}
+async function searchForGlobalZoneless(startPath) {
+    const angularJsonDir = findAngularJsonDir(startPath);
+    if (!angularJsonDir) {
+        // Cannot determine project root, fallback to original behavior or assume false.
+        // For now, let's assume no global setup if angular.json is not found.
+        return false;
+    }
+    try {
+        const files = (0, promises_1.glob)(`${angularJsonDir}/**/*.ts`);
+        for await (const file of files) {
+            const content = fs.readFileSync(file, 'utf-8');
+            if (content.includes('initTestEnvironment') &&
+                content.includes('provideZonelessChangeDetection')) {
+                return true;
+            }
+        }
+    }
+    catch (e) {
+        return false;
+    }
+    return false;
+}
+function findAngularJsonDir(startDir) {
+    let currentDir = startDir;
+    while (true) {
+        if (fs.existsSync((0, node_path_1.join)(currentDir, 'angular.json'))) {
+            return currentDir;
+        }
+        const parentDir = (0, node_path_1.dirname)(currentDir);
+        if (parentDir === currentDir) {
+            return null;
+        }
+        currentDir = parentDir;
+    }
+}

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

@@ -0,0 +1,15 @@
+/**
+ * @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 { SourceFile } from 'typescript';
+import { MigrationResponse } from './types';
+export declare function createProvideZonelessForTestsSetupPrompt(testFilePath: string): MigrationResponse;
+export declare function createUnsupportedZoneUsagesMessage(usages: string[], filePath: string): MigrationResponse;
+export declare function generateZonelessMigrationInstructionsForComponent(filePath: string): MigrationResponse;
+export declare function createTestDebuggingGuideForNonActionableInput(fileOrDirPath: string): MigrationResponse;
+export declare function createFixResponseForZoneTests(sourceFile: SourceFile): Promise<MigrationResponse | null>;
+export declare function createResponse(text: string): MigrationResponse;