refactor(@angular/cli): add type safety fallbacks and deduplicate search roots for MCP projects tool

Added runtime type checks for `projectType` and `prefix` to prevent unhandled schema exceptions.
Implemented `deduplicateSearchRoots` to filter out child directories from overlapping search trees, optimizing filesystem scans.
Aggregated validation errors and reported them in the tool output for better visibility.

Author: clydin

packages/angular/cli/src/commands/mcp/tools/projects.ts

@@ -112,6 +112,18 @@ const listProjectsOutputSchema = {
     )
     .default([])
     .describe('A list of workspaces for which the framework version could not be determined.'),
+  validationErrors: z
+    .array(
+      z.object({
+        filePath: z.string().describe('The path to the workspace `angular.json` file.'),
+        projectName: z.string().describe('The name of the project with invalid schema.'),
+        message: z.string().describe('The reason why validation failed or fell back.'),
+      }),
+    )
+    .default([])
+    .describe(
+      'A list of projects within workspaces that had invalid or malformed schema elements.',
+    ),
 };
 
 export const LIST_PROJECTS_TOOL = declareTool({
@@ -331,6 +343,7 @@ async function findAngularCoreVersion(
 type WorkspaceData = z.infer<typeof listProjectsOutputSchema.workspaces>[number];
 type ParsingError = z.infer<typeof listProjectsOutputSchema.parsingErrors>[number];
 type VersioningError = z.infer<typeof listProjectsOutputSchema.versioningErrors>[number];
+type ValidationError = z.infer<typeof listProjectsOutputSchema.validationErrors>[number];
 
 /**
  * Determines the unit test framework for a project based on its 'test' target configuration.
@@ -455,36 +468,71 @@ async function getProjectStyleLanguage(
 async function loadAndParseWorkspace(
   configFile: string,
   seenPaths: Set<string>,
-): Promise<{ workspace: WorkspaceData | null; error: ParsingError | null }> {
+): Promise<{
+  workspace: WorkspaceData | null;
+  error: ParsingError | null;
+  validationErrors: ValidationError[];
+}> {
   try {
     const resolvedPath = resolve(configFile);
     if (seenPaths.has(resolvedPath)) {
-      return { workspace: null, error: null }; // Already processed, skip.
+      return { workspace: null, error: null, validationErrors: [] }; // Already processed, skip.
     }
     seenPaths.add(resolvedPath);
 
     const ws = await AngularWorkspace.load(configFile);
-    const projects = [];
+    const projects: WorkspaceData['projects'] = [];
+    const validationErrors: ValidationError[] = [];
     const workspaceRoot = dirname(configFile);
     for (const [name, project] of ws.projects.entries()) {
       const sourceRoot = posix.join(project.root, project.sourceRoot ?? 'src');
       const fullSourceRoot = join(workspaceRoot, sourceRoot);
       const unitTestFramework = getUnitTestFramework(project.targets.get('test'));
       const styleLanguage = await getProjectStyleLanguage(project, ws, fullSourceRoot);
 
+      const rawType = project.extensions['projectType'];
+      const type = rawType === 'application' || rawType === 'library' ? rawType : undefined;
+      if (rawType && !type) {
+        validationErrors.push({
+          filePath: configFile,
+          projectName: name,
+          message: `Invalid \`projectType\` '${rawType}'. Expected 'application' or 'library'. Falling back to undefined.`,
+        });
+      }
+
+      const rawPrefix = project.extensions['prefix'];
+      const selectorPrefix = typeof rawPrefix === 'string' ? rawPrefix : undefined;
+      if (rawPrefix !== undefined && selectorPrefix === undefined) {
+        validationErrors.push({
+          filePath: configFile,
+          projectName: name,
+          message: `Invalid \`prefix\`. Expected a string. Falling back to undefined.`,
+        });
+      }
+
+      const buildBuilder = project.targets.get('build')?.builder;
+      const builder = typeof buildBuilder === 'string' ? buildBuilder : undefined;
+      if (buildBuilder !== undefined && builder === undefined) {
+        validationErrors.push({
+          filePath: configFile,
+          projectName: name,
+          message: `Invalid or missing build builder. Falling back to undefined.`,
+        });
+      }
+
       projects.push({
         name,
-        type: project.extensions['projectType'] as 'application' | 'library' | undefined,
-        builder: project.targets.get('build')?.builder,
+        type,
+        builder,
         root: project.root,
         sourceRoot,
-        selectorPrefix: project.extensions['prefix'] as string,
+        selectorPrefix,
         unitTestFramework,
         styleLanguage,
       });
     }
 
-    return { workspace: { path: configFile, projects }, error: null };
+    return { workspace: { path: configFile, projects }, error: null, validationErrors };
   } catch (error) {
     let message;
     if (error instanceof Error) {
@@ -493,7 +541,7 @@ async function loadAndParseWorkspace(
       message = 'An unknown error occurred while parsing the file.';
     }
 
-    return { workspace: null, error: { filePath: configFile, message } };
+    return { workspace: null, error: { filePath: configFile, message }, validationErrors: [] };
   }
 }
 
@@ -514,14 +562,15 @@ async function processConfigFile(
   workspace?: WorkspaceData;
   parsingError?: ParsingError;
   versioningError?: VersioningError;
+  validationErrors?: ValidationError[];
 }> {
-  const { workspace, error } = await loadAndParseWorkspace(configFile, seenPaths);
+  const { workspace, error, validationErrors } = await loadAndParseWorkspace(configFile, seenPaths);
   if (error) {
     return { parsingError: error };
   }
 
   if (!workspace) {
-    return {}; // Skipped as it was already seen.
+    return { validationErrors }; // If already seen, we still group validation errors if any (unlikely to be any if seen).
   }
 
   try {
@@ -532,10 +581,11 @@ async function processConfigFile(
       searchRoot,
     );
 
-    return { workspace };
+    return { workspace, validationErrors };
   } catch (e) {
     return {
       workspace,
+      validationErrors,
       versioningError: {
         filePath: workspace.path,
         message: e instanceof Error ? e.message : 'An unknown error occurred.',
@@ -544,11 +594,37 @@ async function processConfigFile(
   }
 }
 
+/**
+ * Deduplicates overlapping search roots (e.g., if one is a child of another).
+ * Sorting by length ensures parent directories are processed before children.
+ * @param roots A list of normalized absolute paths used as search roots.
+ * @returns A deduplicated list of search roots.
+ */
+function deduplicateSearchRoots(roots: string[]): string[] {
+  const sortedRoots = [...roots].sort((a, b) => a.length - b.length);
+  const deduplicated: string[] = [];
+
+  for (const root of sortedRoots) {
+    const isSubdirectory = deduplicated.some((existing) => {
+      const rel = relative(existing, root);
+
+      return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel));
+    });
+
+    if (!isSubdirectory) {
+      deduplicated.push(root);
+    }
+  }
+
+  return deduplicated;
+}
+
 async function createListProjectsHandler({ server }: McpToolContext) {
   return async () => {
     const workspaces: WorkspaceData[] = [];
     const parsingErrors: ParsingError[] = [];
     const versioningErrors: z.infer<typeof listProjectsOutputSchema.versioningErrors> = [];
+    const validationErrors: ValidationError[] = [];
     const seenPaths = new Set<string>();
     const versionCache = new Map<string, string | undefined>();
 
@@ -562,6 +638,8 @@ async function createListProjectsHandler({ server }: McpToolContext) {
       searchRoots = [process.cwd()];
     }
 
+    searchRoots = deduplicateSearchRoots(searchRoots);
+
     // Pre-resolve allowed roots to handle their own symlinks or normalizations.
     // We ignore failures here; if a root is broken, we simply won't match against it.
     const realAllowedRoots = searchRoots
@@ -576,12 +654,12 @@ async function createListProjectsHandler({ server }: McpToolContext) {
 
     for (const root of searchRoots) {
       for await (const configFile of findAngularJsonFiles(root, realAllowedRoots)) {
-        const { workspace, parsingError, versioningError } = await processConfigFile(
-          configFile,
-          root,
-          seenPaths,
-          versionCache,
-        );
+        const {
+          workspace,
+          parsingError,
+          versioningError,
+          validationErrors: currentValidationErrors,
+        } = await processConfigFile(configFile, root, seenPaths, versionCache);
 
         if (workspace) {
           workspaces.push(workspace);
@@ -592,6 +670,9 @@ async function createListProjectsHandler({ server }: McpToolContext) {
         if (versioningError) {
           versioningErrors.push(versioningError);
         }
+        if (currentValidationErrors) {
+          validationErrors.push(...currentValidationErrors);
+        }
       }
     }
 
@@ -619,10 +700,16 @@ async function createListProjectsHandler({ server }: McpToolContext) {
       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');
     }
+    if (validationErrors.length > 0) {
+      text += `\n\nWarning: The following ${validationErrors.length} project validation issue(s) were found (properties fell back to defaults):\n`;
+      text += validationErrors
+        .map((e) => `- ${e.filePath} [Project: ${e.projectName}]: ${e.message}`)
+        .join('\n');
+    }
 
     return {
       content: [{ type: 'text' as const, text }],
-      structuredContent: { workspaces, parsingErrors, versioningErrors },
+      structuredContent: { workspaces, parsingErrors, versioningErrors, validationErrors },
     };
   };
 }