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

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

@@ -14,6 +14,7 @@ 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 semver_1 = __importDefault(require("semver"));
 const zod_1 = __importDefault(require("zod"));
 const config_1 = require("../../../utilities/config");
 const error_1 = require("../../../utilities/error");
@@ -21,6 +22,10 @@ const tool_registry_1 = require("./tool-registry");
 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.'),
+        frameworkVersion: zod_1.default
+            .string()
+            .optional()
+            .describe('The major version of the Angular framework (`@angular/core`) in this workspace, if found.'),
         projects: zod_1.default.array(zod_1.default.object({
             name: zod_1.default
                 .string()
@@ -29,6 +34,10 @@ const listProjectsOutputSchema = {
                 .enum(['application', 'library'])
                 .optional()
                 .describe(`The type of the project, either 'application' or 'library'.`),
+            builder: zod_1.default
+                .string()
+                .optional()
+                .describe('The primary builder for the project, typically from the "build" target.'),
             root: zod_1.default
                 .string()
                 .describe('The root directory of the project, relative to the workspace root.'),
@@ -49,6 +58,15 @@ const listProjectsOutputSchema = {
     }))
         .default([])
         .describe('A list of files that looked like workspaces but failed to parse.'),
+    versioningErrors: zod_1.default
+        .array(zod_1.default.object({
+        filePath: zod_1.default
+            .string()
+            .describe('The path to the workspace `angular.json` for which versioning failed.'),
+        message: zod_1.default.string().describe('The error message detailing why versioning failed.'),
+    }))
+        .default([])
+        .describe('A list of workspaces for which the framework version could not be determined.'),
 };
 exports.LIST_PROJECTS_TOOL = (0, tool_registry_1.declareTool)({
     name: 'list_projects',
@@ -64,6 +82,8 @@ their types, and their locations.
 * 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.
+* Identifying the major version of the Angular framework for each workspace, which is crucial for monorepos.
+* Determining a project's primary function by inspecting its builder (e.g., '@angular-devkit/build-angular:browser' for an application).
 </Use Cases>
 <Operational Notes>
 * **Working Directory:** Shell commands for a project (like \`ng generate\`) **MUST**
@@ -122,6 +142,64 @@ async function* findAngularJsonFiles(rootDir) {
         yield* foundFilesInBatch;
     }
 }
+/**
+ * Searches upwards from a starting directory to find the version of '@angular/core'.
+ * It caches results to avoid redundant lookups.
+ * @param startDir The directory to start the search from.
+ * @param cache A map to store cached results.
+ * @param searchRoot The directory at which to stop the search.
+ * @returns The major version of '@angular/core' as a string, otherwise undefined.
+ */
+async function findAngularCoreVersion(startDir, cache, searchRoot) {
+    let currentDir = startDir;
+    const dirsToCache = [];
+    while (currentDir) {
+        dirsToCache.push(currentDir);
+        if (cache.has(currentDir)) {
+            const cachedResult = cache.get(currentDir);
+            // Populate cache for all intermediate directories.
+            for (const dir of dirsToCache) {
+                cache.set(dir, cachedResult);
+            }
+            return cachedResult;
+        }
+        const pkgPath = node_path_1.default.join(currentDir, 'package.json');
+        try {
+            const pkgContent = await (0, promises_1.readFile)(pkgPath, 'utf-8');
+            const pkg = JSON.parse(pkgContent);
+            const versionSpecifier = pkg.dependencies?.['@angular/core'] ?? pkg.devDependencies?.['@angular/core'];
+            if (versionSpecifier) {
+                const minVersion = semver_1.default.minVersion(versionSpecifier);
+                const result = minVersion ? String(minVersion.major) : undefined;
+                for (const dir of dirsToCache) {
+                    cache.set(dir, result);
+                }
+                return result;
+            }
+        }
+        catch (error) {
+            (0, error_1.assertIsError)(error);
+            if (error.code !== 'ENOENT') {
+                // Ignore missing package.json files, but rethrow other errors.
+                throw error;
+            }
+        }
+        // Stop if we are at the search root or the filesystem root.
+        if (currentDir === searchRoot) {
+            break;
+        }
+        const parentDir = node_path_1.default.dirname(currentDir);
+        if (parentDir === currentDir) {
+            break; // Reached the filesystem root.
+        }
+        currentDir = parentDir;
+    }
+    // Cache the failure for all traversed directories.
+    for (const dir of dirsToCache) {
+        cache.set(dir, undefined);
+    }
+    return undefined;
+}
 /**
  * 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.
@@ -142,6 +220,7 @@ async function loadAndParseWorkspace(configFile, seenPaths) {
             projects.push({
                 name,
                 type: project.extensions['projectType'],
+                builder: project.targets.get('build')?.builder,
                 root: project.root,
                 sourceRoot: project.sourceRoot ?? node_path_1.default.posix.join(project.root, 'src'),
                 selectorPrefix: project.extensions['prefix'],
@@ -160,11 +239,44 @@ async function loadAndParseWorkspace(configFile, seenPaths) {
         return { workspace: null, error: { filePath: configFile, message } };
     }
 }
+/**
+ * Processes a single `angular.json` file to extract workspace and framework version information.
+ * @param configFile The path to the `angular.json` file.
+ * @param searchRoot The directory at which to stop the upward search for `package.json`.
+ * @param seenPaths A Set of absolute paths that have already been processed to avoid duplicates.
+ * @param versionCache A Map to cache framework version lookups for performance.
+ * @returns A promise resolving to an object containing the processed data and any errors.
+ */
+async function processConfigFile(configFile, searchRoot, seenPaths, versionCache) {
+    const { workspace, error } = await loadAndParseWorkspace(configFile, seenPaths);
+    if (error) {
+        return { parsingError: error };
+    }
+    if (!workspace) {
+        return {}; // Skipped as it was already seen.
+    }
+    try {
+        const workspaceDir = node_path_1.default.dirname(configFile);
+        workspace.frameworkVersion = await findAngularCoreVersion(workspaceDir, versionCache, searchRoot);
+        return { workspace };
+    }
+    catch (e) {
+        return {
+            workspace,
+            versioningError: {
+                filePath: workspace.path,
+                message: e instanceof Error ? e.message : 'An unknown error occurred.',
+            },
+        };
+    }
+}
 async function createListProjectsHandler({ server }) {
     return async () => {
         const workspaces = [];
         const parsingErrors = [];
+        const versioningErrors = [];
         const seenPaths = new Set();
+        const versionCache = new Map();
         let searchRoots;
         const clientCapabilities = server.server.getClientCapabilities();
         if (clientCapabilities?.roots) {
@@ -177,12 +289,15 @@ async function createListProjectsHandler({ server }) {
         }
         for (const root of searchRoots) {
             for await (const configFile of findAngularJsonFiles(root)) {
-                const { workspace, error } = await loadAndParseWorkspace(configFile, seenPaths);
+                const { workspace, parsingError, versioningError } = await processConfigFile(configFile, root, seenPaths, versionCache);
                 if (workspace) {
                     workspaces.push(workspace);
                 }
-                if (error) {
-                    parsingErrors.push(error);
+                if (parsingError) {
+                    parsingErrors.push(parsingError);
+                }
+                if (versioningError) {
+                    versioningErrors.push(versioningError);
                 }
             }
         }
@@ -204,9 +319,13 @@ async function createListProjectsHandler({ server }) {
             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');
         }
+        if (versioningErrors.length > 0) {
+            text += `\n\nWarning: The framework version for the following ${versioningErrors.length} workspace(s) could not be determined:\n`;
+            text += versioningErrors.map((e) => `- ${e.filePath}: ${e.message}`).join('\n');
+        }
         return {
             content: [{ type: 'text', text }],
-            structuredContent: { workspaces, parsingErrors },
+            structuredContent: { workspaces, parsingErrors, versioningErrors },
         };
     };
 }

package/src/commands/version/cli.d.ts

@@ -24,13 +24,9 @@ export default class VersionCommandModule extends CommandModule implements Comma
     /**
      * The main execution logic for the `ng version` command.
      */
-    run(): Promise<void>;
-    /**
-     * Formats the Angular packages section of the version output.
-     * @param versionInfo An object containing the version information.
-     * @returns A string containing the formatted Angular packages information.
-     */
-    private formatAngularPackages;
+    run(options: {
+        json?: boolean;
+    }): Promise<void>;
     /**
      * Formats the package table section of the version output.
      * @param versions A map of package names to their versions.

package/src/commands/version/cli.js

@@ -39,55 +39,44 @@ class VersionCommandModule extends command_module_1.CommandModule {
      * @returns The configured `yargs` instance.
      */
     builder(localYargs) {
-        return localYargs;
+        return localYargs.option('json', {
+            describe: 'Outputs version information in JSON format.',
+            type: 'boolean',
+        });
     }
     /**
      * The main execution logic for the `ng version` command.
      */
-    async run() {
+    async run(options) {
         const { logger } = this.context;
         const versionInfo = (0, version_info_1.gatherVersionInfo)(this.context);
-        const { ngCliVersion, nodeVersion, unsupportedNodeVersion, packageManagerName, packageManagerVersion, os, arch, versions, } = versionInfo;
-        const header = `
-      Angular CLI: ${ngCliVersion}
-      Node: ${nodeVersion}${unsupportedNodeVersion ? ' (Unsupported)' : ''}
-      Package Manager: ${packageManagerName} ${packageManagerVersion ?? '<error>'}
-      OS: ${os} ${arch}
-    `.replace(/^ {6}/gm, '');
-        const angularPackages = this.formatAngularPackages(versionInfo);
-        const packageTable = this.formatPackageTable(versions);
-        logger.info([ASCII_ART, header, angularPackages, packageTable].join('\n\n'));
+        if (options.json) {
+            // eslint-disable-next-line no-console
+            console.log(JSON.stringify(versionInfo, null, 2));
+            return;
+        }
+        const { cli: { version: ngCliVersion }, framework, system: { node: { version: nodeVersion, unsupported: unsupportedNodeVersion }, os: { platform: os, architecture: arch }, packageManager: { name: packageManagerName, version: packageManagerVersion }, }, packages, } = versionInfo;
+        const headerInfo = [{ label: 'Angular CLI', value: ngCliVersion }];
+        if (framework.version) {
+            headerInfo.push({ label: 'Angular', value: framework.version });
+        }
+        headerInfo.push({
+            label: 'Node.js',
+            value: `${nodeVersion}${unsupportedNodeVersion ? color_1.colors.yellow(' (Unsupported)') : ''}`,
+        }, {
+            label: 'Package Manager',
+            value: `${packageManagerName} ${packageManagerVersion ?? '<error>'}`,
+        }, { label: 'Operating System', value: `${os} ${arch}` });
+        const maxHeaderLabelLength = Math.max(...headerInfo.map((l) => l.label.length));
+        const header = headerInfo
+            .map(({ label, value }) => color_1.colors.bold(label.padEnd(maxHeaderLabelLength + 2)) + `: ${color_1.colors.cyan(value)}`)
+            .join('\n');
+        const packageTable = this.formatPackageTable(packages);
+        logger.info([ASCII_ART, header, packageTable].join('\n\n'));
         if (unsupportedNodeVersion) {
             logger.warn(`Warning: The current version of Node (${nodeVersion}) is not supported by Angular.`);
         }
     }
-    /**
-     * Formats the Angular packages section of the version output.
-     * @param versionInfo An object containing the version information.
-     * @returns A string containing the formatted Angular packages information.
-     */
-    formatAngularPackages(versionInfo) {
-        const { angularCoreVersion, angularSameAsCore } = versionInfo;
-        if (!angularCoreVersion) {
-            return 'Angular: <error>';
-        }
-        const wrappedPackages = angularSameAsCore
-            .reduce((acc, name) => {
-            if (acc.length === 0) {
-                return [name];
-            }
-            const line = acc[acc.length - 1] + ', ' + name;
-            if (line.length > 60) {
-                acc.push(name);
-            }
-            else {
-                acc[acc.length - 1] = line;
-            }
-            return acc;
-        }, [])
-            .join('\n... ');
-        return `Angular: ${angularCoreVersion}\n... ${wrappedPackages}`;
-    }
     /**
      * Formats the package table section of the version output.
      * @param versions A map of package names to their versions.
@@ -98,19 +87,30 @@ class VersionCommandModule extends command_module_1.CommandModule {
         if (versionKeys.length === 0) {
             return '';
         }
-        const header = 'Package';
-        const maxNameLength = Math.max(...versionKeys.map((key) => key.length));
-        const namePad = ' '.repeat(Math.max(0, maxNameLength - header.length) + 3);
-        const tableHeader = `${header}${namePad}Version`;
-        const separator = '-'.repeat(tableHeader.length);
+        const headers = {
+            name: 'Package',
+            installed: 'Installed Version',
+            requested: 'Requested Version',
+        };
+        const maxNameLength = Math.max(headers.name.length, ...versionKeys.map((key) => key.length));
+        const maxInstalledLength = Math.max(headers.installed.length, ...versionKeys.map((key) => versions[key].installed.length));
+        const maxRequestedLength = Math.max(headers.requested.length, ...versionKeys.map((key) => versions[key].requested.length));
         const tableRows = versionKeys
             .map((module) => {
-            const padding = ' '.repeat(maxNameLength - module.length + 3);
-            return `${module}${padding}${versions[module]}`;
+            const { requested, installed } = versions[module];
+            const name = module.padEnd(maxNameLength);
+            const coloredInstalled = installed === '<error>' ? color_1.colors.red(installed) : color_1.colors.cyan(installed);
+            const installedPadding = ' '.repeat(maxInstalledLength - installed.length);
+            return `│ ${name} │ ${coloredInstalled}${installedPadding} │ ${requested.padEnd(maxRequestedLength)} │`;
         })
-            .sort()
-            .join('\n');
-        return `${tableHeader}\n${separator}\n${tableRows}`;
+            .sort();
+        const top = `┌─${'─'.repeat(maxNameLength)}─┬─${'─'.repeat(maxInstalledLength)}─┬─${'─'.repeat(maxRequestedLength)}─┐`;
+        const header = `│ ${headers.name.padEnd(maxNameLength)} │ ` +
+            `${headers.installed.padEnd(maxInstalledLength)} │ ` +
+            `${headers.requested.padEnd(maxRequestedLength)} │`;
+        const separator = `├─${'─'.repeat(maxNameLength)}─┼─${'─'.repeat(maxInstalledLength)}─┼─${'─'.repeat(maxRequestedLength)}─┤`;
+        const bottom = `└─${'─'.repeat(maxNameLength)}─┴─${'─'.repeat(maxInstalledLength)}─┴─${'─'.repeat(maxRequestedLength)}─┘`;
+        return [top, header, separator, ...tableRows, bottom].join('\n');
     }
 }
 exports.default = VersionCommandModule;

package/src/commands/version/version-info.d.ts

@@ -5,20 +5,38 @@
  * 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
  */
+/**
+ * An object containing version information for a single package.
+ */
+export interface PackageVersionInfo {
+    requested: string;
+    installed: string;
+}
 /**
  * An object containing all the version information that will be displayed by the command.
  */
 export interface VersionInfo {
-    ngCliVersion: string;
-    angularCoreVersion: string;
-    angularSameAsCore: string[];
-    versions: Record<string, string>;
-    unsupportedNodeVersion: boolean;
-    nodeVersion: string;
-    packageManagerName: string;
-    packageManagerVersion: string | undefined;
-    os: string;
-    arch: string;
+    cli: {
+        version: string;
+    };
+    framework: {
+        version: string | undefined;
+    };
+    system: {
+        node: {
+            version: string;
+            unsupported: boolean;
+        };
+        os: {
+            platform: string;
+            architecture: string;
+        };
+        packageManager: {
+            name: string;
+            version: string | undefined;
+        };
+    };
+    packages: Record<string, PackageVersionInfo>;
 }
 /**
  * Gathers all the version information from the environment and workspace.

package/src/commands/version/version-info.js

@@ -9,7 +9,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.gatherVersionInfo = gatherVersionInfo;
 const node_module_1 = require("node:module");
-const node_path_1 = require("node:path");
+const version_1 = require("../../utilities/version");
 /**
  * Major versions of Node.js that are officially supported by Angular.
  * @see https://angular.dev/reference/versions#supported-node-js-versions
@@ -35,10 +35,8 @@ const PACKAGE_PATTERNS = [
  * @returns An object containing all the version information.
  */
 function gatherVersionInfo(context) {
-    const localRequire = (0, node_module_1.createRequire)((0, node_path_1.resolve)(__filename, '../../../'));
     // Trailing slash is used to allow the path to be treated as a directory
     const workspaceRequire = (0, node_module_1.createRequire)(context.root + '/');
-    const cliPackage = localRequire('./package.json');
     let workspacePackage;
     try {
         workspacePackage = workspaceRequire('./package.json');
@@ -46,46 +44,43 @@ function gatherVersionInfo(context) {
     catch { }
     const [nodeMajor] = process.versions.node.split('.').map((part) => Number(part));
     const unsupportedNodeVersion = !SUPPORTED_NODE_MAJORS.includes(nodeMajor);
-    const packageNames = new Set(Object.keys({
-        ...cliPackage.dependencies,
-        ...cliPackage.devDependencies,
+    const allDependencies = {
         ...workspacePackage?.dependencies,
         ...workspacePackage?.devDependencies,
-    }));
-    const versions = {};
+    };
+    const packageNames = new Set(Object.keys(allDependencies));
+    const packages = {};
     for (const name of packageNames) {
         if (PACKAGE_PATTERNS.some((p) => p.test(name))) {
-            versions[name] = getVersion(name, workspaceRequire, localRequire);
-        }
-    }
-    const ngCliVersion = cliPackage.version;
-    let angularCoreVersion = '';
-    const angularSameAsCore = [];
-    if (workspacePackage) {
-        // Filter all angular versions that are the same as core.
-        angularCoreVersion = versions['@angular/core'];
-        if (angularCoreVersion) {
-            for (const [name, version] of Object.entries(versions)) {
-                if (version === angularCoreVersion && name.startsWith('@angular/')) {
-                    angularSameAsCore.push(name.replace(/^@angular\//, ''));
-                    delete versions[name];
-                }
-            }
-            // Make sure we list them in alphabetical order.
-            angularSameAsCore.sort();
+            packages[name] = {
+                requested: allDependencies[name] ?? 'error',
+                installed: getVersion(name, workspaceRequire),
+            };
         }
     }
+    const angularCoreVersion = packages['@angular/core'];
     return {
-        ngCliVersion,
-        angularCoreVersion,
-        angularSameAsCore,
-        versions,
-        unsupportedNodeVersion,
-        nodeVersion: process.versions.node,
-        packageManagerName: context.packageManager.name,
-        packageManagerVersion: context.packageManager.version,
-        os: process.platform,
-        arch: process.arch,
+        cli: {
+            version: version_1.VERSION.full,
+        },
+        framework: {
+            version: angularCoreVersion?.installed,
+        },
+        system: {
+            node: {
+                version: process.versions.node,
+                unsupported: unsupportedNodeVersion,
+            },
+            os: {
+                platform: process.platform,
+                architecture: process.arch,
+            },
+            packageManager: {
+                name: context.packageManager.name,
+                version: context.packageManager.version,
+            },
+        },
+        packages,
     };
 }
 /**
@@ -95,28 +90,16 @@ function gatherVersionInfo(context) {
  * @param localRequire A `require` function for the CLI.
  * @returns The version of the package, or `<error>` if it could not be found.
  */
-function getVersion(moduleName, workspaceRequire, localRequire) {
+function getVersion(moduleName, workspaceRequire) {
     let packageInfo;
-    let cliOnly = false;
     // Try to find the package in the workspace
     try {
         packageInfo = workspaceRequire(`${moduleName}/package.json`);
     }
     catch { }
-    // If not found, try to find within the CLI
-    if (!packageInfo) {
-        try {
-            packageInfo = localRequire(`${moduleName}/package.json`);
-            cliOnly = true;
-        }
-        catch { }
-    }
     // If found, attempt to get the version
     if (packageInfo) {
-        try {
-            return packageInfo.version + (cliOnly ? ' (cli-only)' : '');
-        }
-        catch { }
+        return packageInfo.version;
     }
     return '<error>';
 }

package/src/package-managers/discovery.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @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 { Host } from './host';
+import { Logger } from './logger';
+import { PackageManagerName } from './package-manager-descriptor';
+/**
+ * Discovers the package manager used in a project by searching for lockfiles.
+ *
+ * This function searches for lockfiles in the given directory and its ancestors.
+ * If multiple lockfiles are found, it uses the precedence array to determine
+ * which package manager to use. The search is bounded by the git repository root.
+ *
+ * @param host A `Host` instance for interacting with the file system.
+ * @param startDir The directory to start the search from.
+ * @param logger An optional logger instance.
+ * @returns A promise that resolves to the name of the discovered package manager, or null if none is found.
+ */
+export declare function discover(host: Host, startDir: string, logger?: Logger): Promise<PackageManagerName | null>;

package/src/package-managers/discovery.js

@@ -0,0 +1,109 @@
+"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.discover = discover;
+/**
+ * @fileoverview This file contains the logic for discovering the package manager
+ * used in a project by searching for lockfiles. It is designed to be efficient
+ * and to correctly handle monorepo structures.
+ */
+const node_path_1 = require("node:path");
+const package_manager_descriptor_1 = require("./package-manager-descriptor");
+/**
+ * A map from lockfile names to their corresponding package manager.
+ * This is a performance optimization to avoid iterating over all possible
+ * lockfiles in every directory.
+ */
+const LOCKFILE_TO_PACKAGE_MANAGER = new Map();
+for (const [name, descriptor] of Object.entries(package_manager_descriptor_1.SUPPORTED_PACKAGE_MANAGERS)) {
+    for (const lockfile of descriptor.lockfiles) {
+        LOCKFILE_TO_PACKAGE_MANAGER.set(lockfile, name);
+    }
+}
+/**
+ * Searches a directory for lockfiles and returns a set of package managers that correspond to them.
+ * @param host A `Host` instance for interacting with the file system.
+ * @param directory The directory to search.
+ * @param logger An optional logger instance.
+ * @returns A promise that resolves to a set of package manager names.
+ */
+async function findLockfiles(host, directory, logger) {
+    logger?.debug(`Searching for lockfiles in '${directory}'...`);
+    try {
+        const files = await host.readdir(directory);
+        const foundPackageManagers = new Set();
+        for (const file of files) {
+            const packageManager = LOCKFILE_TO_PACKAGE_MANAGER.get(file);
+            if (packageManager) {
+                logger?.debug(`  Found '${file}'.`);
+                foundPackageManagers.add(packageManager);
+            }
+        }
+        return foundPackageManagers;
+    }
+    catch (e) {
+        logger?.debug(`  Failed to read directory: ${e}`);
+        // Ignore directories that don't exist or can't be read.
+        return new Set();
+    }
+}
+/**
+ * Checks if a given path is a directory.
+ * @param host A `Host` instance for interacting with the file system.
+ * @param path The path to check.
+ * @returns A promise that resolves to true if the path is a directory, false otherwise.
+ */
+async function isDirectory(host, path) {
+    try {
+        return (await host.stat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Discovers the package manager used in a project by searching for lockfiles.
+ *
+ * This function searches for lockfiles in the given directory and its ancestors.
+ * If multiple lockfiles are found, it uses the precedence array to determine
+ * which package manager to use. The search is bounded by the git repository root.
+ *
+ * @param host A `Host` instance for interacting with the file system.
+ * @param startDir The directory to start the search from.
+ * @param logger An optional logger instance.
+ * @returns A promise that resolves to the name of the discovered package manager, or null if none is found.
+ */
+async function discover(host, startDir, logger) {
+    logger?.debug(`Starting package manager discovery in '${startDir}'...`);
+    let currentDir = startDir;
+    while (true) {
+        const found = await findLockfiles(host, currentDir, logger);
+        if (found.size > 0) {
+            logger?.debug(`Found lockfile(s): [${[...found].join(', ')}]. Applying precedence...`);
+            for (const packageManager of package_manager_descriptor_1.PACKAGE_MANAGER_PRECEDENCE) {
+                if (found.has(packageManager)) {
+                    logger?.debug(`Selected '${packageManager}' based on precedence.`);
+                    return packageManager;
+                }
+            }
+        }
+        // Stop searching if we reach the git repository root.
+        if (await isDirectory(host, (0, node_path_1.join)(currentDir, '.git'))) {
+            logger?.debug(`Reached repository root at '${currentDir}'. Stopping search.`);
+            return null;
+        }
+        const parentDir = (0, node_path_1.dirname)(currentDir);
+        if (parentDir === currentDir) {
+            // We have reached the filesystem root.
+            logger?.debug('Reached filesystem root. No lockfile found.');
+            return null;
+        }
+        currentDir = parentDir;
+    }
+}