feat(@angular/cli): Add a "build" MCP tool

Author: amishne

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

@@ -13,6 +13,7 @@ import { VERSION } from '../../utilities/version';
 import { registerInstructionsResource } from './resources/instructions';
 import { AI_TUTOR_TOOL } from './tools/ai-tutor';
 import { BEST_PRACTICES_TOOL } from './tools/best-practices';
+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';
@@ -27,6 +28,7 @@ import { AnyMcpToolDeclaration, registerTools } from './tools/tool-registry';
 const STABLE_TOOLS = [
   AI_TUTOR_TOOL,
   BEST_PRACTICES_TOOL,
+  BUILD_TOOL,
   DOC_SEARCH_TOOL,
   FIND_EXAMPLE_TOOL,
   LIST_PROJECTS_TOOL,

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

@@ -0,0 +1,118 @@
+/**
+ * @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 { z } from 'zod';
+import { execSync } from 'child_process';
+import { declareTool } from './tool-registry';
+
+const CONFIGURATIONS = {
+  development: {
+    args: '-c development',
+  },
+  production: {
+    args: '',
+  },
+};
+
+const BUILD_STATUSES = ['success', 'failure'] as const;
+type BuildStatus = (typeof BUILD_STATUSES)[number];
+
+const buildToolInputSchema = z.object({
+  project: z
+    .string()
+    .optional()
+    .describe(
+      'Which project to build in a monorepo context. If not provided, builds the top-level project.',
+    ),
+  configuration: z
+    .enum(Object.keys(CONFIGURATIONS) as [string, ...string[]])
+    .optional()
+    .describe('Which build configuration to use. Defaults to "development".'),
+});
+
+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`.'),
+  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) {
+  const configurationName = input.configuration ?? 'development';
+  const configuration = CONFIGURATIONS[configurationName as keyof typeof CONFIGURATIONS];
+  const command = ['ng', 'build'];
+  if (input.project) {
+    command.push(input.project);
+  }
+  if (configuration.args) {
+    command.push(configuration.args);
+  }
+
+  let status: BuildStatus = 'success';
+  let logs = '';
+  let outputPath: string | undefined;
+
+  try {
+    logs = execSync(command.join(' ')).toString();
+    const match = logs.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()}`;
+      }
+    }
+  }
+
+  const structuredContent: BuildToolOutput = {
+    status,
+    logs,
+    path: outputPath,
+  };
+
+  return {
+    content: [{ type: 'text' as const, text: JSON.stringify(structuredContent) }],
+    structuredContent,
+  };
+}
+
+export const BUILD_TOOL = declareTool({
+  name: 'build',
+  title: 'Build Tool',
+  description: `
+<Purpose>
+Perform a one-off, non-watched build with "ng build". Use this tool whenever
+the user wants to build an Angular project; this is similar to "ng build", but
+the tool is smarter about using the right configuration and collecting the
+output logs.
+</Purpose>
+<Use Cases>
+* Building the Angular project and getting build logs back.
+</Use Cases>
+<Operational Notes>
+* This tool runs "ng build" so it expects to run within an Angular workspace.
+* You can provide a project instead of building the root one. The
+  "list_projects" MCP tool could be used to obtain the list of projects.
+</Operational Notes>
+`,
+  isReadOnly: false,
+  isLocalOnly: true,
+  inputSchema: buildToolInputSchema.shape,
+  outputSchema: buildToolOutputSchema.shape,
+  factory: () => (input: BuildToolInput) => runBuild(input),
+});

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

@@ -0,0 +1,85 @@
+/**
+ * @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 { 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,
+});
+
+describe('Build Tool', () => {
+  beforeEach(() => {
+    mockedExecSync.calls.reset();
+  });
+
+  it('should handle a successful build and extract the output path', () => {
+    const buildLogs =
+      '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');
+  });
+
+  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 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 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 for production configuration', () => {
+    mockedExecSync.and.returnValue(Buffer.from('Success'));
+    runBuild({ configuration: 'production' });
+    expect(mockedExecSync).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));
+
+    const result = runBuild({});
+
+    expect(result.structuredContent.status).toBe('success');
+    expect(result.structuredContent.logs).toBe(buildLogs);
+    expect(result.structuredContent.path).toBeUndefined();
+  });
+});