@eaperezc/mcpgen 0.1.0

package/dist/cli/index.cjs

@@ -0,0 +1,625 @@
+#!/usr/bin/env node
+'use strict';
+
+var commander = require('commander');
+var promises = require('fs/promises');
+var path = require('path');
+
+function toPascalCase(str) {
+  return str.split(/[-_\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+function toKebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+async function exists(path) {
+  try {
+    await promises.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function toolTemplate(className, toolName) {
+  return `import { BaseTool } from 'mcpkit';
+import { z } from 'zod';
+
+/**
+ * ${className} - Description of what this tool does
+ */
+export class ${className} extends BaseTool {
+  name = '${toolName}';
+  description = 'TODO: Add description';
+
+  schema = z.object({
+    // TODO: Define your input schema
+    input: z.string().describe('Input parameter'),
+  });
+
+  async execute(input: z.infer<typeof this.schema>) {
+    // TODO: Implement your tool logic
+    return {
+      content: {
+        result: \`Processed: \${input.input}\`,
+      },
+    };
+  }
+}
+`;
+}
+function resourceTemplate(className, resourceName) {
+  return `import { BaseResource } from 'mcpkit';
+
+/**
+ * ${className} - Description of what this resource provides
+ */
+export class ${className} extends BaseResource {
+  uri = '${resourceName}://data';
+  name = '${className}';
+  description = 'TODO: Add description';
+
+  async read() {
+    // TODO: Implement your resource logic
+    return {
+      contents: [
+        this.json({
+          // Your data here
+          example: 'data',
+        }),
+      ],
+    };
+  }
+}
+`;
+}
+function promptTemplate(className, promptName) {
+  return `import { BasePrompt } from 'mcpkit';
+import { z } from 'zod';
+
+/**
+ * ${className} - Description of what this prompt does
+ */
+export class ${className} extends BasePrompt {
+  name = '${promptName}';
+  description = 'TODO: Add description';
+
+  arguments = z.object({
+    // TODO: Define your arguments schema
+    topic: z.string().describe('The topic to discuss'),
+  });
+
+  async render(args: z.infer<typeof this.arguments>) {
+    // TODO: Implement your prompt logic
+    return {
+      messages: [
+        this.user(\`Please help me with: \${args.topic}\`),
+      ],
+    };
+  }
+}
+`;
+}
+async function updateIndexFile(indexPath, className, fileName) {
+  let content = "";
+  if (await exists(indexPath)) {
+    content = await promises.readFile(indexPath, "utf-8");
+  }
+  const exportLine = `export { ${className} } from './${fileName}.js';`;
+  if (!content.includes(exportLine)) {
+    const lines = content.split("\n").filter(
+      (line) => line.trim() && !line.trim().startsWith("//")
+    );
+    lines.push(exportLine);
+    content = lines.join("\n") + "\n";
+    await promises.writeFile(indexPath, content);
+  }
+}
+async function generateComponent(options) {
+  const { type, name } = options;
+  const className = toPascalCase(name) + (type === "tool" ? "Tool" : type === "resource" ? "Resource" : "Prompt");
+  const fileName = className;
+  const kebabName = toKebabCase(name);
+  const typeDir = type === "tool" ? "tools" : type === "resource" ? "resources" : "prompts";
+  const srcDir = path.join(process.cwd(), "src", typeDir);
+  const filePath = path.join(srcDir, `${fileName}.ts`);
+  const indexPath = path.join(srcDir, "index.ts");
+  if (!await exists(path.join(process.cwd(), "src"))) {
+    throw new Error('No src/ directory found. Are you in an mcpkit project? Run "mcpkit init" first.');
+  }
+  await promises.mkdir(srcDir, { recursive: true });
+  if (await exists(filePath)) {
+    throw new Error(`${type} '${fileName}' already exists at ${filePath}`);
+  }
+  let content;
+  switch (type) {
+    case "tool":
+      content = toolTemplate(className, kebabName);
+      break;
+    case "resource":
+      content = resourceTemplate(className, kebabName);
+      break;
+    case "prompt":
+      content = promptTemplate(className, kebabName);
+      break;
+    default:
+      throw new Error(`Unknown component type: ${type}`);
+  }
+  await promises.writeFile(filePath, content);
+  console.log(`
+\u2705 Created ${type}: ${filePath.replace(process.cwd(), ".")}`);
+  await updateIndexFile(indexPath, className, fileName);
+  console.log(`   Updated: ${indexPath.replace(process.cwd(), ".")}`);
+  console.log(`
+Next steps:
+
+  1. Edit src/${typeDir}/${fileName}.ts to implement your ${type}
+  2. Register it in src/index.ts:
+
+     import { ${className} } from './tools/${fileName}.js';
+     server.${type}(new ${className}());
+`);
+}
+
+// src/cli/templates/index.ts
+var packageJsonTemplate = (name, description) => `{
+  "name": "${name}",
+  "version": "0.1.0",
+  "description": "${description}",
+  "type": "module",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx watch src/index.ts",
+    "start": "node dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": ["mcp", "model-context-protocol"],
+  "license": "MIT",
+  "dependencies": {
+    "@eaperezc/mcpgen": "^0.1.0",
+    "@modelcontextprotocol/sdk": "^1.11.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "typescript": "^5.7.2",
+    "tsx": "^4.19.2",
+    "vitest": "^2.1.8"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}
+`;
+var tsconfigTemplate = () => `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}
+`;
+var gitignoreTemplate = () => `# Dependencies
+node_modules/
+
+# Build output
+dist/
+
+# Environment files
+.env
+.env.local
+.env.*.local
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+`;
+var mainIndexTemplate = (name, transport) => {
+  if (transport === "http") {
+    return `import { McpServer } from '@eaperezc/mcpgen';
+import { GreetTool } from './tools/GreetTool.js';
+import { ConfigResource } from './resources/ConfigResource.js';
+
+const server = new McpServer({
+  name: '${name}',
+  version: '0.1.0',
+  transport: {
+    type: 'http',
+    port: 3000,
+    cors: { origin: '*' },
+  },
+  logging: { level: 'info' },
+});
+
+// Register tools
+server.tool(new GreetTool());
+
+// Register resources
+server.resource(new ConfigResource());
+
+// Start the server
+server.start().then(() => {
+  console.log('MCP server running at http://localhost:3000/mcp');
+});
+`;
+  }
+  return `import { McpServer } from '@eaperezc/mcpgen';
+import { GreetTool } from './tools/GreetTool.js';
+import { ConfigResource } from './resources/ConfigResource.js';
+
+const server = new McpServer({
+  name: '${name}',
+  version: '0.1.0',
+  logging: { level: 'info' },
+});
+
+// Register tools
+server.tool(new GreetTool());
+
+// Register resources
+server.resource(new ConfigResource());
+
+// Start the server
+server.start();
+`;
+};
+var toolsIndexTemplate = () => `export { GreetTool } from './GreetTool.js';
+`;
+var greetToolTemplate = () => `import { BaseTool } from '@eaperezc/mcpgen';
+import { z } from 'zod';
+
+/**
+ * Example tool that greets a user
+ */
+export class GreetTool extends BaseTool {
+  name = 'greet';
+  description = 'Greets a user by name';
+
+  schema = z.object({
+    name: z.string().describe('The name of the person to greet'),
+  });
+
+  async execute(input: z.infer<typeof this.schema>) {
+    return {
+      content: {
+        greeting: \`Hello, \${input.name}! Welcome to your MCP server.\`,
+      },
+    };
+  }
+}
+`;
+var resourcesIndexTemplate = () => `export { ConfigResource } from './ConfigResource.js';
+`;
+var configResourceTemplate = (name) => `import { BaseResource } from '@eaperezc/mcpgen';
+
+/**
+ * Example resource that provides server configuration
+ */
+export class ConfigResource extends BaseResource {
+  uri = 'config://server';
+  name = 'Server Configuration';
+  description = 'Provides server configuration information';
+
+  async read() {
+    return {
+      contents: [
+        this.json({
+          serverName: '${name}',
+          version: '0.1.0',
+          environment: process.env.NODE_ENV ?? 'development',
+        }),
+      ],
+    };
+  }
+}
+`;
+var promptsIndexTemplate = () => `// Export your prompts here
+// export { SummarizePrompt } from './SummarizePrompt.js';
+`;
+var testExampleTemplate = () => `import { describe, it, expect } from 'vitest';
+import { createTestClient } from '@eaperezc/mcpgen/testing';
+import { GreetTool } from '../src/tools/GreetTool.js';
+
+describe('GreetTool', () => {
+  it('should greet the user', async () => {
+    const client = createTestClient();
+    client.registerTool(new GreetTool());
+
+    const result = await client.callTool('greet', { name: 'Alice' });
+
+    expect(result.content).toHaveProperty('greeting');
+    expect((result.content as { greeting: string }).greeting).toContain('Alice');
+  });
+
+  it('should require a name', async () => {
+    const client = createTestClient();
+    client.registerTool(new GreetTool());
+
+    await expect(client.callTool('greet', {})).rejects.toThrow();
+  });
+});
+`;
+var readmeTemplate = (name, description) => `# ${name}
+
+${description}
+
+## Getting Started
+
+### Installation
+
+\`\`\`bash
+npm install
+\`\`\`
+
+### Development
+
+Run the server in development mode with hot reload:
+
+\`\`\`bash
+npm run dev
+\`\`\`
+
+### Production
+
+Build and run:
+
+\`\`\`bash
+npm run build
+npm start
+\`\`\`
+
+### Testing
+
+\`\`\`bash
+npm test
+\`\`\`
+
+## Project Structure
+
+\`\`\`
+${name}/
+\u251C\u2500\u2500 src/
+\u2502   \u251C\u2500\u2500 tools/          # MCP tools
+\u2502   \u2502   \u2514\u2500\u2500 GreetTool.ts
+\u2502   \u251C\u2500\u2500 resources/      # MCP resources
+\u2502   \u2502   \u2514\u2500\u2500 ConfigResource.ts
+\u2502   \u251C\u2500\u2500 prompts/        # MCP prompts
+\u2502   \u2514\u2500\u2500 index.ts        # Server entry point
+\u251C\u2500\u2500 tests/
+\u2502   \u2514\u2500\u2500 tools.test.ts
+\u251C\u2500\u2500 package.json
+\u2514\u2500\u2500 tsconfig.json
+\`\`\`
+
+## Adding New Components
+
+### Tools
+
+Create a new file in \`src/tools/\`:
+
+\`\`\`typescript
+import { BaseTool } from '@eaperezc/mcpgen';
+import { z } from 'zod';
+
+export class MyTool extends BaseTool {
+  name = 'my-tool';
+  description = 'Description of what this tool does';
+
+  schema = z.object({
+    // Define your input schema
+  });
+
+  async execute(input: z.infer<typeof this.schema>) {
+    // Implement your tool logic
+    return { content: { result: 'success' } };
+  }
+}
+\`\`\`
+
+### Resources
+
+Create a new file in \`src/resources/\`:
+
+\`\`\`typescript
+import { BaseResource } from '@eaperezc/mcpgen';
+
+export class MyResource extends BaseResource {
+  uri = 'my-resource://example';
+  name = 'My Resource';
+
+  async read() {
+    return { contents: [this.json({ data: 'example' })] };
+  }
+}
+\`\`\`
+
+## License
+
+MIT
+`;
+var vitestConfigTemplate = () => `import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+  },
+});
+`;
+
+// src/cli/commands/init.ts
+async function exists2(path) {
+  try {
+    await promises.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function initProject(options) {
+  const {
+    name,
+    description = `An MCP server built with @eaperezc/mcpgen`,
+    transport = "stdio"
+  } = options;
+  const projectDir = path.join(process.cwd(), name);
+  if (await exists2(projectDir)) {
+    throw new Error(`Directory '${name}' already exists`);
+  }
+  console.log(`
+Creating new MCP server: ${name}
+`);
+  const dirs = [
+    projectDir,
+    path.join(projectDir, "src"),
+    path.join(projectDir, "src", "tools"),
+    path.join(projectDir, "src", "resources"),
+    path.join(projectDir, "src", "prompts"),
+    path.join(projectDir, "tests")
+  ];
+  for (const dir of dirs) {
+    await promises.mkdir(dir, { recursive: true });
+    console.log(`  Created: ${dir.replace(process.cwd(), ".")}`);
+  }
+  const files = [
+    { path: "package.json", content: packageJsonTemplate(name, description) },
+    { path: "tsconfig.json", content: tsconfigTemplate() },
+    { path: ".gitignore", content: gitignoreTemplate() },
+    { path: "vitest.config.ts", content: vitestConfigTemplate() },
+    { path: "README.md", content: readmeTemplate(name, description) },
+    { path: "src/index.ts", content: mainIndexTemplate(name, transport) },
+    { path: "src/tools/index.ts", content: toolsIndexTemplate() },
+    { path: "src/tools/GreetTool.ts", content: greetToolTemplate() },
+    { path: "src/resources/index.ts", content: resourcesIndexTemplate() },
+    { path: "src/resources/ConfigResource.ts", content: configResourceTemplate(name) },
+    { path: "src/prompts/index.ts", content: promptsIndexTemplate() },
+    { path: "tests/tools.test.ts", content: testExampleTemplate() }
+  ];
+  for (const file of files) {
+    const filePath = path.join(projectDir, file.path);
+    await promises.writeFile(filePath, file.content);
+    console.log(`  Created: ./${name}/${file.path}`);
+  }
+  console.log(`
+\u2705 Project created successfully!
+
+Next steps:
+
+  cd ${name}
+  npm install
+  npm run dev
+
+${transport === "http" ? "Server will run at http://localhost:3000/mcp" : "Server will run via stdio"}
+
+To add new components:
+  - Tools: Create files in src/tools/
+  - Resources: Create files in src/resources/
+  - Prompts: Create files in src/prompts/
+
+Happy building! \u{1F680}
+`);
+}
+
+// src/cli/index.ts
+var program = new commander.Command();
+program.name("mcpgen").description("CLI for building MCP servers").version("0.1.0");
+program.command("init").description("Initialize a new MCP server project").argument("<name>", "Project name").option("-d, --description <desc>", "Project description").option("-t, --transport <type>", "Transport type (stdio or http)", "stdio").option("--skip-install", "Skip npm install").action(async (name, options) => {
+  try {
+    await initProject({
+      name,
+      description: options.description,
+      transport: options.transport,
+      skipInstall: options.skipInstall
+    });
+  } catch (error) {
+    console.error(`
+\u274C Error: ${error instanceof Error ? error.message : error}
+`);
+    process.exit(1);
+  }
+});
+program.command("make:tool").description("Create a new tool").argument("<name>", "Tool name").action(async (name) => {
+  try {
+    await generateComponent({ type: "tool", name });
+  } catch (error) {
+    console.error(`
+\u274C Error: ${error instanceof Error ? error.message : error}
+`);
+    process.exit(1);
+  }
+});
+program.command("make:resource").description("Create a new resource").argument("<name>", "Resource name").action(async (name) => {
+  try {
+    await generateComponent({ type: "resource", name });
+  } catch (error) {
+    console.error(`
+\u274C Error: ${error instanceof Error ? error.message : error}
+`);
+    process.exit(1);
+  }
+});
+program.command("make:prompt").description("Create a new prompt").argument("<name>", "Prompt name").action(async (name) => {
+  try {
+    await generateComponent({ type: "prompt", name });
+  } catch (error) {
+    console.error(`
+\u274C Error: ${error instanceof Error ? error.message : error}
+`);
+    process.exit(1);
+  }
+});
+program.addHelpText(
+  "after",
+  `
+Examples:
+  $ mcpgen init my-mcp-server            Create a new MCP server project
+  $ mcpgen init my-api --transport http  Create with HTTP transport
+  $ mcpgen make:tool search              Create a new tool
+  $ mcpgen make:resource database        Create a new resource
+  $ mcpgen make:prompt summarize         Create a new prompt
+`
+);
+if (process.argv.length <= 2) {
+  const cyan = "\x1B[36m";
+  const dim = "\x1B[2m";
+  const bold = "\x1B[1m";
+  const reset = "\x1B[0m";
+  console.log(`
+${dim}+-------------------------------------+${reset}
+${dim}|${reset}                                     ${dim}|${reset}
+${dim}|${reset}   ${bold}${cyan}MCPGEN${reset}  ${dim}v0.1.0${reset}                 ${dim}|${reset}
+${dim}|${reset}                                     ${dim}|${reset}
+${dim}|${reset}   A TypeScript framework for        ${dim}|${reset}
+${dim}|${reset}   building MCP servers              ${dim}|${reset}
+${dim}|${reset}                                     ${dim}|${reset}
+${dim}|${reset}   Run ${cyan}mcpgen --help${reset} for commands    ${dim}|${reset}
+${dim}|${reset}                                     ${dim}|${reset}
+${dim}+-------------------------------------+${reset}
+`);
+} else {
+  program.parse();
+}
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map