@angular/cli 21.0.0-next.5 → 21.0.0-next.7

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

@@ -10,6 +10,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseJsonSchemaToOptions = parseJsonSchemaToOptions;
 exports.addSchemaOptionsToCommand = addSchemaOptionsToCommand;
 const core_1 = require("@angular-devkit/core");
+/**
+ * A Yargs check function that validates that the given options are in the form of `key=value`.
+ * @param keyValuePairOptions A set of options that should be in the form of `key=value`.
+ * @param args The parsed arguments.
+ * @returns `true` if the options are valid, otherwise an error is thrown.
+ */
 function checkStringMap(keyValuePairOptions, args) {
     for (const key of keyValuePairOptions) {
         const value = args[key];
@@ -28,6 +34,11 @@ function checkStringMap(keyValuePairOptions, args) {
     }
     return true;
 }
+/**
+ * A Yargs coerce function that converts an array of `key=value` strings to an object.
+ * @param value An array of `key=value` strings.
+ * @returns An object with the keys and values from the input array.
+ */
 function coerceToStringMap(value) {
     const stringMap = {};
     for (const pair of value) {
@@ -45,6 +56,12 @@ function coerceToStringMap(value) {
     }
     return stringMap;
 }
+/**
+ * Checks if a JSON schema node represents a string map.
+ * A string map is an object with `additionalProperties` of type `string`.
+ * @param node The JSON schema node to check.
+ * @returns `true` if the node represents a string map, otherwise `false`.
+ */
 function isStringMap(node) {
     // Exclude fields with more specific kinds of properties.
     if (node.properties || node.patternProperties) {
@@ -55,131 +72,197 @@ function isStringMap(node) {
         !node.additionalProperties.enum &&
         node.additionalProperties.type === 'string');
 }
+const SUPPORTED_PRIMITIVE_TYPES = new Set(['boolean', 'number', 'string']);
+/**
+ * Checks if a string is a supported primitive type.
+ * @param value The string to check.
+ * @returns `true` if the string is a supported primitive type, otherwise `false`.
+ */
+function isSupportedPrimitiveType(value) {
+    return SUPPORTED_PRIMITIVE_TYPES.has(value);
+}
+/**
+ * Recursively checks if a JSON schema for an array's items is a supported primitive type.
+ * It supports `oneOf` and `anyOf` keywords.
+ * @param schema The JSON schema for the array's items.
+ * @returns `true` if the schema is a supported primitive type, otherwise `false`.
+ */
+function isSupportedArrayItemSchema(schema) {
+    if (typeof schema.type === 'string' && isSupportedPrimitiveType(schema.type)) {
+        return true;
+    }
+    if (core_1.json.isJsonArray(schema.enum)) {
+        return true;
+    }
+    if (core_1.json.isJsonArray(schema.items)) {
+        return schema.items.some((item) => (0, core_1.isJsonObject)(item) && isSupportedArrayItemSchema(item));
+    }
+    if (core_1.json.isJsonArray(schema.oneOf) &&
+        schema.oneOf.some((item) => (0, core_1.isJsonObject)(item) && isSupportedArrayItemSchema(item))) {
+        return true;
+    }
+    if (core_1.json.isJsonArray(schema.anyOf) &&
+        schema.anyOf.some((item) => (0, core_1.isJsonObject)(item) && isSupportedArrayItemSchema(item))) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Gets the supported types for a JSON schema node.
+ * @param current The JSON schema node to get the supported types for.
+ * @returns An array of supported types.
+ */
+function getSupportedTypes(current) {
+    const typeSet = core_1.json.schema.getTypesOfSchema(current);
+    if (typeSet.size === 0) {
+        return [];
+    }
+    return [...typeSet].filter((type) => {
+        switch (type) {
+            case 'boolean':
+            case 'number':
+            case 'string':
+                return true;
+            case 'array':
+                return (0, core_1.isJsonObject)(current.items) && isSupportedArrayItemSchema(current.items);
+            case 'object':
+                return isStringMap(current);
+            default:
+                return false;
+        }
+    });
+}
+/**
+ * Gets the enum values for a JSON schema node.
+ * @param current The JSON schema node to get the enum values for.
+ * @returns An array of enum values.
+ */
+function getEnumValues(current) {
+    if (core_1.json.isJsonArray(current.enum)) {
+        return current.enum.sort();
+    }
+    if ((0, core_1.isJsonObject)(current.items)) {
+        const enumValues = getEnumValues(current.items);
+        if (enumValues?.length) {
+            return enumValues;
+        }
+    }
+    if (typeof current.type === 'string' && isSupportedPrimitiveType(current.type)) {
+        return [];
+    }
+    const subSchemas = (core_1.json.isJsonArray(current.oneOf) && current.oneOf) ||
+        (core_1.json.isJsonArray(current.anyOf) && current.anyOf);
+    if (subSchemas) {
+        // Find the first enum.
+        for (const subSchema of subSchemas) {
+            if ((0, core_1.isJsonObject)(subSchema)) {
+                const enumValues = getEnumValues(subSchema);
+                if (enumValues) {
+                    return enumValues;
+                }
+            }
+        }
+    }
+    return [];
+}
+/**
+ * Gets the default value for a JSON schema node.
+ * @param current The JSON schema node to get the default value for.
+ * @param type The type of the JSON schema node.
+ * @returns The default value, or `undefined` if there is no default value.
+ */
+function getDefaultValue(current, type) {
+    const defaultValue = current.default;
+    if (defaultValue === undefined) {
+        return undefined;
+    }
+    if (type === 'array') {
+        return Array.isArray(defaultValue) && defaultValue.length > 0 ? defaultValue : undefined;
+    }
+    if (typeof defaultValue === type) {
+        return defaultValue;
+    }
+    return undefined;
+}
+/**
+ * Gets the aliases for a JSON schema node.
+ * @param current The JSON schema node to get the aliases for.
+ * @returns An array of aliases.
+ */
+function getAliases(current) {
+    if (core_1.json.isJsonArray(current.aliases)) {
+        return [...current.aliases].map(String);
+    }
+    if (current.alias) {
+        return [String(current.alias)];
+    }
+    return [];
+}
+/**
+ * Parses a JSON schema to a list of options that can be used by yargs.
+ *
+ * @param registry A schema registry to use for flattening the schema.
+ * @param schema The JSON schema to parse.
+ * @param interactive Whether to prompt the user for missing options.
+ * @returns A list of options.
+ *
+ * @note The schema definition are not resolved at this stage. This means that `$ref` will not be resolved,
+ * and custom keywords like `x-prompt` will not be processed.
+ */
 async function parseJsonSchemaToOptions(registry, schema, interactive = true) {
     const options = [];
     function visitor(current, pointer, parentSchema) {
-        if (!parentSchema) {
-            // Ignore root.
-            return;
-        }
-        else if (pointer.split(/\/(?:properties|items|definitions)\//g).length > 2) {
-            // Ignore subitems (objects or arrays).
-            return;
-        }
-        else if (core_1.json.isJsonArray(current)) {
+        if (!parentSchema ||
+            core_1.json.isJsonArray(current) ||
+            pointer.split(/\/(?:properties|items|definitions)\//g).length > 2) {
+            // Ignore root, arrays, and subitems.
             return;
         }
-        if (pointer.indexOf('/not/') != -1) {
+        if (pointer.includes('/not/')) {
             // We don't support anyOf/not.
             throw new Error('The "not" keyword is not supported in JSON Schema.');
         }
         const ptr = core_1.json.schema.parseJsonPointer(pointer);
-        const name = ptr[ptr.length - 1];
-        if (ptr[ptr.length - 2] != 'properties') {
+        if (ptr[ptr.length - 2] !== 'properties') {
             // Skip any non-property items.
             return;
         }
-        const typeSet = core_1.json.schema.getTypesOfSchema(current);
-        if (typeSet.size == 0) {
-            throw new Error('Cannot find type of schema.');
-        }
-        // We only support number, string or boolean (or array of those), so remove everything else.
-        const types = [...typeSet].filter((x) => {
-            switch (x) {
-                case 'boolean':
-                case 'number':
-                case 'string':
-                    return true;
-                case 'array':
-                    // Only include arrays if they're boolean, string or number.
-                    if (core_1.json.isJsonObject(current.items) &&
-                        typeof current.items.type == 'string' &&
-                        isValidTypeForEnum(current.items.type)) {
-                        return true;
-                    }
-                    return false;
-                case 'object':
-                    return isStringMap(current);
-                default:
-                    return false;
-            }
-        });
-        if (types.length == 0) {
+        const name = ptr[ptr.length - 1];
+        const types = getSupportedTypes(current);
+        if (types.length === 0) {
             // This means it's not usable on the command line. e.g. an Object.
             return;
         }
-        // Only keep enum values we support (booleans, numbers and strings).
-        const enumValues = ((core_1.json.isJsonArray(current.enum) && current.enum) ||
-            (core_1.json.isJsonObject(current.items) &&
-                core_1.json.isJsonArray(current.items.enum) &&
-                current.items.enum) ||
-            [])
-            .filter((value) => isValidTypeForEnum(typeof value))
-            .sort();
-        let defaultValue = undefined;
-        if (current.default !== undefined) {
-            switch (types[0]) {
-                case 'string':
-                    if (typeof current.default == 'string') {
-                        defaultValue = current.default;
-                    }
-                    break;
-                case 'array':
-                    if (Array.isArray(current.default) && current.default.length > 0) {
-                        defaultValue = current.default;
-                    }
-                    break;
-                case 'number':
-                    if (typeof current.default == 'number') {
-                        defaultValue = current.default;
-                    }
-                    break;
-                case 'boolean':
-                    if (typeof current.default == 'boolean') {
-                        defaultValue = current.default;
-                    }
-                    break;
-            }
-        }
+        const [type] = types;
         const $default = current.$default;
-        const $defaultIndex = core_1.json.isJsonObject($default) && $default['$source'] == 'argv' ? $default['index'] : undefined;
-        const positional = typeof $defaultIndex == 'number' ? $defaultIndex : undefined;
-        let required = core_1.json.isJsonArray(schema.required) ? schema.required.includes(name) : false;
+        const $defaultIndex = (0, core_1.isJsonObject)($default) && $default['$source'] === 'argv' ? $default['index'] : undefined;
+        const positional = typeof $defaultIndex === 'number' ? $defaultIndex : undefined;
+        let required = core_1.json.isJsonArray(schema.required) && schema.required.includes(name);
         if (required && interactive && current['x-prompt']) {
             required = false;
         }
-        const alias = core_1.json.isJsonArray(current.aliases)
-            ? [...current.aliases].map((x) => '' + x)
-            : current.alias
-                ? ['' + current.alias]
-                : [];
-        const format = typeof current.format == 'string' ? current.format : undefined;
-        const visible = current.visible === undefined || current.visible === true;
-        const hidden = !!current.hidden || !visible;
-        const xUserAnalytics = current['x-user-analytics'];
-        const userAnalytics = typeof xUserAnalytics === 'string' ? xUserAnalytics : undefined;
-        // Deprecated is set only if it's true or a string.
+        const visible = current.visible !== false;
         const xDeprecated = current['x-deprecated'];
-        const deprecated = xDeprecated === true || typeof xDeprecated === 'string' ? xDeprecated : undefined;
+        const enumValues = getEnumValues(current);
         const option = {
             name,
-            description: '' + (current.description === undefined ? '' : current.description),
-            default: defaultValue,
-            choices: enumValues.length ? enumValues : undefined,
+            description: String(current.description ?? ''),
+            default: getDefaultValue(current, type),
+            choices: enumValues?.length ? enumValues : undefined,
             required,
-            alias,
-            format,
-            hidden,
-            userAnalytics,
-            deprecated,
+            alias: getAliases(current),
+            format: typeof current.format === 'string' ? current.format : undefined,
+            hidden: !!current.hidden || !visible,
+            userAnalytics: typeof current['x-user-analytics'] === 'string' ? current['x-user-analytics'] : undefined,
+            deprecated: xDeprecated === true || typeof xDeprecated === 'string' ? xDeprecated : undefined,
             positional,
-            ...(types[0] === 'object'
+            ...(type === 'object'
                 ? {
                     type: 'array',
                     itemValueType: 'string',
                 }
                 : {
-                    type: types[0],
+                    type,
                 }),
         };
         options.push(option);
@@ -263,7 +346,3 @@ function addSchemaOptionsToCommand(localYargs, options, includeDefaultValues) {
     }
     return optionsWithAnalytics;
 }
-const VALID_ENUM_TYPES = new Set(['boolean', 'number', 'string']);
-function isValidTypeForEnum(value) {
-    return VALID_ENUM_TYPES.has(value);
-}

package/src/commands/cache/info/cli.js

@@ -41,10 +41,10 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CacheInfoCommandModule = void 0;
-const core_1 = require("@angular-devkit/core");
 const fs = __importStar(require("node:fs/promises"));
 const node_path_1 = require("node:path");
 const command_module_1 = require("../../../command-builder/command-module");
+const color_1 = require("../../../utilities/color");
 const environment_options_1 = require("../../../utilities/environment-options");
 const utilities_1 = require("../utilities");
 class CacheInfoCommandModule extends command_module_1.CommandModule {
@@ -56,14 +56,38 @@ class CacheInfoCommandModule extends command_module_1.CommandModule {
         return localYargs.strict();
     }
     async run() {
-        const { path, environment, enabled } = (0, utilities_1.getCacheConfig)(this.context.workspace);
-        this.context.logger.info(core_1.tags.stripIndents `
-      Enabled: ${enabled ? 'yes' : 'no'}
-      Environment: ${environment}
-      Path: ${path}
-      Size on disk: ${await this.getSizeOfDirectory(path)}
-      Effective status on current machine: ${this.effectiveEnabledStatus() ? 'enabled' : 'disabled'}
-    `);
+        const cacheConfig = (0, utilities_1.getCacheConfig)(this.context.workspace);
+        const { path, environment, enabled } = cacheConfig;
+        const effectiveStatus = this.effectiveEnabledStatus(cacheConfig);
+        const sizeOnDisk = await this.getSizeOfDirectory(path);
+        const info = [
+            {
+                label: 'Enabled',
+                value: enabled ? color_1.colors.green('Yes') : color_1.colors.red('No'),
+            },
+            {
+                label: 'Environment',
+                value: color_1.colors.cyan(environment),
+            },
+            {
+                label: 'Path',
+                value: color_1.colors.cyan(path),
+            },
+            {
+                label: 'Size on disk',
+                value: color_1.colors.cyan(sizeOnDisk),
+            },
+            {
+                label: 'Effective Status',
+                value: (effectiveStatus ? color_1.colors.green('Enabled') : color_1.colors.red('Disabled')) +
+                    ' (current machine)',
+            },
+        ];
+        const maxLabelLength = Math.max(...info.map((l) => l.label.length));
+        const output = info
+            .map(({ label, value }) => color_1.colors.bold(label.padEnd(maxLabelLength + 2)) + `: ${value}`)
+            .join('\n');
+        this.context.logger.info(`\n${color_1.colors.bold('Cache Information')}\n\n${output}\n`);
     }
     async getSizeOfDirectory(path) {
         const directoriesStack = [path];
@@ -98,8 +122,8 @@ class CacheInfoCommandModule extends command_module_1.CommandModule {
         const fractionDigits = index === 0 ? 0 : 2;
         return `${roundedSize.toFixed(fractionDigits)} ${abbreviations[index]}`;
     }
-    effectiveEnabledStatus() {
-        const { enabled, environment } = (0, utilities_1.getCacheConfig)(this.context.workspace);
+    effectiveEnabledStatus(cacheConfig) {
+        const { enabled, environment } = cacheConfig;
         if (enabled) {
             switch (environment) {
                 case 'ci':

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

@@ -84,9 +84,10 @@ tutorials, concepts, and best practices.
 </Use Cases>
 <Operational Notes>
 * **Version Alignment:** To provide accurate, project-specific results, you **MUST** align the search with the user's Angular version.
-  Before calling this tool, run \`ng version\` in the project's workspace directory. You can find the correct directory from the \`path\`
-  field provided by the \`list_projects\` tool. Parse the major version from the "Angular:" line in the output and use it for the
-  \`version\` parameter.
+  The recommended approach is to use the \`list_projects\` tool. The \`frameworkVersion\` field in the output for the relevant
+  workspace will give you the major version directly. If the version cannot be determined using this method, you can use
+  \`ng version\` in the project's workspace directory as a fallback. Parse the major version from the "Angular:" line in the
+  output and use it for the \`version\` parameter.
 * 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

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

@@ -9,9 +9,11 @@ import z from 'zod';
 export declare const LIST_PROJECTS_TOOL: import("./tool-registry").McpToolDeclaration<z.ZodRawShape, {
     workspaces: z.ZodArray<z.ZodObject<{
         path: z.ZodString;
+        frameworkVersion: z.ZodOptional<z.ZodString>;
         projects: z.ZodArray<z.ZodObject<{
             name: z.ZodString;
             type: z.ZodOptional<z.ZodEnum<["application", "library"]>>;
+            builder: z.ZodOptional<z.ZodString>;
             root: z.ZodString;
             sourceRoot: z.ZodString;
             selectorPrefix: z.ZodOptional<z.ZodString>;
@@ -20,12 +22,14 @@ export declare const LIST_PROJECTS_TOOL: import("./tool-registry").McpToolDeclar
             root: string;
             sourceRoot: string;
             type?: "application" | "library" | undefined;
+            builder?: string | undefined;
             selectorPrefix?: string | undefined;
         }, {
             name: string;
             root: string;
             sourceRoot: string;
             type?: "application" | "library" | undefined;
+            builder?: string | undefined;
             selectorPrefix?: string | undefined;
         }>, "many">;
     }, "strip", z.ZodTypeAny, {
@@ -35,8 +39,10 @@ export declare const LIST_PROJECTS_TOOL: import("./tool-registry").McpToolDeclar
             root: string;
             sourceRoot: string;
             type?: "application" | "library" | undefined;
+            builder?: string | undefined;
             selectorPrefix?: string | undefined;
         }[];
+        frameworkVersion?: string | undefined;
     }, {
         path: string;
         projects: {
@@ -44,8 +50,10 @@ export declare const LIST_PROJECTS_TOOL: import("./tool-registry").McpToolDeclar
             root: string;
             sourceRoot: string;
             type?: "application" | "library" | undefined;
+            builder?: string | undefined;
             selectorPrefix?: string | undefined;
         }[];
+        frameworkVersion?: string | undefined;
     }>, "many">;
     parsingErrors: z.ZodDefault<z.ZodArray<z.ZodObject<{
         filePath: z.ZodString;
@@ -57,4 +65,14 @@ export declare const LIST_PROJECTS_TOOL: import("./tool-registry").McpToolDeclar
         message: string;
         filePath: string;
     }>, "many">>;
+    versioningErrors: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        filePath: z.ZodString;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        filePath: string;
+    }, {
+        message: string;
+        filePath: string;
+    }>, "many">>;
 }>;