@aiready/mcp-server 0.1.0

package/.turbo/turbo-build.log

@@ -0,0 +1,17 @@
+
+
+> @aiready/mcp-server@0.1.0 build /Users/pengcao/projects/aiready/packages/mcp-server
+> tsup src/index.ts --format esm --clean --dts
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Using tsup config: /Users/pengcao/projects/aiready/packages/mcp-server/tsup.config.ts
+CLI Target: node20
+CLI Cleaning output folder
+ESM Build start
+ESM dist/index.js 2.74 KB
+ESM ⚡️ Build success in 29ms
+DTS Build start
+DTS ⚡️ Build success in 2555ms
+DTS dist/index.d.ts 202.00 B

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * AIReady MCP Server Implementation
+ */
+declare class AIReadyMcpServer {
+    private server;
+    constructor();
+    private setupHandlers;
+    run(): Promise<void>;
+}
+
+export { AIReadyMcpServer };

package/dist/index.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { ToolRegistry } from "@aiready/core";
+import chalk from "chalk";
+import "@aiready/pattern-detect";
+import "@aiready/context-analyzer";
+import "@aiready/consistency";
+var AIReadyMcpServer = class {
+  constructor() {
+    this.server = new Server(
+      {
+        name: "aiready-server",
+        version: "0.1.0"
+      },
+      {
+        capabilities: {
+          tools: {}
+        }
+      }
+    );
+    this.setupHandlers();
+    this.server.onerror = (error) => {
+      console.error(chalk.red("[MCP Error]"), error);
+    };
+  }
+  setupHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      const providers = ToolRegistry.getAll();
+      return {
+        tools: providers.map((p) => ({
+          name: p.id,
+          description: `AIReady analysis tool: ${p.id}`,
+          inputSchema: {
+            type: "object",
+            properties: {
+              path: {
+                type: "string",
+                description: "Path to the directory to analyze"
+              }
+              // Future: expose tool-specific options
+            },
+            required: ["path"]
+          }
+        }))
+      };
+    });
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+      try {
+        const provider = ToolRegistry.find(name);
+        if (!provider) {
+          throw new Error(`Tool ${name} not found`);
+        }
+        if (!args || typeof args.path !== "string") {
+          throw new Error("Missing required argument: path");
+        }
+        console.error(chalk.blue(`[MCP] Executing ${name} on ${args.path}`));
+        const results = await provider.analyze({
+          rootDir: args.path
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(results, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error.message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    });
+  }
+  async run() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    console.error(chalk.green("AIReady MCP Server started"));
+  }
+};
+var server = new AIReadyMcpServer();
+server.run().catch((error) => {
+  console.error(chalk.red("Fatal error starting AIReady MCP Server:"), error);
+  process.exit(1);
+});
+export {
+  AIReadyMcpServer
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@aiready/mcp-server",
+  "version": "0.1.0",
+  "description": "AIReady Model Context Protocol (MCP) Server",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "bin": {
+    "aiready-mcp": "./dist/index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^0.6.0",
+    "chalk": "^5.3.0",
+    "zod": "^4.3.6",
+    "@aiready/core": "0.23.2",
+    "@aiready/context-analyzer": "0.21.6",
+    "@aiready/consistency": "0.20.2",
+    "@aiready/pattern-detect": "0.16.2"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "tsup": "^8.3.5",
+    "typescript": "^5.9.3",
+    "vitest": "^2.1.0"
+  },
+  "keywords": [
+    "aiready",
+    "mcp",
+    "model-context-protocol",
+    "ai-readiness",
+    "code-analysis"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --clean --dts",
+    "dev": "tsup src/index.ts --format esm --watch",
+    "test": "vitest run",
+    "lint": "eslint src",
+    "clean": "rm -rf dist",
+    "start": "node dist/index.js"
+  }
+}

package/src/__tests__/server.test.ts

@@ -0,0 +1,106 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// Point to the built JS to ensure we are testing the actual distribution
+const serverPath = path.resolve(__dirname, '../../dist/index.js');
+
+describe('AIReady MCP Server Integration', () => {
+  let client: Client;
+  let transport: StdioClientTransport;
+
+  beforeAll(async () => {
+    transport = new StdioClientTransport({
+      command: 'node',
+      args: [serverPath],
+    });
+
+    client = new Client(
+      { name: 'test-client', version: '1.0.0' },
+      { capabilities: {} }
+    );
+
+    await client.connect(transport);
+  });
+
+  afterAll(async () => {
+    // StdioClientTransport doesn't have an explicit close, but we should clear references
+  });
+
+  it('should list available tools', async () => {
+    const result = await client.listTools();
+
+    expect(result.tools).toBeDefined();
+    expect(result.tools.length).toBeGreaterThan(0);
+
+    const toolNames = result.tools.map((t) => t.name);
+    expect(toolNames).toContain('pattern-detect');
+    expect(toolNames).toContain('context-analyzer');
+    expect(toolNames).toContain('naming-consistency');
+  });
+
+  it('should expose correct input schema for tools', async () => {
+    const result = await client.listTools();
+
+    const patternDetect = result.tools.find((t) => t.name === 'pattern-detect');
+    expect(patternDetect?.inputSchema).toMatchObject({
+      type: 'object',
+      properties: {
+        path: { type: 'string' },
+      },
+      required: ['path'],
+    });
+  });
+
+  it('should execute pattern-detect and return results', async () => {
+    const result = await client.callTool({
+      name: 'pattern-detect',
+      arguments: {
+        path: path.resolve(__dirname, '../../../core'), // Test on core package
+      },
+    });
+
+    // Check if result has content
+    expect(result.content).toBeDefined();
+
+    const firstContent = result.content[0];
+    expect(firstContent.type).toBe('text');
+
+    const data = JSON.parse((firstContent as any).text);
+    expect(data).toHaveProperty('results');
+    expect(data).toHaveProperty('summary');
+  }, 20000); // Higher timeout for analysis
+
+  it('should return error for unknown tool', async () => {
+    const result = await client.callTool({
+      name: 'non-existent-tool',
+      arguments: { path: '.' },
+    });
+
+    expect(result.isError).toBe(true);
+    expect((result.content[0] as any).text).toContain(
+      'Tool non-existent-tool not found'
+    );
+  });
+
+  it('should return error for missing arguments', async () => {
+    // Note: The server handles missing arguments and returns isError: true
+    const result = await client.callTool({
+      name: 'pattern-detect',
+      arguments: {},
+    });
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0].type).toBe('text');
+    expect((result.content[0] as any).text).toContain(
+      'Missing required argument: path'
+    );
+  });
+});

package/src/index.ts

@@ -0,0 +1,122 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { ToolRegistry, ToolName } from '@aiready/core';
+import chalk from 'chalk';
+
+// Pre-load essential tools (following CLI pattern)
+// In a real implementation, we would want to dynamically load these
+// or have them as peer dependencies.
+import '@aiready/pattern-detect';
+import '@aiready/context-analyzer';
+import '@aiready/consistency';
+
+/**
+ * AIReady MCP Server Implementation
+ */
+export class AIReadyMcpServer {
+  private server: Server;
+
+  constructor() {
+    this.server = new Server(
+      {
+        name: 'aiready-server',
+        version: '0.1.0',
+      },
+      {
+        capabilities: {
+          tools: {},
+        },
+      }
+    );
+
+    this.setupHandlers();
+
+    this.server.onerror = (error) => {
+      console.error(chalk.red('[MCP Error]'), error);
+    };
+  }
+
+  private setupHandlers() {
+    // List available tools
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      const providers = ToolRegistry.getAll();
+
+      return {
+        tools: providers.map((p) => ({
+          name: p.id,
+          description: `AIReady analysis tool: ${p.id}`,
+          inputSchema: {
+            type: 'object',
+            properties: {
+              path: {
+                type: 'string',
+                description: 'Path to the directory to analyze',
+              },
+              // Future: expose tool-specific options
+            },
+            required: ['path'],
+          },
+        })),
+      };
+    });
+
+    // Handle tool execution
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+
+      try {
+        const provider = ToolRegistry.find(name);
+        if (!provider) {
+          throw new Error(`Tool ${name} not found`);
+        }
+
+        if (!args || typeof args.path !== 'string') {
+          throw new Error('Missing required argument: path');
+        }
+
+        console.error(chalk.blue(`[MCP] Executing ${name} on ${args.path}`));
+
+        const results = await provider.analyze({
+          rootDir: args.path,
+        });
+
+        // Format results for the agent
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(results, null, 2),
+            },
+          ],
+        };
+      } catch (error: any) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Error: ${error.message}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+    });
+  }
+
+  async run() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    console.error(chalk.green('AIReady MCP Server started'));
+  }
+}
+
+// Bootstrap the server
+const server = new AIReadyMcpServer();
+server.run().catch((error) => {
+  console.error(chalk.red('Fatal error starting AIReady MCP Server:'), error);
+  process.exit(1);
+});

package/test-mcp.ts

@@ -0,0 +1,84 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const serverPath = path.join(__dirname, 'dist', 'index.js');
+
+async function testServer() {
+  console.log('🚀 Starting MCP Server verification test...');
+
+  const transport = new StdioClientTransport({
+    command: 'node',
+    args: [serverPath],
+    env: {
+      ...process.env,
+      NODE_ENV: 'test',
+    },
+  });
+
+  const client = new Client(
+    {
+      name: 'test-client',
+      version: '1.0.0',
+    },
+    {
+      capabilities: {},
+    }
+  );
+
+  try {
+    await client.connect(transport);
+    console.log('✅ Connected to MCP Server');
+
+    // Test ListTools
+    const tools = await client.request(
+      { method: 'tools/list' },
+      ListToolsRequestSchema
+    );
+    console.log(
+      '📋 Available Tools:',
+      tools.tools.map((t) => t.name).join(', ')
+    );
+
+    if (tools.tools.length === 0) {
+      throw new Error('No tools listed!');
+    }
+
+    // Test CallTool (pattern-detect)
+    console.log("🔍 Testing 'pattern-detect'...");
+    const rootDir = '/Users/pengcao/projects/aiready'; // Test on current repo
+    const result = await client.request(
+      {
+        method: 'tools/call',
+        params: {
+          name: 'pattern-detect',
+          arguments: { path: rootDir },
+        },
+      },
+      CallToolRequestSchema
+    );
+
+    if (result.isError) {
+      console.error('❌ Tool execution failed:', result.content[0].text);
+    } else {
+      console.log('✅ Tool execution success!');
+      const data = JSON.parse(result.content[0].text);
+      console.log(
+        `📊 Found ${data.duplicates?.length || 0} duplicate patterns.`
+      );
+    }
+  } catch (error) {
+    console.error('💥 Test failed:', error);
+  } finally {
+    console.log('🏁 Verification test complete.');
+    process.exit(0);
+  }
+}
+
+testServer();

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src/**/*"]
+}

package/tsup.config.ts

@@ -0,0 +1,26 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm'],
+  dts: true,
+  clean: true,
+  shims: true,
+  // Treat these as external to avoid bundling them (they will be resolved at runtime)
+  external: [
+    '@aiready/core',
+    '@aiready/pattern-detect',
+    '@aiready/context-analyzer',
+    '@aiready/consistency',
+    '@modelcontextprotocol/sdk',
+    'path',
+    'url',
+    'fs',
+  ],
+  // Ensure we are targeting a modern node version
+  target: 'node20',
+  // Build to be executable
+  banner: {
+    js: '#!/usr/bin/env node',
+  },
+});