":node_modules/@modelcontextprotocol/sdk",

"@modelcontextprotocol/sdk": "1.13.1",

| 'mcp'

'mcp': {

factory: () => import('./mcp/cli'),

},

import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';

import { Argv } from 'yargs';

import { CommandModule, CommandModuleImplementation } from '../../command-builder/command-module';

import { isTTY } from '../../utilities/tty';

import { createMcpServer } from './mcp-server';

const INTERACTIVE_MESSAGE = `

export default class McpCommandModule extends CommandModule implements CommandModuleImplementation {

command = 'mcp';

describe = false as const;

longDescriptionPath = undefined;

builder(localYargs: Argv): Argv {

return localYargs;

}

async run(): Promise<void> {

if (isTTY()) {

this.context.logger.info(INTERACTIVE_MESSAGE);

return;

}

const server = await createMcpServer({ workspace: this.context.workspace });

const transport = new StdioServerTransport();

await server.connect(transport);

}

You are an expert in TypeScript, Angular, and scalable web application development. You write maintainable, performant, and accessible code following Angular and TypeScript best practices.

- Use strict type checking

- Prefer type inference when the type is obvious

- Avoid the `any` type; use `unknown` when type is uncertain

- Always use standalone components over NgModules

- Don't use explicit `standalone: true` (it is implied by default)

- Use signals for state management

- Implement lazy loading for feature routes

- Use `NgOptimizedImage` for all static images.

- Keep components small and focused on a single responsibility

- Use `input()` and `output()` functions instead of decorators

- Use `computed()` for derived state

- Set `changeDetection: ChangeDetectionStrategy.OnPush` in `@Component` decorator

- Prefer inline templates for small components

- Prefer Reactive forms instead of Template-driven ones

- Do NOT use `ngClass`, use `class` bindings instead

- DO NOT use `ngStyle`, use `style` bindings instead

- Use signals for local component state

- Use `computed()` for derived state

- Keep state transformations pure and predictable

- Keep templates simple and avoid complex logic

- Use native control flow (`@if`, `@for`, `@switch`) instead of `*ngIf`, `*ngFor`, `*ngSwitch`

- Use the async pipe to handle observables

- Design services around a single responsibility

- Use the `providedIn: 'root'` option for singleton services

- Use the `inject()` function instead of constructor injection

import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';

import { readFile } from 'node:fs/promises';

import path from 'node:path';

import type { AngularWorkspace } from '../../utilities/config';

import { VERSION } from '../../utilities/version';

export async function createMcpServer(context: {

workspace?: AngularWorkspace;

}): Promise<McpServer> {

const server = new McpServer({

name: 'angular-cli-server',

version: VERSION.full,

capabilities: {

resources: {},

tools: {},

},

});

server.registerResource(

'instructions',

'instructions://best-practices',

{

title: 'Angular System Instructions',

description:

'A set of instructions to help LLMs generate correct code that follows Angular best practices.',

mimeType: 'text/markdown',

},

async () => {

const text = await readFile(

path.join(__dirname, 'instructions', 'best-practices.md'),

'utf-8',

);

return { contents: [{ uri: 'instructions://best-practices', text }] };

},

);

server.registerTool(

'list_projects',

{

title: 'List projects',

description:

'List projects within an Angular workspace.' +

' This information is read from the `angular.json` file at the root path of the Angular workspace',

},

() => {

if (!context.workspace) {

return {

content: [

{

type: 'text',

text: 'Not within an Angular project.',

},

],

};

}

return {

content: [

{

type: 'text',

text:

'Projects in the Angular workspace: ' +

[...context.workspace.projects.keys()].join(','),

},

],

};

},

);

return server;