#!/usr/bin/env node
/**
* CTP MCP Server
*
* Model Context Protocol server for generating ConveniencePro Tool Protocol tools.
* Provides AI-powered tool scaffolding and code generation.
*/
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 { createTool } from './tools/create-tool.js';
import { validateTool } from './tools/validate-tool.js';
import { generateImplementation } from './tools/generate-implementation.js';
import { generateTests } from './tools/generate-tests.js';
import { searchDuplicates } from './tools/search-duplicates.js';
// MCP Server instance
const server = new Server(
{
name: '@conveniencepro/ctp-mcp-server',
version: '1.0.0',
},
{
capabilities: {
tools: {},
},
}
);
// List available tools
server.setRequestHandler(ListToolsRequestSchema, async () => {
return {
tools: [
{
name: 'ctp_create_tool',
description: 'Generate a complete CTP tool from a natural language description. Creates tool definition, implementation, and tests.',
inputSchema: {
type: 'object',
properties: {
description: {
type: 'string',
description: 'Natural language description of what the tool should do',
},
name: {
type: 'string',
description: 'Tool name (optional - will be auto-generated if not provided)',
},
category: {
type: 'string',
description: 'Tool category (e.g., "converters", "calculators", "generators")',
},
executionMode: {
type: 'string',
enum: ['client', 'server', 'both'],
description: 'Where the tool should execute (default: client)',
},
},
required: ['description'],
},
},
{
name: 'ctp_validate_tool',
description: 'Validate a tool definition against the CTP specification',
inputSchema: {
type: 'object',
properties: {
definition: {
type: 'object',
description: 'The tool definition to validate',
},
},
required: ['definition'],
},
},
{
name: 'ctp_generate_implementation',
description: 'Generate implementation code from a tool definition',
inputSchema: {
type: 'object',
properties: {
definition: {
type: 'object',
description: 'The tool definition',
},
executionMode: {
type: 'string',
enum: ['client', 'server', 'both'],
description: 'Execution mode (default: client)',
},
},
required: ['definition'],
},
},
{
name: 'ctp_generate_tests',
description: 'Generate test suite for a CTP tool',
inputSchema: {
type: 'object',
properties: {
definition: {
type: 'object',
description: 'The tool definition',
},
implementation: {
type: 'string',
description: 'The tool implementation code',
},
},
required: ['definition'],
},
},
{
name: 'ctp_search_duplicates',
description: 'Search for existing tools with similar functionality',
inputSchema: {
type: 'object',
properties: {
description: {
type: 'string',
description: 'Description of the tool to search for',
},
category: {
type: 'string',
description: 'Optional category to narrow search',
},
},
required: ['description'],
},
},
],
};
});
// Handle tool calls
server.setRequestHandler(CallToolRequestSchema, async (request) => {
const { name, arguments: args } = request.params;
try {
if (!args) {
throw new Error('Missing arguments');
}
switch (name) {
case 'ctp_create_tool':
return await createTool(args as never);
case 'ctp_validate_tool':
return await validateTool(args as never);
case 'ctp_generate_implementation':
return await generateImplementation(args as never);
case 'ctp_generate_tests':
return await generateTests(args as never);
case 'ctp_search_duplicates':
return await searchDuplicates(args as never);
default:
throw new Error(`Unknown tool: ${name}`);
}
} catch (error) {
const message = error instanceof Error ? error.message : 'Unknown error';
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: false,
error: message,
}, null, 2),
},
],
};
}
});
// Start the server
async function main() {
const transport = new StdioServerTransport();
await server.connect(transport);
console.error('CTP MCP Server running on stdio');
}
main().catch((error) => {
console.error('Fatal error:', error);
process.exit(1);
});
