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

package/src/commands/add/cli.js

@@ -43,7 +43,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const tools_1 = require("@angular-devkit/schematics/tools");
 const listr2_1 = require("listr2");
 const node_assert_1 = __importDefault(require("node:assert"));
 const node_module_1 = require("node:module");
@@ -69,6 +68,17 @@ const packageVersionExclusions = {
     // @angular/material@7.x versions have unbounded peer dependency ranges (>=7.0.0).
     '@angular/material': '7.x',
 };
+const DEFAULT_CONFLICT_DISPLAY_LIMIT = 5;
+/**
+ * A map of packages to built-in schematics.
+ * This is used for packages that do not have a native `ng-add` schematic.
+ */
+const BUILT_IN_SCHEMATICS = {
+    tailwindcss: {
+        collection: '@schematics/angular',
+        name: 'tailwind',
+    },
+};
 class AddCommandModule extends schematics_command_module_1.SchematicsCommandModule {
     command = 'add <collection>';
     describe = 'Adds support for an external library to your project.';
@@ -76,6 +86,7 @@ class AddCommandModule extends schematics_command_module_1.SchematicsCommandModu
     allowPrivateSchematics = true;
     schematicName = 'ng-add';
     rootRequire = (0, node_module_1.createRequire)(this.context.root + '/');
+    #projectVersionCache = new Map();
     async builder(argv) {
         const localYargs = (await super.builder(argv))
             .positional('collection', {
@@ -117,6 +128,7 @@ class AddCommandModule extends schematics_command_module_1.SchematicsCommandModu
         return localYargs;
     }
     async run(options) {
+        this.#projectVersionCache.clear();
         const { logger } = this.context;
         const { collection, skipConfirmation } = options;
         let packageIdentifier;
@@ -141,7 +153,8 @@ class AddCommandModule extends schematics_command_module_1.SchematicsCommandModu
         const taskContext = {
             packageIdentifier,
             executeSchematic: this.executeSchematic.bind(this),
-            hasMismatchedPeer: this.hasMismatchedPeer.bind(this),
+            getPeerDependencyConflicts: this.getPeerDependencyConflicts.bind(this),
+            dryRun: options.dryRun,
         };
         const tasks = new listr2_1.Listr([
             {
@@ -162,11 +175,18 @@ class AddCommandModule extends schematics_command_module_1.SchematicsCommandModu
             },
             {
                 title: 'Confirming installation',
-                enabled: !skipConfirmation,
+                enabled: !skipConfirmation && !options.dryRun,
                 task: (context, task) => this.confirmInstallationTask(context, task),
                 rendererOptions: { persistentOutput: true },
             },
             {
+                title: 'Installing package',
+                skip: (context) => {
+                    if (context.dryRun) {
+                        return `Skipping package installation. Would install package ${listr2_1.color.blue(context.packageIdentifier.toString())}.`;
+                    }
+                    return false;
+                },
                 task: (context, task) => this.installPackageTask(context, task, options),
                 rendererOptions: { bottomBar: Infinity },
             },
@@ -177,6 +197,48 @@ class AddCommandModule extends schematics_command_module_1.SchematicsCommandModu
         try {
             const result = await tasks.run(taskContext);
             (0, node_assert_1.default)(result.collectionName, 'Collection name should always be available');
+            // Check if the installed package has actual add actions and not just schematic support
+            if (result.hasSchematics && !options.dryRun) {
+                const workflow = this.getOrCreateWorkflowForBuilder(result.collectionName);
+                const collection = workflow.engine.createCollection(result.collectionName);
+                // listSchematicNames cannot be used here since it does not list private schematics.
+                // Most `ng-add` schematics are marked as private.
+                // TODO: Consider adding a `hasSchematic` helper to the schematic collection object.
+                try {
+                    collection.createSchematic(this.schematicName, true);
+                }
+                catch {
+                    result.hasSchematics = false;
+                }
+            }
+            if (!result.hasSchematics) {
+                // Fallback to a built-in schematic if the package does not have an `ng-add` schematic
+                const packageName = result.packageIdentifier.name;
+                if (packageName) {
+                    const builtInSchematic = BUILT_IN_SCHEMATICS[packageName];
+                    if (builtInSchematic) {
+                        logger.info(`The ${listr2_1.color.blue(packageName)} package does not provide \`ng add\` actions.`);
+                        logger.info('The Angular CLI will use built-in actions to add it to your project.');
+                        return this.executeSchematic({
+                            ...options,
+                            collection: builtInSchematic.collection,
+                            schematicName: builtInSchematic.name,
+                        });
+                    }
+                }
+                let message = options.dryRun
+                    ? 'The package does not provide any `ng add` actions, so no further actions would be taken.'
+                    : 'Package installed successfully. The package does not provide any `ng add` actions, so no further actions were taken.';
+                if (result.homepage) {
+                    message += `\nFor more information about this package, visit its homepage at ${result.homepage}`;
+                }
+                logger.info(message);
+                return;
+            }
+            if (options.dryRun) {
+                logger.info("The package's `ng add` actions would be executed next.");
+                return;
+            }
             return this.executeSchematic({ ...options, collection: result.collectionName });
         }
         catch (e) {
@@ -210,60 +272,79 @@ class AddCommandModule extends schematics_command_module_1.SchematicsCommandModu
             (0, error_1.assertIsError)(e);
             throw new CommandError(`Unable to load package information from registry: ${e.message}`);
         }
+        const rejectionReasons = [];
         // Start with the version tagged as `latest` if it exists
         const latestManifest = packageMetadata.tags['latest'];
         if (latestManifest) {
-            context.packageIdentifier = npm_package_arg_1.default.resolve(latestManifest.name, latestManifest.version);
-        }
-        // Adjust the version based on name and peer dependencies
-        if (latestManifest?.peerDependencies &&
-            Object.keys(latestManifest.peerDependencies).length === 0) {
-            task.output = `Found compatible package version: ${listr2_1.color.blue(latestManifest.version)}.`;
-        }
-        else if (!latestManifest || (await context.hasMismatchedPeer(latestManifest))) {
-            // 'latest' is invalid so search for most recent matching package
-            // Allow prelease versions if the CLI itself is a prerelease
-            const allowPrereleases = (0, semver_1.prerelease)(version_1.VERSION.full);
-            const versionExclusions = packageVersionExclusions[packageMetadata.name];
-            const versionManifests = Object.values(packageMetadata.versions).filter((value) => {
-                // Prerelease versions are not stable and should not be considered by default
-                if (!allowPrereleases && (0, semver_1.prerelease)(value.version)) {
-                    return false;
-                }
-                // Deprecated versions should not be used or considered
-                if (value.deprecated) {
-                    return false;
-                }
-                // Excluded package versions should not be considered
-                if (versionExclusions &&
-                    (0, semver_1.satisfies)(value.version, versionExclusions, { includePrerelease: true })) {
-                    return false;
-                }
-                return true;
-            });
-            // Sort in reverse SemVer order so that the newest compatible version is chosen
-            versionManifests.sort((a, b) => (0, semver_1.compare)(b.version, a.version, true));
-            let found = false;
-            for (const versionManifest of versionManifests) {
-                const mismatch = await context.hasMismatchedPeer(versionManifest);
-                if (mismatch) {
-                    continue;
-                }
-                context.packageIdentifier = npm_package_arg_1.default.resolve(versionManifest.name, versionManifest.version);
-                found = true;
-                break;
-            }
-            if (!found) {
-                task.output = "Unable to find compatible package. Using 'latest' tag.";
+            const latestConflicts = await this.getPeerDependencyConflicts(latestManifest);
+            if (latestConflicts) {
+                // 'latest' is invalid so search for most recent matching package
+                rejectionReasons.push(...latestConflicts);
             }
             else {
-                task.output = `Found compatible package version: ${listr2_1.color.blue(context.packageIdentifier.toString())}.`;
+                context.packageIdentifier = npm_package_arg_1.default.resolve(latestManifest.name, latestManifest.version);
+                task.output = `Found compatible package version: ${listr2_1.color.blue(latestManifest.version)}.`;
+                return;
             }
         }
+        // Allow prelease versions if the CLI itself is a prerelease
+        const allowPrereleases = !!(0, semver_1.prerelease)(version_1.VERSION.full);
+        const versionManifests = this.#getPotentialVersionManifests(packageMetadata, allowPrereleases);
+        let found = false;
+        for (const versionManifest of versionManifests) {
+            // Already checked the 'latest' version
+            if (latestManifest?.version === versionManifest.version) {
+                continue;
+            }
+            const conflicts = await this.getPeerDependencyConflicts(versionManifest);
+            if (conflicts) {
+                if (options.verbose || rejectionReasons.length < DEFAULT_CONFLICT_DISPLAY_LIMIT) {
+                    rejectionReasons.push(...conflicts);
+                }
+                continue;
+            }
+            context.packageIdentifier = npm_package_arg_1.default.resolve(versionManifest.name, versionManifest.version);
+            found = true;
+            break;
+        }
+        if (!found) {
+            let message = `Unable to find compatible package. Using 'latest' tag.`;
+            if (rejectionReasons.length > 0) {
+                message +=
+                    '\nThis is often because of incompatible peer dependencies.\n' +
+                        'These versions were rejected due to the following conflicts:\n' +
+                        rejectionReasons
+                            .slice(0, options.verbose ? undefined : DEFAULT_CONFLICT_DISPLAY_LIMIT)
+                            .map((r) => `  - ${r}`)
+                            .join('\n');
+            }
+            task.output = message;
+        }
         else {
             task.output = `Found compatible package version: ${listr2_1.color.blue(context.packageIdentifier.toString())}.`;
         }
     }
+    #getPotentialVersionManifests(packageMetadata, allowPrereleases) {
+        const versionExclusions = packageVersionExclusions[packageMetadata.name];
+        const versionManifests = Object.values(packageMetadata.versions).filter((value) => {
+            // Prerelease versions are not stable and should not be considered by default
+            if (!allowPrereleases && (0, semver_1.prerelease)(value.version)) {
+                return false;
+            }
+            // Deprecated versions should not be used or considered
+            if (value.deprecated) {
+                return false;
+            }
+            // Excluded package versions should not be considered
+            if (versionExclusions &&
+                (0, semver_1.satisfies)(value.version, versionExclusions, { includePrerelease: true })) {
+                return false;
+            }
+            return true;
+        });
+        // Sort in reverse SemVer order so that the newest compatible version is chosen
+        return versionManifests.sort((a, b) => (0, semver_1.compare)(b.version, a.version, true));
+    }
     async loadPackageInfoTask(context, task, options) {
         const { logger } = this.context;
         const { verbose, registry } = options;
@@ -279,9 +360,11 @@ class AddCommandModule extends schematics_command_module_1.SchematicsCommandModu
             (0, error_1.assertIsError)(e);
             throw new CommandError(`Unable to fetch package information for '${context.packageIdentifier}': ${e.message}`);
         }
+        context.hasSchematics = !!manifest.schematics;
         context.savePackage = manifest['ng-add']?.save;
         context.collectionName = manifest.name;
-        if (await context.hasMismatchedPeer(manifest)) {
+        context.homepage = manifest.homepage;
+        if (await this.getPeerDependencyConflicts(manifest)) {
             task.output = listr2_1.color.yellow(listr2_1.figures.warning +
                 ' Package has unmet peer dependencies. Adding the package may not succeed.');
         }
@@ -385,32 +468,26 @@ class AddCommandModule extends schematics_command_module_1.SchematicsCommandModu
         }
         return false;
     }
-    async executeSchematic(options) {
-        try {
-            const { verbose, skipConfirmation, interactive, force, dryRun, registry, defaults, collection: collectionName, ...schematicOptions } = options;
-            return await this.runSchematic({
-                schematicOptions,
-                schematicName: this.schematicName,
-                collectionName,
-                executionOptions: {
-                    interactive,
-                    force,
-                    dryRun,
-                    defaults,
-                    packageRegistry: registry,
-                },
-            });
-        }
-        catch (e) {
-            if (e instanceof tools_1.NodePackageDoesNotSupportSchematics) {
-                this.context.logger.error('The package that you are trying to add does not support schematics.' +
-                    'You can try using a different version of the package or contact the package author to add ng-add support.');
-                return 1;
-            }
-            throw e;
-        }
+    executeSchematic(options) {
+        const { verbose, skipConfirmation, interactive, force, dryRun, registry, defaults, collection: collectionName, schematicName, ...schematicOptions } = options;
+        return this.runSchematic({
+            schematicOptions,
+            schematicName: schematicName ?? this.schematicName,
+            collectionName,
+            executionOptions: {
+                interactive,
+                force,
+                dryRun,
+                defaults,
+                packageRegistry: registry,
+            },
+        });
     }
     async findProjectVersion(name) {
+        const cachedVersion = this.#projectVersionCache.get(name);
+        if (cachedVersion !== undefined) {
+            return cachedVersion;
+        }
         const { logger, root } = this.context;
         let installedPackage;
         try {
@@ -420,6 +497,7 @@ class AddCommandModule extends schematics_command_module_1.SchematicsCommandModu
         if (installedPackage) {
             try {
                 const installed = await (0, package_metadata_1.fetchPackageManifest)((0, node_path_1.dirname)(installedPackage), logger);
+                this.#projectVersionCache.set(name, installed.version);
                 return installed.version;
             }
             catch { }
@@ -432,44 +510,50 @@ class AddCommandModule extends schematics_command_module_1.SchematicsCommandModu
         if (projectManifest) {
             const version = projectManifest.dependencies?.[name] || projectManifest.devDependencies?.[name];
             if (version) {
+                this.#projectVersionCache.set(name, version);
                 return version;
             }
         }
+        this.#projectVersionCache.set(name, null);
         return null;
     }
-    async hasMismatchedPeer(manifest) {
-        for (const peer in manifest.peerDependencies) {
+    async getPeerDependencyConflicts(manifest) {
+        if (!manifest.peerDependencies) {
+            return false;
+        }
+        const checks = Object.entries(manifest.peerDependencies).map(async ([peer, range]) => {
             let peerIdentifier;
             try {
-                peerIdentifier = npm_package_arg_1.default.resolve(peer, manifest.peerDependencies[peer]);
+                peerIdentifier = npm_package_arg_1.default.resolve(peer, range);
             }
             catch {
                 this.context.logger.warn(`Invalid peer dependency ${peer} found in package.`);
-                continue;
+                return null;
             }
-            if (peerIdentifier.type === 'version' || peerIdentifier.type === 'range') {
-                try {
-                    const version = await this.findProjectVersion(peer);
-                    if (!version) {
-                        continue;
-                    }
-                    const options = { includePrerelease: true };
-                    if (!(0, semver_1.intersects)(version, peerIdentifier.rawSpec, options) &&
-                        !(0, semver_1.satisfies)(version, peerIdentifier.rawSpec, options)) {
-                        return true;
-                    }
+            if (peerIdentifier.type !== 'version' && peerIdentifier.type !== 'range') {
+                // type === 'tag' | 'file' | 'directory' | 'remote' | 'git'
+                // Cannot accurately compare these as the tag/location may have changed since install.
+                return null;
+            }
+            try {
+                const version = await this.findProjectVersion(peer);
+                if (!version) {
+                    return null;
                 }
-                catch {
-                    // Not found or invalid so ignore
-                    continue;
+                const options = { includePrerelease: true };
+                if (!(0, semver_1.intersects)(version, peerIdentifier.rawSpec, options) &&
+                    !(0, semver_1.satisfies)(version, peerIdentifier.rawSpec, options)) {
+                    return (`Package "${manifest.name}@${manifest.version}" has an incompatible peer dependency to "` +
+                        `${peer}@${peerIdentifier.rawSpec}" (requires "${version}" in project).`);
                 }
             }
-            else {
-                // type === 'tag' | 'file' | 'directory' | 'remote' | 'git'
-                // Cannot accurately compare these as the tag/location may have changed since install
+            catch {
+                // Not found or invalid so ignore
             }
-        }
-        return false;
+            return null;
+        });
+        const conflicts = (await Promise.all(checks)).filter((result) => !!result);
+        return conflicts.length > 0 && conflicts;
     }
 }
 exports.default = AddCommandModule;

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">;
+}>;