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

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

@@ -0,0 +1,205 @@
+"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.ZONELESS_MIGRATION_TOOL = void 0;
+exports.registerZonelessMigrationTool = registerZonelessMigrationTool;
+const fs = __importStar(require("node:fs"));
+const promises_1 = require("node:fs/promises");
+const zod_1 = require("zod");
+const tool_registry_1 = require("../tool-registry");
+const analyze_for_unsupported_zone_uses_1 = require("./analyze_for_unsupported_zone_uses");
+const migrate_single_file_1 = require("./migrate_single_file");
+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");
+exports.ZONELESS_MIGRATION_TOOL = (0, tool_registry_1.declareTool)({
+    name: 'onpush-zoneless-migration',
+    title: 'Plan migration to OnPush and/or zoneless',
+    description: `
+<Purpose>
+Analyzes Angular code and provides a step-by-step, iterative plan to migrate it to \`OnPush\`
+change detection, a prerequisite for a zoneless application. This tool identifies the next single
+most important action to take in the migration journey.
+</Purpose>
+<Use Cases>
+* **Step-by-Step Migration:** Running the tool repeatedly to get the next instruction for a full
+  migration to \`OnPush\`.
+* **Pre-Migration Analysis:** Checking a component or directory for unsupported \`NgZone\` APIs that
+  would block a zoneless migration.
+* **Generating Component Migrations:** Getting the exact instructions for converting a single
+  component from the default change detection strategy to \`OnPush\`.
+</Use Cases>
+<Operational Notes>
+* **Execution Model:** This tool **DOES NOT** modify code. It **PROVIDES INSTRUCTIONS** for a
+  single action at a time. You **MUST** apply the changes it suggests, and then run the tool
+  again to get the next step.
+* **Iterative Process:** The migration process is iterative. You must call this tool repeatedly,
+  applying the suggested fix after each call, until the tool indicates that no more actions are
+  needed.
+* **Relationship to \`modernize\`:** This tool is the specialized starting point for the zoneless/OnPush
+  migration. For other migrations (like signal inputs), you should use the \`modernize\` tool first,
+  as the zoneless migration may depend on them as prerequisites.
+* **Input:** The tool can operate on either a single file or an entire directory. Provide the
+  absolute path.
+</Operational Notes>`,
+    isReadOnly: true,
+    isLocalOnly: true,
+    inputSchema: {
+        fileOrDirPath: zod_1.z
+            .string()
+            .describe('The absolute path of the directory or file with the component(s), directive(s), or service(s) to migrate.' +
+            ' The contents are read with fs.readFileSync.'),
+    },
+    factory: () => ({ fileOrDirPath }, requestHandlerExtra) => registerZonelessMigrationTool(fileOrDirPath, requestHandlerExtra),
+});
+async function registerZonelessMigrationTool(fileOrDirPath, extras) {
+    let files = [];
+    const componentTestFiles = new Set();
+    const filesWithComponents = new Set();
+    const zoneFiles = new Set();
+    if (fs.statSync(fileOrDirPath).isDirectory()) {
+        const allFiles = (0, promises_1.glob)(`${fileOrDirPath}/**/*.ts`);
+        for await (const file of allFiles) {
+            files.push(await (0, ts_utils_1.createSourceFile)(file));
+        }
+    }
+    else {
+        files = [await (0, ts_utils_1.createSourceFile)(fileOrDirPath)];
+        const maybeTestFile = await getTestFilePath(fileOrDirPath);
+        if (maybeTestFile) {
+            componentTestFiles.add(await (0, ts_utils_1.createSourceFile)(maybeTestFile));
+        }
+    }
+    for (const sourceFile of files) {
+        const content = sourceFile.getFullText();
+        const componentSpecifier = await (0, ts_utils_1.getImportSpecifier)(sourceFile, '@angular/core', 'Component');
+        const zoneSpecifier = await (0, ts_utils_1.getImportSpecifier)(sourceFile, '@angular/core', 'NgZone');
+        const testBedSpecifier = await (0, ts_utils_1.getImportSpecifier)(sourceFile, /(@angular\/core)?\/testing/, 'TestBed');
+        if (testBedSpecifier) {
+            componentTestFiles.add(sourceFile);
+        }
+        else if (componentSpecifier) {
+            if (!content.includes('changeDetectionStrategy: ChangeDetectionStrategy.OnPush') &&
+                !content.includes('changeDetectionStrategy: ChangeDetectionStrategy.Default')) {
+                filesWithComponents.add(sourceFile);
+            }
+            else {
+                (0, send_debug_message_1.sendDebugMessage)(`Component file already has change detection strategy: ${sourceFile.fileName}. Skipping migration.`, extras);
+            }
+            const testFilePath = await getTestFilePath(sourceFile.fileName);
+            if (testFilePath) {
+                componentTestFiles.add(await (0, ts_utils_1.createSourceFile)(testFilePath));
+            }
+        }
+        else if (zoneSpecifier) {
+            zoneFiles.add(sourceFile);
+        }
+    }
+    if (zoneFiles.size > 0) {
+        for (const file of zoneFiles) {
+            const result = await (0, analyze_for_unsupported_zone_uses_1.analyzeForUnsupportedZoneUses)(file);
+            if (result !== null) {
+                return result;
+            }
+        }
+    }
+    if (filesWithComponents.size > 0) {
+        const rankedFiles = filesWithComponents.size > 1
+            ? await rankComponentFilesForMigration(extras, Array.from(filesWithComponents))
+            : Array.from(filesWithComponents);
+        for (const file of rankedFiles) {
+            const result = await (0, migrate_single_file_1.migrateSingleFile)(file, extras);
+            if (result !== null) {
+                return result;
+            }
+        }
+    }
+    for (const file of componentTestFiles) {
+        const result = await (0, migrate_test_file_1.migrateTestFile)(file);
+        if (result !== null) {
+            return result;
+        }
+    }
+    return (0, prompts_1.createTestDebuggingGuideForNonActionableInput)(fileOrDirPath);
+}
+async function rankComponentFilesForMigration({ sendRequest }, componentFiles) {
+    try {
+        const response = await sendRequest({
+            method: 'sampling/createMessage',
+            params: {
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: `The following files are components that need to be migrated to OnPush change detection.` +
+                                ` Please rank them based on which ones are most likely to be shared or common components.` +
+                                ` The most likely shared component should be first.
+  ${componentFiles.map((f) => f.fileName).join('\n  ')}
+  Respond ONLY with the ranked list of files, one file per line.`,
+                        },
+                    },
+                ],
+                systemPrompt: 'You are a helpful assistant that helps migrate identify shared Angular components.',
+                maxTokens: 2000,
+            },
+        }, zod_1.z.object({ sortedFiles: zod_1.z.array(zod_1.z.string()) }));
+        const rankedFiles = response.sortedFiles
+            .map((line) => line.trim())
+            .map((fileName) => componentFiles.find((f) => f.fileName === fileName))
+            .filter((f) => !!f);
+        // Ensure the ranking didn't mess up the list of files
+        if (rankedFiles.length === componentFiles.length) {
+            return rankedFiles;
+        }
+    }
+    catch { }
+    return componentFiles; // Fallback to original order if the response fails
+}
+async function getTestFilePath(filePath) {
+    const testFilePath = filePath.replace(/\.ts$/, '.spec.ts');
+    if (fs.existsSync(testFilePath)) {
+        return testFilePath;
+    }
+    return undefined;
+}

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

@@ -7,23 +7,54 @@
  */
 import z from 'zod';
 export declare const LIST_PROJECTS_TOOL: import("./tool-registry").McpToolDeclaration<z.ZodRawShape, {
-    projects: z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        type: z.ZodOptional<z.ZodEnum<["application", "library"]>>;
-        root: z.ZodString;
-        sourceRoot: z.ZodString;
-        selectorPrefix: z.ZodOptional<z.ZodString>;
+    workspaces: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        projects: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodOptional<z.ZodEnum<["application", "library"]>>;
+            root: z.ZodString;
+            sourceRoot: z.ZodString;
+            selectorPrefix: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            root: string;
+            sourceRoot: string;
+            type?: "application" | "library" | undefined;
+            selectorPrefix?: string | undefined;
+        }, {
+            name: string;
+            root: string;
+            sourceRoot: string;
+            type?: "application" | "library" | undefined;
+            selectorPrefix?: string | undefined;
+        }>, "many">;
     }, "strip", z.ZodTypeAny, {
-        name: string;
-        root: string;
-        sourceRoot: string;
-        type?: "application" | "library" | undefined;
-        selectorPrefix?: string | undefined;
+        path: string;
+        projects: {
+            name: string;
+            root: string;
+            sourceRoot: string;
+            type?: "application" | "library" | undefined;
+            selectorPrefix?: string | undefined;
+        }[];
     }, {
-        name: string;
-        root: string;
-        sourceRoot: string;
-        type?: "application" | "library" | undefined;
-        selectorPrefix?: string | undefined;
+        path: string;
+        projects: {
+            name: string;
+            root: string;
+            sourceRoot: string;
+            type?: "application" | "library" | undefined;
+            selectorPrefix?: string | undefined;
+        }[];
     }>, "many">;
+    parsingErrors: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        filePath: z.ZodString;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        filePath: string;
+    }, {
+        message: string;
+        filePath: string;
+    }>, "many">>;
 }>;

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

@@ -11,15 +11,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LIST_PROJECTS_TOOL = void 0;
+const promises_1 = require("node:fs/promises");
 const node_path_1 = __importDefault(require("node:path"));
+const node_url_1 = require("node:url");
 const zod_1 = __importDefault(require("zod"));
+const config_1 = require("../../../utilities/config");
+const error_1 = require("../../../utilities/error");
 const tool_registry_1 = require("./tool-registry");
-exports.LIST_PROJECTS_TOOL = (0, tool_registry_1.declareTool)({
-    name: 'list_projects',
-    title: 'List Angular Projects',
-    description: 'Lists the names of all applications and libraries defined within an Angular workspace. ' +
-        'It reads the `angular.json` configuration file to identify the projects. ',
-    outputSchema: {
+const listProjectsOutputSchema = {
+    workspaces: zod_1.default.array(zod_1.default.object({
+        path: zod_1.default.string().describe('The path to the `angular.json` file for this workspace.'),
         projects: zod_1.default.array(zod_1.default.object({
             name: zod_1.default
                 .string()
@@ -40,15 +41,152 @@ exports.LIST_PROJECTS_TOOL = (0, tool_registry_1.declareTool)({
                 .describe('The prefix to use for component selectors.' +
                 ` For example, a prefix of 'app' would result in selectors like '<app-my-component>'.`),
         })),
-    },
+    })),
+    parsingErrors: zod_1.default
+        .array(zod_1.default.object({
+        filePath: zod_1.default.string().describe('The path to the file that could not be parsed.'),
+        message: zod_1.default.string().describe('The error message detailing why parsing failed.'),
+    }))
+        .default([])
+        .describe('A list of files that looked like workspaces but failed to parse.'),
+};
+exports.LIST_PROJECTS_TOOL = (0, tool_registry_1.declareTool)({
+    name: 'list_projects',
+    title: 'List Angular Projects',
+    description: `
+<Purpose>
+Provides a comprehensive overview of all Angular workspaces and projects within a monorepo.
+It is essential to use this tool as a first step before performing any project-specific actions to understand the available projects,
+their types, and their locations.
+</Purpose>
+<Use Cases>
+* Finding the correct project name to use in other commands (e.g., \`ng generate component my-comp --project=my-app\`).
+* Identifying the \`root\` and \`sourceRoot\` of a project to read, analyze, or modify its files.
+* Determining if a project is an \`application\` or a \`library\`.
+* Getting the \`selectorPrefix\` for a project before generating a new component to ensure it follows conventions.
+</Use Cases>
+<Operational Notes>
+* **Working Directory:** Shell commands for a project (like \`ng generate\`) **MUST**
+  be executed from the parent directory of the \`path\` field for the relevant workspace.
+* **Disambiguation:** A monorepo may contain multiple workspaces (e.g., for different applications or even in output directories).
+  Use the \`path\` of each workspace to understand its context and choose the correct project.
+</Operational Notes>`,
+    outputSchema: listProjectsOutputSchema,
     isReadOnly: true,
     isLocalOnly: true,
-    shouldRegister: (context) => !!context.workspace,
     factory: createListProjectsHandler,
 });
-function createListProjectsHandler({ workspace }) {
+const EXCLUDED_DIRS = new Set(['node_modules', 'dist', 'out', 'coverage']);
+/**
+ * Iteratively finds all 'angular.json' files with controlled concurrency and directory exclusions.
+ * This non-recursive implementation is suitable for very large directory trees
+ * and prevents file descriptor exhaustion (`EMFILE` errors).
+ * @param rootDir The directory to start the search from.
+ * @returns An async generator that yields the full path of each found 'angular.json' file.
+ */
+async function* findAngularJsonFiles(rootDir) {
+    const CONCURRENCY_LIMIT = 50;
+    const queue = [rootDir];
+    while (queue.length > 0) {
+        const batch = queue.splice(0, CONCURRENCY_LIMIT);
+        const foundFilesInBatch = [];
+        const promises = batch.map(async (dir) => {
+            try {
+                const entries = await (0, promises_1.readdir)(dir, { withFileTypes: true });
+                const subdirectories = [];
+                for (const entry of entries) {
+                    const fullPath = node_path_1.default.join(dir, entry.name);
+                    if (entry.isDirectory()) {
+                        // Exclude dot-directories, build/cache directories, and node_modules
+                        if (entry.name.startsWith('.') || EXCLUDED_DIRS.has(entry.name)) {
+                            continue;
+                        }
+                        subdirectories.push(fullPath);
+                    }
+                    else if (entry.name === 'angular.json') {
+                        foundFilesInBatch.push(fullPath);
+                    }
+                }
+                return subdirectories;
+            }
+            catch (error) {
+                (0, error_1.assertIsError)(error);
+                if (error.code === 'EACCES' || error.code === 'EPERM') {
+                    return []; // Silently ignore permission errors.
+                }
+                throw error;
+            }
+        });
+        const nestedSubdirs = await Promise.all(promises);
+        queue.push(...nestedSubdirs.flat());
+        yield* foundFilesInBatch;
+    }
+}
+/**
+ * Loads, parses, and transforms a single angular.json file into the tool's output format.
+ * It checks a set of seen paths to avoid processing the same workspace multiple times.
+ * @param configFile The path to the angular.json file.
+ * @param seenPaths A Set of absolute paths that have already been processed.
+ * @returns A promise resolving to the workspace data or a parsing error.
+ */
+async function loadAndParseWorkspace(configFile, seenPaths) {
+    try {
+        const resolvedPath = node_path_1.default.resolve(configFile);
+        if (seenPaths.has(resolvedPath)) {
+            return { workspace: null, error: null }; // Already processed, skip.
+        }
+        seenPaths.add(resolvedPath);
+        const ws = await config_1.AngularWorkspace.load(configFile);
+        const projects = [];
+        for (const [name, project] of ws.projects.entries()) {
+            projects.push({
+                name,
+                type: project.extensions['projectType'],
+                root: project.root,
+                sourceRoot: project.sourceRoot ?? node_path_1.default.posix.join(project.root, 'src'),
+                selectorPrefix: project.extensions['prefix'],
+            });
+        }
+        return { workspace: { path: configFile, projects }, error: null };
+    }
+    catch (error) {
+        let message;
+        if (error instanceof Error) {
+            message = error.message;
+        }
+        else {
+            message = 'An unknown error occurred while parsing the file.';
+        }
+        return { workspace: null, error: { filePath: configFile, message } };
+    }
+}
+async function createListProjectsHandler({ server }) {
     return async () => {
-        if (!workspace) {
+        const workspaces = [];
+        const parsingErrors = [];
+        const seenPaths = new Set();
+        let searchRoots;
+        const clientCapabilities = server.server.getClientCapabilities();
+        if (clientCapabilities?.roots) {
+            const { roots } = await server.server.listRoots();
+            searchRoots = roots?.map((r) => node_path_1.default.normalize((0, node_url_1.fileURLToPath)(r.uri))) ?? [];
+        }
+        else {
+            // Fallback to the current working directory if client does not support roots
+            searchRoots = [process.cwd()];
+        }
+        for (const root of searchRoots) {
+            for await (const configFile of findAngularJsonFiles(root)) {
+                const { workspace, error } = await loadAndParseWorkspace(configFile, seenPaths);
+                if (workspace) {
+                    workspaces.push(workspace);
+                }
+                if (error) {
+                    parsingErrors.push(error);
+                }
+            }
+        }
+        if (workspaces.length === 0 && parsingErrors.length === 0) {
             return {
                 content: [
                     {
@@ -58,30 +196,17 @@ function createListProjectsHandler({ workspace }) {
                             ' could not be located in the current directory or any of its parent directories.',
                     },
                 ],
-                structuredContent: { projects: [] },
+                structuredContent: { workspaces: [] },
             };
         }
-        const projects = [];
-        // Convert to output format
-        for (const [name, project] of workspace.projects.entries()) {
-            projects.push({
-                name,
-                type: project.extensions['projectType'],
-                root: project.root,
-                sourceRoot: project.sourceRoot ?? node_path_1.default.posix.join(project.root, 'src'),
-                selectorPrefix: project.extensions['prefix'],
-            });
+        let text = `Found ${workspaces.length} workspace(s).\n${JSON.stringify({ workspaces })}`;
+        if (parsingErrors.length > 0) {
+            text += `\n\nWarning: The following ${parsingErrors.length} file(s) could not be parsed and were skipped:\n`;
+            text += parsingErrors.map((e) => `- ${e.filePath}: ${e.message}`).join('\n');
         }
-        // The structuredContent field is newer and may not be supported by all hosts.
-        // A text representation of the content is also provided for compatibility.
         return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Projects in the Angular workspace:\n${JSON.stringify(projects)}`,
-                },
-            ],
-            structuredContent: { projects },
+            content: [{ type: 'text', text }],
+            structuredContent: { workspaces, parsingErrors },
         };
     };
 }

package/src/commands/mcp/tools/tool-registry.d.ts

@@ -10,6 +10,7 @@ import { ZodRawShape } from 'zod';
 import type { AngularWorkspace } from '../../../utilities/config';
 type ToolConfig = Parameters<McpServer['registerTool']>[1];
 export interface McpToolContext {
+    server: McpServer;
     workspace?: AngularWorkspace;
     logger: {
         warn(text: string): void;
@@ -31,5 +32,5 @@ export interface McpToolDeclaration<TInput extends ZodRawShape, TOutput extends
 }
 export type AnyMcpToolDeclaration = McpToolDeclaration<any, any>;
 export declare function declareTool<TInput extends ZodRawShape, TOutput extends ZodRawShape>(declaration: McpToolDeclaration<TInput, TOutput>): McpToolDeclaration<TInput, TOutput>;
-export declare function registerTools(server: McpServer, context: McpToolContext, declarations: AnyMcpToolDeclaration[]): Promise<void>;
+export declare function registerTools(server: McpServer, context: Omit<McpToolContext, 'server'>, declarations: AnyMcpToolDeclaration[]): Promise<void>;
 export {};

package/src/commands/mcp/tools/tool-registry.js

@@ -14,11 +14,12 @@ function declareTool(declaration) {
 }
 async function registerTools(server, context, declarations) {
     for (const declaration of declarations) {
-        if (declaration.shouldRegister && !(await declaration.shouldRegister(context))) {
+        const toolContext = { ...context, server };
+        if (declaration.shouldRegister && !(await declaration.shouldRegister(toolContext))) {
             continue;
         }
         const { name, factory, shouldRegister, isReadOnly, isLocalOnly, ...config } = declaration;
-        const handler = await factory(context);
+        const handler = await factory(toolContext);
         // Add declarative characteristics to annotations
         config.annotations ??= {};
         if (isReadOnly !== undefined) {

package/src/commands/update/schematic/schema.d.ts

@@ -45,7 +45,6 @@ export type Schema = {
  */
 export declare enum PackageManager {
     Bun = "bun",
-    Cnpm = "cnpm",
     Npm = "npm",
     Pnpm = "pnpm",
     Yarn = "yarn"

package/src/commands/update/schematic/schema.js

@@ -9,7 +9,6 @@ exports.PackageManager = void 0;
 var PackageManager;
 (function (PackageManager) {
     PackageManager["Bun"] = "bun";
-    PackageManager["Cnpm"] = "cnpm";
     PackageManager["Npm"] = "npm";
     PackageManager["Pnpm"] = "pnpm";
     PackageManager["Yarn"] = "yarn";

package/src/commands/update/schematic/schema.json

@@ -57,7 +57,7 @@
       "description": "The preferred package manager configuration files to use for registry settings.",
       "type": "string",
       "default": "npm",
-      "enum": ["npm", "yarn", "cnpm", "pnpm", "bun"]
+      "enum": ["npm", "yarn", "pnpm", "bun"]
     }
   },
   "required": []

package/src/utilities/version.js

@@ -22,4 +22,4 @@ class Version {
         this.patch = patch;
     }
 }
-exports.VERSION = new Version('21.0.0-next.0');
+exports.VERSION = new Version('21.0.0-next.2');