add-prompt

Add Prompt Template to MCP Server

Adds a new prompt template to your MCP server for reusable conversation patterns.

Usage

/add-prompt <name> <description> [arguments]

Examples

/add-prompt code_review "Review code for improvements" language:string file:string?
/add-prompt analyze_data "Analyze data patterns" dataset:string metrics:array
/add-prompt generate_docs "Generate documentation" codebase:string style:enum[minimal,detailed]

Implementation

import * as fs from 'fs/promises';
import * as path from 'path';

async function addPrompt(
  name: string,
  description: string,
  argumentDefs?: string[]
) {
  // Parse arguments
  const args = parsePromptArguments(argumentDefs || []);
  
  // Generate prompt file
  const promptContent = generatePromptFile(name, description, args);
  
  // Write prompt file
  const promptPath = path.join('src/prompts', `${name}.ts`);
  await fs.writeFile(promptPath, promptContent);
  
  // Update prompt index
  await updatePromptIndex(name);
  
  // Generate test file
  const testContent = generatePromptTest(name);
  const testPath = path.join('tests/unit/prompts', `${name}.test.ts`);
  await fs.writeFile(testPath, testContent);
  
  console.log(`✅ Prompt "${name}" added successfully!`);
  console.log(`  - Implementation: ${promptPath}`);
  console.log(`  - Test file: ${testPath}`);
  console.log(`\nNext steps:`);
  console.log(`  1. Define the prompt template in ${promptPath}`);
  console.log(`  2. Test with MCP Inspector`);
}

interface PromptArgument {
  name: string;
  description: string;
  required: boolean;
  type: string;
}

function parsePromptArguments(argumentDefs: string[]): PromptArgument[] {
  return argumentDefs.map(def => {
    const [nameWithType, description] = def.split('=');
    const [nameType] = nameWithType.split(':');
    const isOptional = nameType.endsWith('?');
    const name = isOptional ? nameType.slice(0, -1) : nameType;
    const type = nameWithType.split(':')[1] || 'string';
    
    return {
      name,
      description: description || `${name} parameter`,
      required: !isOptional,
      type: type.replace('?', ''),
    };
  });
}

function generatePromptFile(
  name: string,
  description: string,
  args: PromptArgument[]
): string {
  return `
import type { Prompt, PromptMessage } from '../types/prompts.js';

export const ${name}Prompt: Prompt = {
  name: '${name}',
  description: '${description}',
  arguments: [
${args.map(arg => `    {
      name: '${arg.name}',
      description: '${arg.description}',
      required: ${arg.required},
    },`).join('\n')}
  ],
};

export function get${capitalize(name)}Prompt(
  args: Record<string, unknown>
): PromptMessage[] {
  // Validate required arguments
${args.filter(a => a.required).map(arg => `  if (!args.${arg.name}) {
    throw new Error('Missing required argument: ${arg.name}');
  }`).join('\n')}
  
  // Build prompt messages
  const messages: PromptMessage[] = [];
  
  // System message (optional)
  messages.push({
    role: 'system',
    content: {
      type: 'text',
      text: buildSystemPrompt(args),
    },
  });
  
  // User message
  messages.push({
    role: 'user',
    content: {
      type: 'text',
      text: buildUserPrompt(args),
    },
  });
  
  return messages;
}

function buildSystemPrompt(args: Record<string, unknown>): string {
  // TODO: Define the system prompt template
  return \`You are an expert assistant helping with ${description.toLowerCase()}.\`;
}

function buildUserPrompt(args: Record<string, unknown>): string {
  // TODO: Define the user prompt template
  let prompt = '${description}\\n\\n';
  
${args.map(arg => `  if (args.${arg.name}) {
    prompt += \`${capitalize(arg.name)}: \${args.${arg.name}}\\n\`;
  }`).join('\n')}
  
  return prompt;
}

function capitalize(str: string): string {
  return str.charAt(0).toUpperCase() + str.slice(1);
}
`;
}

function generatePromptTest(name: string): string {
  return `
import { describe, it, expect } from 'vitest';