refactor(@angular/cli): Make "build" MCP tool work with host

Author: amishne

packages/angular/cli/src/commands/mcp/mcp-server.ts

@@ -17,9 +17,9 @@ import { BUILD_TOOL } from './tools/build';
 import { DOC_SEARCH_TOOL } from './tools/doc-search';
 import { FIND_EXAMPLE_TOOL } from './tools/examples';
 import { MODERNIZE_TOOL } from './tools/modernize';
-import { SERVE_TOOL } from './tools/serve';
 import { ZONELESS_MIGRATION_TOOL } from './tools/onpush-zoneless-migration/zoneless-migration';
 import { LIST_PROJECTS_TOOL } from './tools/projects';
+import { SERVE_TOOL } from './tools/serve';
 import { AnyMcpToolDeclaration, registerTools } from './tools/tool-registry';
 
 /**

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

@@ -7,8 +7,8 @@
  */
 
 import { z } from 'zod';
-import { execSync } from 'child_process';
-import { declareTool } from './tool-registry';
+import { CommandError, Host, LocalWorkspaceHost } from '../host';
+import { McpToolContext, McpToolDeclaration, declareTool } from './tool-registry';
 
 const CONFIGURATIONS = {
   development: {
@@ -39,59 +39,61 @@ export type BuildToolInput = z.infer<typeof buildToolInputSchema>;
 
 const buildToolOutputSchema = z.object({
   status: z.enum(BUILD_STATUSES).describe('Build status.'),
-  logs: z.string().describe('Output logs from `ng build`.'),
+  stdout: z.string().optional().describe('The standard output from `ng build`.'),
+  stderr: z.string().optional().describe('The standard error from `ng build`.'),
   path: z.string().optional().describe('The output path the build project was written into.'),
 });
 
 export type BuildToolOutput = z.infer<typeof buildToolOutputSchema>;
 
-export function runBuild(input: BuildToolInput) {
+export async function runBuild(input: BuildToolInput, host: Host) {
   const configurationName = input.configuration ?? 'development';
   const configuration = CONFIGURATIONS[configurationName as keyof typeof CONFIGURATIONS];
-  const command = ['ng', 'build'];
+  const args = ['build'];
   if (input.project) {
-    command.push(input.project);
+    args.push(input.project);
   }
   if (configuration.args) {
-    command.push(configuration.args);
+    args.push(configuration.args);
   }
 
   let status: BuildStatus = 'success';
-  let logs = '';
+  let stdout = '';
+  let stderr = '';
   let outputPath: string | undefined;
 
   try {
-    logs = execSync(command.join(' ')).toString();
-    const match = logs.match(/Output location: (.*)/);
+    const result = await host.runCommand('ng', args);
+    stdout = result.stdout;
+    stderr = result.stderr;
+    const match = stdout.match(/Output location: (.*)/);
     if (match) {
       outputPath = match[1].trim();
     }
   } catch (e) {
     status = 'failure';
-    if (e instanceof Error) {
-      logs = e.message;
-      if ('stdout' in e) {
-        logs += `\nSTDOUT:\n${(e as { stdout: Buffer }).stdout.toString()}`;
-      }
-      if ('stderr' in e) {
-        logs += `\nSTDERR:\n${(e as { stderr: Buffer }).stderr.toString()}`;
-      }
+    if (e instanceof CommandError) {
+      stdout = e.stdout;
+      stderr = e.stderr;
+    } else if (e instanceof Error) {
+      stderr = e.message;
     }
   }
 
   const structuredContent: BuildToolOutput = {
     status,
-    logs,
+    stdout,
+    stderr,
     path: outputPath,
   };
 
-  return {
-    content: [{ type: 'text' as const, text: JSON.stringify(structuredContent) }],
-    structuredContent,
-  };
+  return createStructureContentOutput(structuredContent);
 }
 
-export const BUILD_TOOL = declareTool({
+export const BUILD_TOOL: McpToolDeclaration<
+  typeof buildToolInputSchema.shape,
+  typeof buildToolOutputSchema.shape
+> = declareTool({
   name: 'build',
   title: 'Build Tool',
   description: `
@@ -114,5 +116,5 @@ output logs.
   isLocalOnly: true,
   inputSchema: buildToolInputSchema.shape,
   outputSchema: buildToolOutputSchema.shape,
-  factory: () => (input: BuildToolInput) => runBuild(input),
+  factory: () => (input) => runBuild(input, LocalWorkspaceHost),
 });

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

@@ -6,80 +6,89 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 
-import { execSync, spawnSync } from 'child_process';
-import { BUILD_TOOL, BuildToolInput, runBuild } from './build';
-import { McpToolContext } from './tool-registry';
-
-// Mock the execSync function
-const mockedExecSync = jasmine.createSpy('execSync');
-
-// Replace the actual execSync with our mock
-Object.defineProperty(require('child_process'), 'execSync', {
-  value: mockedExecSync,
-});
+import { CommandError, Host } from '../host';
+import { BuildToolInput, runBuild } from './build';
 
 describe('Build Tool', () => {
+  let mockHost: Host;
+
   beforeEach(() => {
-    mockedExecSync.calls.reset();
+    mockHost = {
+      runCommand: jasmine.createSpy('runCommand').and.resolveTo({ stdout: '', stderr: '' }),
+      stat: jasmine.createSpy('stat'),
+      existsSync: jasmine.createSpy('existsSync'),
+    };
   });
 
-  it('should handle a successful build and extract the output path', () => {
-    const buildLogs =
+  it('should handle a successful build and extract the output path', async () => {
+    const buildStdout =
       'Build successful!\nSome other log lines...\nOutput location: dist/my-cool-app';
-    mockedExecSync.and.returnValue(Buffer.from(buildLogs));
-
-    const result = runBuild({ project: 'my-cool-app' });
-
-    expect(mockedExecSync).toHaveBeenCalledWith('ng build my-cool-app -c development');
-    expect(result.structuredContent.status).toBe('success');
-    expect(result.structuredContent.logs).toBe(buildLogs);
-    expect(result.structuredContent.path).toBe('dist/my-cool-app');
+    (mockHost.runCommand as jasmine.Spy).and.resolveTo({
+      stdout: buildStdout,
+      stderr: 'some warning',
+    });
+
+    const { structuredContent } = await runBuild({ project: 'my-cool-app' }, mockHost);
+
+    expect(mockHost.runCommand).toHaveBeenCalledWith('ng', [
+      'build',
+      'my-cool-app',
+      '-c development',
+    ]);
+    expect(structuredContent.status).toBe('success');
+    expect(structuredContent.stdout).toBe(buildStdout);
+    expect(structuredContent.stderr).toBe('some warning');
+    expect(structuredContent.path).toBe('dist/my-cool-app');
   });
 
-  it('should handle a failed build and capture logs', () => {
-    const error = new Error('Build failed');
-    // Errors thrown from execSync contain the entire result like it would be returned from spawnSync.
-    const execSyncError = error as unknown as ReturnType<typeof spawnSync>;
-    execSyncError.stdout = Buffer.from('Some output before the crash.');
-    execSyncError.stderr = Buffer.from('Error: Something went wrong!');
-    mockedExecSync.and.throwError(error);
-
-    const result = runBuild({ project: 'my-failed-app', configuration: 'production' });
-
-    expect(mockedExecSync).toHaveBeenCalledWith('ng build my-failed-app');
-    expect(result.structuredContent.status).toBe('failure');
-    expect(result.structuredContent.logs).toContain('Build failed');
-    expect(result.structuredContent.logs).toContain('STDOUT:\nSome output before the crash.');
-    expect(result.structuredContent.logs).toContain('STDERR:\nError: Something went wrong!');
-    expect(result.structuredContent.path).toBeUndefined();
+  it('should handle a failed build and capture logs', async () => {
+    const error = new CommandError(
+      'Build failed',
+      'Some output before the crash.',
+      'Error: Something went wrong!',
+      1,
+    );
+    (mockHost.runCommand as jasmine.Spy).and.rejectWith(error);
+
+    const { structuredContent } = await runBuild(
+      { project: 'my-failed-app', configuration: 'production' },
+      mockHost,
+    );
+
+    expect(mockHost.runCommand).toHaveBeenCalledWith('ng', ['build', 'my-failed-app']);
+    expect(structuredContent.status).toBe('failure');
+    expect(structuredContent.stdout).toBe('Some output before the crash.');
+    expect(structuredContent.stderr).toBe('Error: Something went wrong!');
+    expect(structuredContent.path).toBeUndefined();
   });
 
-  it('should construct the command correctly with default configuration', () => {
-    mockedExecSync.and.returnValue(Buffer.from('Success'));
-    runBuild({});
-    expect(mockedExecSync).toHaveBeenCalledWith('ng build -c development');
+  it('should construct the command correctly with default configuration', async () => {
+    await runBuild({}, mockHost);
+    expect(mockHost.runCommand).toHaveBeenCalledWith('ng', ['build', '-c development']);
   });
 
-  it('should construct the command correctly with a specified project', () => {
-    mockedExecSync.and.returnValue(Buffer.from('Success'));
-    runBuild({ project: 'another-app' });
-    expect(mockedExecSync).toHaveBeenCalledWith('ng build another-app -c development');
+  it('should construct the command correctly with a specified project', async () => {
+    await runBuild({ project: 'another-app' }, mockHost);
+    expect(mockHost.runCommand).toHaveBeenCalledWith('ng', [
+      'build',
+      'another-app',
+      '-c development',
+    ]);
   });
 
-  it('should construct the command correctly for production configuration', () => {
-    mockedExecSync.and.returnValue(Buffer.from('Success'));
-    runBuild({ configuration: 'production' });
-    expect(mockedExecSync).toHaveBeenCalledWith('ng build');
+  it('should construct the command correctly for production configuration', async () => {
+    await runBuild({ configuration: 'production' }, mockHost);
+    expect(mockHost.runCommand).toHaveBeenCalledWith('ng', ['build']);
   });
 
-  it('should handle builds where the output path is not found in logs', () => {
-    const buildLogs = 'Build finished, but we could not find the output path string.';
-    mockedExecSync.and.returnValue(Buffer.from(buildLogs));
+  it('should handle builds where the output path is not found in logs', async () => {
+    const buildStdout = 'Build finished, but we could not find the output path string.';
+    (mockHost.runCommand as jasmine.Spy).and.resolveTo({ stdout: buildStdout, stderr: '' });
 
-    const result = runBuild({});
+    const { structuredContent } = await runBuild({}, mockHost);
 
-    expect(result.structuredContent.status).toBe('success');
-    expect(result.structuredContent.logs).toBe(buildLogs);
-    expect(result.structuredContent.path).toBeUndefined();
+    expect(structuredContent.status).toBe('success');
+    expect(structuredContent.stdout).toBe(buildStdout);
+    expect(structuredContent.path).toBeUndefined();
   });
 });

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

@@ -0,0 +1,26 @@
+/**
+ * @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
+ * Utility functions shared across MCP tools.
+ */
+
+/**
+ * Returns simple structured content output from an MCP tool.
+ *
+ * Returns a structure with both `content` and `structuredContent` for maximum compatibility.
+ * @param structuredContent
+ * @returns
+ */
+function createStructureContentOutput<OutputType>(structuredContent: OutputType) {
+  return {
+    content: [{ type: 'text' as const, text: JSON.stringify(structuredContent, null, 2) }],
+    structuredContent,
+  };
+}