refactor(@angular/cli): Change modernize to use a host interface for OS/FS operations

Author: amishne

packages/angular/cli/src/commands/mcp/host.ts

@@ -0,0 +1,130 @@
+/**
+ * @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
+ */
+
+/**
+ * @fileoverview
+ * This file defines an abstraction layer for operating-system or file-system operations, such as
+ * command execution. This allows for easier testing by enabling the injection of mock or
+ * test-specific implementations.
+ */
+
+import { existsSync as nodeExistsSync } from 'fs';
+import { spawn } from 'node:child_process';
+import { Stats } from 'node:fs';
+import { stat } from 'node:fs/promises';
+
+/**
+ * An error thrown when a command fails to execute.
+ */
+export class CommandError extends Error {
+  constructor(
+    message: string,
+    public readonly stdout: string,
+    public readonly stderr: string,
+    public readonly code: number | null,
+  ) {
+    super(message);
+  }
+}
+
+/**
+ * An abstraction layer for side-effectful operations.
+ */
+export interface Host {
+  /**
+   * Gets the stats of a file or directory.
+   * @param path The path to the file or directory.
+   * @returns A promise that resolves to the stats.
+   */
+  stat(path: string): Promise<Stats>;
+
+  /**
+   * Checks if a path exists on the file system.
+   * @param path The path to check.
+   * @returns A boolean indicating whether the path exists.
+   */
+  existsSync(path: string): boolean;
+
+  /**
+   * Spawns a child process and returns a promise that resolves with the process's
+   * output or rejects with a structured error.
+   * @param command The command to run.
+   * @param args The arguments to pass to the command.
+   * @param options Options for the child process.
+   * @returns A promise that resolves with the standard output and standard error of the command.
+   */
+  runCommand(
+    command: string,
+    args: readonly string[],
+    options?: {
+      timeout?: number;
+      stdio?: 'pipe' | 'ignore';
+      cwd?: string;
+      env?: Record<string, string>;
+    },
+  ): Promise<{ stdout: string; stderr: string }>;
+}
+
+/**
+ * A concrete implementation of the `Host` interface that uses the Node.js APIs.
+ */
+export const LocalWorkspaceHost: Host = {
+  stat,
+  existsSync: nodeExistsSync,
+  runCommand: async (
+    command: string,
+    args: readonly string[],
+    options: {
+      timeout?: number;
+      stdio?: 'pipe' | 'ignore';
+      cwd?: string;
+      env?: Record<string, string>;
+    } = {},
+  ): Promise<{ stdout: string; stderr: string }> => {
+    const signal = options.timeout ? AbortSignal.timeout(options.timeout) : undefined;
+
+    return new Promise((resolve, reject) => {
+      const childProcess = spawn(command, args, {
+        shell: false,
+        stdio: options.stdio ?? 'pipe',
+        signal,
+        cwd: options.cwd,
+        env: {
+          ...process.env,
+          ...options.env,
+        },
+      });
+
+      let stdout = '';
+      childProcess.stdout?.on('data', (data) => (stdout += data.toString()));
+
+      let stderr = '';
+      childProcess.stderr?.on('data', (data) => (stderr += data.toString()));
+
+      childProcess.on('close', (code) => {
+        if (code === 0) {
+          resolve({ stdout, stderr });
+        } else {
+          const message = `Process exited with code ${code}.`;
+          reject(new CommandError(message, stdout, stderr, code));
+        }
+      });
+
+      childProcess.on('error', (err) => {
+        if (err.name === 'AbortError') {
+          const message = `Process timed out.`;
+          reject(new CommandError(message, stdout, stderr, null));
+
+          return;
+        }
+        const message = `Process failed with error: ${err.message}`;
+        reject(new CommandError(message, stdout, stderr, null));
+      });
+    });
+  },
+};

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

@@ -6,11 +6,9 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 
-import { existsSync } from 'fs';
-import { stat } from 'fs/promises';
 import { dirname, join, relative } from 'path';
 import { z } from 'zod';
-import { execAsync } from './process-executor';
+import { CommandError, Host, LocalWorkspaceHost } from '../host';
 import { McpToolDeclaration, declareTool } from './tool-registry';
 
 interface Transformation {
@@ -102,10 +100,10 @@ function createToolOutput(structuredContent: ModernizeOutput) {
   };
 }
 
-function findAngularJsonDir(startDir: string): string | null {
+function findAngularJsonDir(startDir: string, host: Host): string | null {
   let currentDir = startDir;
   while (true) {
-    if (existsSync(join(currentDir, 'angular.json'))) {
+    if (host.existsSync(join(currentDir, 'angular.json'))) {
       return currentDir;
     }
     const parentDir = dirname(currentDir);
@@ -116,7 +114,7 @@ function findAngularJsonDir(startDir: string): string | null {
   }
 }
 
-export async function runModernization(input: ModernizeInput) {
+export async function runModernization(input: ModernizeInput, host: Host) {
   const transformationNames = input.transformations ?? [];
   const directories = input.directories ?? [];
 
@@ -138,9 +136,9 @@ export async function runModernization(input: ModernizeInput) {
   }
 
   const firstDir = directories[0];
-  const executionDir = (await stat(firstDir)).isDirectory() ? firstDir : dirname(firstDir);
+  const executionDir = (await host.stat(firstDir)).isDirectory() ? firstDir : dirname(firstDir);
 
-  const angularProjectRoot = findAngularJsonDir(executionDir);
+  const angularProjectRoot = findAngularJsonDir(executionDir, host);
   if (!angularProjectRoot) {
     return createToolOutput({
       instructions: ['Could not find an angular.json file in the current or parent directories.'],
@@ -164,9 +162,12 @@ export async function runModernization(input: ModernizeInput) {
       // Simple case, run the command.
       for (const dir of directories) {
         const relativePath = relative(angularProjectRoot, dir) || '.';
-        const command = `ng generate @angular/core:${transformation.name} --path ${relativePath}`;
+        const command = 'ng';
+        const args = ['generate', `@angular/core:${transformation.name}`, '--path', relativePath];
         try {
-          const { stdout, stderr } = await execAsync(command, { cwd: angularProjectRoot });
+          const { stdout, stderr } = await host.runCommand(command, args, {
+            cwd: angularProjectRoot,
+          });
           if (stdout) {
             stdoutMessages.push(stdout);
           }
@@ -177,6 +178,14 @@ export async function runModernization(input: ModernizeInput) {
             `Migration ${transformation.name} on directory ${relativePath} completed successfully.`,
           );
         } catch (e) {
+          if (e instanceof CommandError) {
+            if (e.stdout) {
+              stdoutMessages.push(e.stdout);
+            }
+            if (e.stderr) {
+              stderrMessages.push(e.stderr);
+            }
+          }
           stderrMessages.push((e as Error).message);
           instructions.push(
             `Migration ${transformation.name} on directory ${relativePath} failed.`,
@@ -228,5 +237,5 @@ ${TRANSFORMATIONS.map((t) => `  * ${t.name}: ${t.description}`).join('\n')}
   outputSchema: modernizeOutputSchema.shape,
   isLocalOnly: true,
   isReadOnly: false,
-  factory: () => runModernization,
+  factory: () => (input) => runModernization(input, LocalWorkspaceHost),
 });