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

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/utilities/package-manager.d.ts

@@ -12,8 +12,14 @@ export interface PackageManagerUtilsContext {
     workspace?: AngularWorkspace;
     root: string;
 }
+/**
+ * Utilities for interacting with various package managers.
+ */
 export declare class PackageManagerUtils {
     private readonly context;
+    /**
+     * @param context The context for the package manager utilities, including workspace and global configuration.
+     */
     constructor(context: PackageManagerUtilsContext);
     /** Get the package manager name. */
     get name(): PackageManager;
@@ -32,6 +38,12 @@ export declare class PackageManagerUtils {
     private run;
     private getVersion;
     private getName;
+    /**
+     * Checks if a lockfile for a specific package manager exists in the root directory.
+     * @param packageManager The package manager to check for.
+     * @param filesInRoot An array of file names in the root directory.
+     * @returns True if the lockfile exists, false otherwise.
+     */
     private hasLockfile;
     private getConfiguredPackageManager;
 }

package/src/utilities/package-manager.js

@@ -50,6 +50,18 @@ const node_path_1 = require("node:path");
 const workspace_schema_1 = require("../../lib/config/workspace-schema");
 const config_1 = require("./config");
 const memoize_1 = require("./memoize");
+/**
+ * A map of package managers to their corresponding lockfile names.
+ */
+const LOCKFILE_NAMES = {
+    [workspace_schema_1.PackageManager.Yarn]: 'yarn.lock',
+    [workspace_schema_1.PackageManager.Pnpm]: 'pnpm-lock.yaml',
+    [workspace_schema_1.PackageManager.Bun]: ['bun.lockb', 'bun.lock'],
+    [workspace_schema_1.PackageManager.Npm]: 'package-lock.json',
+};
+/**
+ * Utilities for interacting with various package managers.
+ */
 let PackageManagerUtils = (() => {
     let _instanceExtraInitializers = [];
     let _getVersion_decorators;
@@ -64,6 +76,9 @@ let PackageManagerUtils = (() => {
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
         context = __runInitializers(this, _instanceExtraInitializers);
+        /**
+         * @param context The context for the package manager utilities, including workspace and global configuration.
+         */
         constructor(context) {
             this.context = context;
         }
@@ -211,10 +226,11 @@ let PackageManagerUtils = (() => {
             if (packageManager) {
                 return packageManager;
             }
-            const hasNpmLock = this.hasLockfile(workspace_schema_1.PackageManager.Npm);
-            const hasYarnLock = this.hasLockfile(workspace_schema_1.PackageManager.Yarn);
-            const hasPnpmLock = this.hasLockfile(workspace_schema_1.PackageManager.Pnpm);
-            const hasBunLock = this.hasLockfile(workspace_schema_1.PackageManager.Bun);
+            const filesInRoot = (0, node_fs_1.readdirSync)(this.context.root);
+            const hasNpmLock = this.hasLockfile(workspace_schema_1.PackageManager.Npm, filesInRoot);
+            const hasYarnLock = this.hasLockfile(workspace_schema_1.PackageManager.Yarn, filesInRoot);
+            const hasPnpmLock = this.hasLockfile(workspace_schema_1.PackageManager.Pnpm, filesInRoot);
+            const hasBunLock = this.hasLockfile(workspace_schema_1.PackageManager.Bun, filesInRoot);
             // PERF NOTE: `this.getVersion` spawns the package a the child_process which can take around ~300ms at times.
             // Therefore, we should only call this method when needed. IE: don't call `this.getVersion(PackageManager.Pnpm)` unless truly needed.
             // The result of this method is not stored in a variable because it's memoized.
@@ -259,24 +275,17 @@ let PackageManagerUtils = (() => {
             //       Potentially with a prompt to choose and optionally set as the default.
             return workspace_schema_1.PackageManager.Npm;
         }
-        hasLockfile(packageManager) {
-            let lockfileName;
-            switch (packageManager) {
-                case workspace_schema_1.PackageManager.Yarn:
-                    lockfileName = 'yarn.lock';
-                    break;
-                case workspace_schema_1.PackageManager.Pnpm:
-                    lockfileName = 'pnpm-lock.yaml';
-                    break;
-                case workspace_schema_1.PackageManager.Bun:
-                    lockfileName = 'bun.lockb';
-                    break;
-                case workspace_schema_1.PackageManager.Npm:
-                default:
-                    lockfileName = 'package-lock.json';
-                    break;
-            }
-            return (0, node_fs_1.existsSync)((0, node_path_1.join)(this.context.root, lockfileName));
+        /**
+         * Checks if a lockfile for a specific package manager exists in the root directory.
+         * @param packageManager The package manager to check for.
+         * @param filesInRoot An array of file names in the root directory.
+         * @returns True if the lockfile exists, false otherwise.
+         */
+        hasLockfile(packageManager, filesInRoot) {
+            const lockfiles = LOCKFILE_NAMES[packageManager];
+            return typeof lockfiles === 'string'
+                ? filesInRoot.includes(lockfiles)
+                : lockfiles.some((lockfile) => filesInRoot.includes(lockfile));
         }
         getConfiguredPackageManager() {
             const getPackageManager = (source) => {

package/src/utilities/version.js

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