@webbywisp/create-mcp-server 0.1.0

package/dist/cli.js

@@ -0,0 +1,1806 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import chalk3 from "chalk";
+
+// src/commands/init.ts
+import path2 from "path";
+import chalk2 from "chalk";
+import ora from "ora";
+import fs2 from "fs-extra";
+
+// src/utils/prompts.ts
+import inquirer from "inquirer";
+async function runWizard(defaults) {
+  return inquirer.prompt([
+    {
+      type: "input",
+      name: "serverName",
+      message: "Server name (used in MCP config):",
+      default: defaults?.serverName ?? "my-mcp-server",
+      validate: (input) => {
+        if (!input.trim()) return "Server name cannot be empty";
+        if (!/^[a-z0-9-]+$/.test(input)) return "Use lowercase letters, numbers, and hyphens only";
+        return true;
+      }
+    },
+    {
+      type: "input",
+      name: "serverDescription",
+      message: "Short description:",
+      default: defaults?.serverDescription ?? "An MCP server"
+    },
+    {
+      type: "list",
+      name: "template",
+      message: "Choose a template:",
+      default: defaults?.template ?? "tool-server",
+      choices: [
+        {
+          name: "tool-server    \u2014 expose tools (functions AI can call)",
+          value: "tool-server",
+          short: "tool-server"
+        },
+        {
+          name: "resource-server \u2014 expose data/files as addressable resources",
+          value: "resource-server",
+          short: "resource-server"
+        },
+        {
+          name: "prompt-server  \u2014 provide structured prompt templates",
+          value: "prompt-server",
+          short: "prompt-server"
+        }
+      ]
+    },
+    {
+      type: "input",
+      name: "packageName",
+      message: "npm package name:",
+      default: (answers) => defaults?.packageName ?? answers.serverName,
+      validate: (input) => {
+        if (!input.trim()) return "Package name cannot be empty";
+        return true;
+      }
+    },
+    {
+      type: "input",
+      name: "author",
+      message: "Author name:",
+      default: defaults?.author ?? ""
+    },
+    {
+      type: "confirm",
+      name: "gitInit",
+      message: "Initialize a git repository?",
+      default: defaults?.gitInit ?? true
+    }
+  ]);
+}
+function buildDefaultConfig(targetDir, dirName, overrides = {}) {
+  return {
+    targetDir,
+    dirName,
+    serverName: dirName,
+    serverDescription: `An MCP server`,
+    template: "tool-server",
+    packageName: dirName,
+    author: "",
+    gitInit: true,
+    dryRun: false,
+    yes: false,
+    ...overrides
+  };
+}
+
+// src/utils/files.ts
+import fs from "fs-extra";
+import path from "path";
+import chalk from "chalk";
+async function writeFiles(targetDir, files, force) {
+  const results = [];
+  for (const file of files) {
+    const filePath = path.join(targetDir, file.path);
+    if (file.isDirectory) {
+      await fs.ensureDir(filePath);
+      results.push({ path: file.path, status: "created" });
+      continue;
+    }
+    await fs.ensureDir(path.dirname(filePath));
+    const exists = await fs.pathExists(filePath);
+    if (exists && !force) {
+      results.push({ path: file.path, status: "skipped" });
+      continue;
+    }
+    await fs.writeFile(filePath, file.content, "utf8");
+    results.push({ path: file.path, status: exists ? "overwritten" : "created" });
+  }
+  return results;
+}
+function printDryRunTree(targetDir, files) {
+  console.log(chalk.bold(`\u{1F4C1} ${targetDir}/`));
+  for (const file of files) {
+    const icon = file.isDirectory ? "\u{1F4C1}" : "\u{1F4C4}";
+    console.log(chalk.dim(`  ${icon} ${file.path}`));
+  }
+  console.log();
+}
+function printWriteResults(results) {
+  for (const result of results) {
+    if (result.status === "created") {
+      console.log(`  ${chalk.green("+")} ${result.path}`);
+    } else if (result.status === "overwritten") {
+      console.log(`  ${chalk.yellow("~")} ${result.path} ${chalk.dim("(overwritten)")}`);
+    } else {
+      console.log(`  ${chalk.dim("-")} ${result.path} ${chalk.dim("(skipped)")}`);
+    }
+  }
+}
+
+// src/templates/tool-server.ts
+function generateToolServer(config) {
+  const { serverName, serverDescription, packageName, author } = config;
+  return [
+    {
+      path: "src/index.ts",
+      content: `import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { readFileTool } from './tools/readFile.js';
+import { writeFileTool } from './tools/writeFile.js';
+import { httpFetchTool } from './tools/httpFetch.js';
+import { execCommandTool } from './tools/execCommand.js';
+
+const server = new McpServer({
+  name: '${serverName}',
+  version: '0.1.0',
+});
+
+// Register all tools
+server.tool(
+  readFileTool.name,
+  readFileTool.description,
+  readFileTool.inputSchema,
+  readFileTool.handler,
+);
+
+server.tool(
+  writeFileTool.name,
+  writeFileTool.description,
+  writeFileTool.inputSchema,
+  writeFileTool.handler,
+);
+
+server.tool(
+  httpFetchTool.name,
+  httpFetchTool.description,
+  httpFetchTool.inputSchema,
+  httpFetchTool.handler,
+);
+
+server.tool(
+  execCommandTool.name,
+  execCommandTool.description,
+  execCommandTool.inputSchema,
+  execCommandTool.handler,
+);
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('${serverName} MCP server running on stdio');
+}
+
+main().catch((err) => {
+  console.error('Fatal error:', err);
+  process.exit(1);
+});
+`
+    },
+    {
+      path: "src/tools/readFile.ts",
+      content: `import { z } from 'zod';
+import fs from 'fs/promises';
+import path from 'path';
+
+export const readFileTool = {
+  name: 'read_file',
+  description: 'Read the contents of a file. Returns the file content as a string.',
+  inputSchema: {
+    path: z.string().describe('Absolute or relative path to the file'),
+    encoding: z.enum(['utf8', 'base64']).optional().default('utf8').describe('File encoding'),
+    maxBytes: z.number().optional().default(1048576).describe('Max bytes to read (default 1MB)'),
+  },
+  handler: async ({ path: filePath, encoding, maxBytes }: {
+    path: string;
+    encoding?: 'utf8' | 'base64';
+    maxBytes?: number;
+  }) => {
+    const resolvedPath = path.resolve(filePath);
+    
+    try {
+      const stat = await fs.stat(resolvedPath);
+      
+      if (!stat.isFile()) {
+        return {
+          content: [{ type: 'text' as const, text: \`Error: \${filePath} is not a file\` }],
+          isError: true,
+        };
+      }
+      
+      if (stat.size > (maxBytes ?? 1048576)) {
+        return {
+          content: [{ 
+            type: 'text' as const, 
+            text: \`Error: File too large (\${stat.size} bytes). Max is \${maxBytes} bytes.\` 
+          }],
+          isError: true,
+        };
+      }
+      
+      const content = await fs.readFile(resolvedPath, encoding ?? 'utf8');
+      
+      return {
+        content: [{ type: 'text' as const, text: String(content) }],
+      };
+    } catch (err: any) {
+      return {
+        content: [{ type: 'text' as const, text: \`Error reading file: \${err.message}\` }],
+        isError: true,
+      };
+    }
+  },
+};
+`
+    },
+    {
+      path: "src/tools/writeFile.ts",
+      content: `import { z } from 'zod';
+import fs from 'fs/promises';
+import path from 'path';
+
+export const writeFileTool = {
+  name: 'write_file',
+  description: 'Write content to a file. Creates parent directories if needed.',
+  inputSchema: {
+    path: z.string().describe('Absolute or relative path to write to'),
+    content: z.string().describe('Content to write'),
+    encoding: z.enum(['utf8', 'base64']).optional().default('utf8').describe('File encoding'),
+    createDirs: z.boolean().optional().default(true).describe('Create parent directories if missing'),
+    overwrite: z.boolean().optional().default(true).describe('Overwrite if file exists'),
+  },
+  handler: async ({ path: filePath, content, encoding, createDirs, overwrite }: {
+    path: string;
+    content: string;
+    encoding?: 'utf8' | 'base64';
+    createDirs?: boolean;
+    overwrite?: boolean;
+  }) => {
+    const resolvedPath = path.resolve(filePath);
+    
+    try {
+      // Check if file exists
+      if (!overwrite) {
+        const exists = await fs.access(resolvedPath).then(() => true).catch(() => false);
+        if (exists) {
+          return {
+            content: [{ type: 'text' as const, text: \`Error: File already exists at \${filePath}. Set overwrite=true to overwrite.\` }],
+            isError: true,
+          };
+        }
+      }
+      
+      if (createDirs) {
+        await fs.mkdir(path.dirname(resolvedPath), { recursive: true });
+      }
+      
+      await fs.writeFile(resolvedPath, content, encoding ?? 'utf8');
+      
+      return {
+        content: [{ type: 'text' as const, text: \`Successfully wrote \${content.length} bytes to \${filePath}\` }],
+      };
+    } catch (err: any) {
+      return {
+        content: [{ type: 'text' as const, text: \`Error writing file: \${err.message}\` }],
+        isError: true,
+      };
+    }
+  },
+};
+`
+    },
+    {
+      path: "src/tools/httpFetch.ts",
+      content: `import { z } from 'zod';
+
+export const httpFetchTool = {
+  name: 'http_fetch',
+  description: 'Make an HTTP request and return the response. Supports GET, POST, PUT, DELETE.',
+  inputSchema: {
+    url: z.string().url().describe('URL to fetch'),
+    method: z.enum(['GET', 'POST', 'PUT', 'DELETE', 'PATCH']).optional().default('GET').describe('HTTP method'),
+    headers: z.record(z.string()).optional().describe('Request headers as key-value pairs'),
+    body: z.string().optional().describe('Request body (for POST/PUT/PATCH)'),
+    timeoutMs: z.number().optional().default(30000).describe('Timeout in milliseconds'),
+    maxBytes: z.number().optional().default(524288).describe('Max response bytes (default 512KB)'),
+  },
+  handler: async ({ url, method, headers, body, timeoutMs, maxBytes }: {
+    url: string;
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+    timeoutMs?: number;
+    maxBytes?: number;
+  }) => {
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), timeoutMs ?? 30000);
+      
+      const response = await fetch(url, {
+        method: method ?? 'GET',
+        headers: headers,
+        body: body,
+        signal: controller.signal,
+      });
+      
+      clearTimeout(timeout);
+      
+      const responseHeaders: Record<string, string> = {};
+      response.headers.forEach((value, key) => {
+        responseHeaders[key] = value;
+      });
+      
+      const contentType = response.headers.get('content-type') ?? '';
+      let responseText: string;
+      
+      if (contentType.includes('application/json') || contentType.includes('text/')) {
+        const arrayBuffer = await response.arrayBuffer();
+        const bytes = arrayBuffer.byteLength;
+        if (bytes > (maxBytes ?? 524288)) {
+          responseText = \`[Response truncated: \${bytes} bytes exceeds maxBytes limit]\`;
+        } else {
+          responseText = new TextDecoder().decode(arrayBuffer);
+        }
+      } else {
+        responseText = \`[Binary content: \${contentType}]\`;
+      }
+      
+      const summary = [
+        \`Status: \${response.status} \${response.statusText}\`,
+        \`Content-Type: \${contentType}\`,
+        \`\\n\${responseText}\`,
+      ].join('\\n');
+      
+      return {
+        content: [{ type: 'text' as const, text: summary }],
+        isError: !response.ok,
+      };
+    } catch (err: any) {
+      return {
+        content: [{ type: 'text' as const, text: \`HTTP request failed: \${err.message}\` }],
+        isError: true,
+      };
+    }
+  },
+};
+`
+    },
+    {
+      path: "src/tools/execCommand.ts",
+      content: `import { z } from 'zod';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+// Safety: block dangerous commands by default
+const BLOCKED_PATTERNS = [
+  /rm\\s+-rf\\s+\\//,
+  /mkfs/,
+  /dd\\s+if=/,
+  /:(\\s*)\\{\\s*:\\|:&\\s*\\}/,  // fork bomb
+  />\\/dev\\/(sd|hd|nvme)/,
+];
+
+export const execCommandTool = {
+  name: 'exec_command',
+  description: 'Execute a shell command and return stdout/stderr. Use with caution.',
+  inputSchema: {
+    command: z.string().describe('Shell command to execute'),
+    cwd: z.string().optional().describe('Working directory (defaults to process cwd)'),
+    timeoutMs: z.number().optional().default(30000).describe('Timeout in milliseconds'),
+    env: z.record(z.string()).optional().describe('Additional environment variables'),
+  },
+  handler: async ({ command, cwd, timeoutMs, env }: {
+    command: string;
+    cwd?: string;
+    timeoutMs?: number;
+    env?: Record<string, string>;
+  }) => {
+    // Safety check
+    for (const pattern of BLOCKED_PATTERNS) {
+      if (pattern.test(command)) {
+        return {
+          content: [{ type: 'text' as const, text: \`Error: Command blocked for safety: \${command}\` }],
+          isError: true,
+        };
+      }
+    }
+    
+    try {
+      const { stdout, stderr } = await execAsync(command, {
+        cwd: cwd ?? process.cwd(),
+        timeout: timeoutMs ?? 30000,
+        env: { ...process.env, ...env },
+        maxBuffer: 1024 * 1024, // 1MB
+      });
+      
+      const output = [
+        stdout && \`stdout:\\n\${stdout.trim()}\`,
+        stderr && \`stderr:\\n\${stderr.trim()}\`,
+      ].filter(Boolean).join('\\n\\n') || '(no output)';
+      
+      return {
+        content: [{ type: 'text' as const, text: output }],
+      };
+    } catch (err: any) {
+      const output = [
+        \`Exit code: \${err.code ?? 'unknown'}\`,
+        err.stdout && \`stdout:\\n\${err.stdout.trim()}\`,
+        err.stderr && \`stderr:\\n\${err.stderr.trim()}\`,
+        \`Error: \${err.message}\`,
+      ].filter(Boolean).join('\\n');
+      
+      return {
+        content: [{ type: 'text' as const, text: output }],
+        isError: true,
+      };
+    }
+  },
+};
+`
+    },
+    {
+      path: "package.json",
+      content: JSON.stringify({
+        name: packageName,
+        version: "0.1.0",
+        description: serverDescription,
+        type: "module",
+        scripts: {
+          build: "tsc",
+          dev: "tsc --watch",
+          start: "node dist/index.js",
+          prepublishOnly: "npm run build"
+        },
+        engines: { node: ">=18.0.0" },
+        dependencies: {
+          "@modelcontextprotocol/sdk": "^1.0.0",
+          zod: "^3.22.0"
+        },
+        devDependencies: {
+          "@types/node": "^22.0.0",
+          typescript: "^5.0.0"
+        }
+      }, null, 2)
+    },
+    {
+      path: "tsconfig.json",
+      content: JSON.stringify({
+        compilerOptions: {
+          target: "ES2022",
+          module: "NodeNext",
+          moduleResolution: "NodeNext",
+          lib: ["ES2022"],
+          outDir: "dist",
+          rootDir: "src",
+          strict: true,
+          esModuleInterop: true,
+          skipLibCheck: true,
+          declaration: true,
+          sourceMap: true,
+          resolveJsonModule: true
+        },
+        include: ["src/**/*"],
+        exclude: ["node_modules", "dist"]
+      }, null, 2)
+    },
+    {
+      path: ".gitignore",
+      content: `node_modules/
+dist/
+*.js.map
+*.d.ts.map
+.env
+.env.local
+*.log
+.DS_Store
+`
+    },
+    {
+      path: "README.md",
+      content: `# ${serverName}
+
+${serverDescription}
+
+A [Model Context Protocol (MCP)](https://modelcontextprotocol.io) tool server that exposes file system, HTTP, and shell execution capabilities to AI models.
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| \`read_file\` | Read file contents with encoding and size limits |
+| \`write_file\` | Write files, creating directories as needed |
+| \`http_fetch\` | Make HTTP requests (GET, POST, PUT, DELETE) |
+| \`exec_command\` | Execute shell commands with safety checks |
+
+## Setup
+
+\`\`\`bash
+npm install
+npm run build
+\`\`\`
+
+## Usage with Claude Desktop
+
+Add to your Claude Desktop config (\`~/Library/Application Support/Claude/claude_desktop_config.json\`):
+
+\`\`\`json
+{
+  "mcpServers": {
+    "${serverName}": {
+      "command": "node",
+      "args": ["${config.targetDir}/dist/index.js"]
+    }
+  }
+}
+\`\`\`
+
+## Development
+
+\`\`\`bash
+npm run dev        # Watch mode
+npm start          # Run the server
+\`\`\`
+
+## Adding Tools
+
+Create a new file in \`src/tools/\` following the existing pattern:
+
+\`\`\`typescript
+import { z } from 'zod';
+
+export const myTool = {
+  name: 'my_tool',
+  description: 'Description of what this tool does',
+  inputSchema: {
+    param1: z.string().describe('First parameter'),
+    param2: z.number().optional().describe('Optional number'),
+  },
+  handler: async ({ param1, param2 }) => {
+    // Your implementation
+    return {
+      content: [{ type: 'text' as const, text: 'result' }],
+    };
+  },
+};
+\`\`\`
+
+Then register it in \`src/index.ts\`.
+
+## Author
+
+${author}
+`
+    }
+  ];
+}
+
+// src/templates/resource-server.ts
+function generateResourceServer(config) {
+  const { serverName, serverDescription, packageName, author } = config;
+  return [
+    {
+      path: "src/index.ts",
+      content: `import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { fileSystemResources } from './resources/fileSystem.js';
+import { databaseResources } from './resources/database.js';
+import { configResources } from './resources/config.js';
+
+const server = new McpServer({
+  name: '${serverName}',
+  version: '0.1.0',
+});
+
+// Register resource providers
+fileSystemResources.register(server);
+databaseResources.register(server);
+configResources.register(server);
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('${serverName} MCP resource server running on stdio');
+}
+
+main().catch((err) => {
+  console.error('Fatal error:', err);
+  process.exit(1);
+});
+`
+    },
+    {
+      path: "src/resources/fileSystem.ts",
+      content: `import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+import fs from 'fs/promises';
+import path from 'path';
+
+/**
+ * File system resources \u2014 expose files and directories as MCP resources.
+ * URI pattern: file:///absolute/path/to/file
+ */
+export const fileSystemResources = {
+  register(server: McpServer) {
+    // Static resource: list files in a directory
+    server.resource(
+      'workspace-files',
+      'file:///workspace',
+      async (uri) => {
+        const dir = process.cwd();
+        try {
+          const entries = await fs.readdir(dir, { withFileTypes: true });
+          const listing = entries
+            .map((e) => \`\${e.isDirectory() ? '[dir]' : '[file]'} \${e.name}\`)
+            .join('\\n');
+          
+          return {
+            contents: [{
+              uri: uri.href,
+              mimeType: 'text/plain',
+              text: \`Files in \${dir}:\\n\\n\${listing}\`,
+            }],
+          };
+        } catch (err: any) {
+          throw new Error(\`Failed to list directory: \${err.message}\`);
+        }
+      },
+    );
+
+    // Dynamic resource template: read any file by URI
+    server.resource(
+      'file',
+      new ResourceTemplate('file://{path}', { list: undefined }),
+      async (uri, params) => {
+        const filePath = decodeURIComponent(params.path as string);
+        const resolvedPath = path.isAbsolute(filePath)
+          ? filePath
+          : path.resolve(process.cwd(), filePath);
+        
+        try {
+          const stat = await fs.stat(resolvedPath);
+          
+          if (stat.isDirectory()) {
+            const entries = await fs.readdir(resolvedPath, { withFileTypes: true });
+            const listing = entries
+              .map((e) => \`\${e.isDirectory() ? '[dir] ' : '[file]'} \${e.name}\`)
+              .join('\\n');
+            return {
+              contents: [{
+                uri: uri.href,
+                mimeType: 'text/plain',
+                text: listing,
+              }],
+            };
+          }
+          
+          const ext = path.extname(resolvedPath).toLowerCase();
+          const textExtensions = new Set([
+            '.ts', '.tsx', '.js', '.jsx', '.json', '.md', '.txt', 
+            '.yaml', '.yml', '.toml', '.env', '.sh', '.bash', '.zsh',
+            '.py', '.rb', '.go', '.rs', '.java', '.c', '.cpp', '.h',
+            '.html', '.css', '.scss', '.less', '.xml', '.svg',
+          ]);
+          
+          if (textExtensions.has(ext) || stat.size < 100000) {
+            const content = await fs.readFile(resolvedPath, 'utf8');
+            const mimeType = getMimeType(ext);
+            
+            return {
+              contents: [{
+                uri: uri.href,
+                mimeType,
+                text: content,
+              }],
+            };
+          } else {
+            const data = await fs.readFile(resolvedPath);
+            return {
+              contents: [{
+                uri: uri.href,
+                mimeType: 'application/octet-stream',
+                blob: data.toString('base64'),
+              }],
+            };
+          }
+        } catch (err: any) {
+          throw new Error(\`Failed to read file \${resolvedPath}: \${err.message}\`);
+        }
+      },
+    );
+  },
+};
+
+function getMimeType(ext: string): string {
+  const map: Record<string, string> = {
+    '.ts': 'text/typescript',
+    '.tsx': 'text/typescript',
+    '.js': 'text/javascript',
+    '.jsx': 'text/javascript',
+    '.json': 'application/json',
+    '.md': 'text/markdown',
+    '.txt': 'text/plain',
+    '.yaml': 'text/yaml',
+    '.yml': 'text/yaml',
+    '.html': 'text/html',
+    '.css': 'text/css',
+    '.svg': 'image/svg+xml',
+    '.xml': 'application/xml',
+    '.py': 'text/x-python',
+    '.sh': 'text/x-sh',
+  };
+  return map[ext] ?? 'text/plain';
+}
+`
+    },
+    {
+      path: "src/resources/database.ts",
+      content: `import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+// Example: In-memory key-value store as a resource.
+// Replace with your actual data source (SQLite, Postgres, Redis, etc.)
+const store = new Map<string, unknown>([
+  ['example:config', { version: '1.0', feature_flags: { new_ui: true } }],
+  ['example:stats', { requests: 0, errors: 0, uptime: Date.now() }],
+]);
+
+/**
+ * Database/store resources \u2014 expose structured data as MCP resources.
+ * URI pattern: db://namespace/key
+ * 
+ * Replace the in-memory store with your actual database client.
+ */
+export const databaseResources = {
+  register(server: McpServer) {
+    // List all available keys
+    server.resource(
+      'db-index',
+      'db://index',
+      async (uri) => {
+        const keys = Array.from(store.keys());
+        const listing = keys.map(k => \`  \${k}\`).join('\\n');
+        
+        return {
+          contents: [{
+            uri: uri.href,
+            mimeType: 'text/plain',
+            text: \`Available keys (\${keys.length}):\\n\${listing}\`,
+          }],
+        };
+      },
+    );
+
+    // Dynamic resource: fetch any key
+    server.resource(
+      'db-record',
+      new ResourceTemplate('db://{namespace}/{key}', { list: undefined }),
+      async (uri, params) => {
+        const recordKey = \`\${params.namespace}:\${params.key}\`;
+        const value = store.get(recordKey);
+        
+        if (value === undefined) {
+          throw new Error(\`Key not found: \${recordKey}\`);
+        }
+        
+        return {
+          contents: [{
+            uri: uri.href,
+            mimeType: 'application/json',
+            text: JSON.stringify(value, null, 2),
+          }],
+        };
+      },
+    );
+  },
+};
+`
+    },
+    {
+      path: "src/resources/config.ts",
+      content: `import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import fs from 'fs/promises';
+import path from 'path';
+
+/**
+ * Config resources \u2014 expose runtime config, env vars, and app settings.
+ * 
+ * These are useful for giving the AI context about the environment
+ * without exposing sensitive credentials.
+ */
+export const configResources = {
+  register(server: McpServer) {
+    // Expose safe environment info
+    server.resource(
+      'environment',
+      'config://environment',
+      async (uri) => {
+        const safeEnv: Record<string, string> = {};
+        
+        // Only expose non-sensitive env vars
+        const allowedPrefixes = ['NODE_', 'npm_', 'PATH', 'HOME', 'USER', 'SHELL', 'LANG'];
+        const blockedKeys = ['TOKEN', 'SECRET', 'PASSWORD', 'KEY', 'PRIVATE', 'AUTH', 'CREDENTIAL'];
+        
+        for (const [key, value] of Object.entries(process.env)) {
+          if (value === undefined) continue;
+          
+          const isBlocked = blockedKeys.some(b => key.toUpperCase().includes(b));
+          if (isBlocked) continue;
+          
+          safeEnv[key] = value;
+        }
+        
+        return {
+          contents: [{
+            uri: uri.href,
+            mimeType: 'application/json',
+            text: JSON.stringify({
+              nodeVersion: process.version,
+              platform: process.platform,
+              arch: process.arch,
+              cwd: process.cwd(),
+              env: safeEnv,
+            }, null, 2),
+          }],
+        };
+      },
+    );
+
+    // Expose package.json info
+    server.resource(
+      'package-info',
+      'config://package',
+      async (uri) => {
+        try {
+          const pkgPath = path.resolve(process.cwd(), 'package.json');
+          const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf8'));
+          
+          // Strip sensitive fields
+          const { _authToken, publishConfig, ...safePkg } = pkg;
+          
+          return {
+            contents: [{
+              uri: uri.href,
+              mimeType: 'application/json',
+              text: JSON.stringify(safePkg, null, 2),
+            }],
+          };
+        } catch {
+          return {
+            contents: [{
+              uri: uri.href,
+              mimeType: 'text/plain',
+              text: 'No package.json found in current directory',
+            }],
+          };
+        }
+      },
+    );
+  },
+};
+`
+    },
+    {
+      path: "package.json",
+      content: JSON.stringify({
+        name: packageName,
+        version: "0.1.0",
+        description: serverDescription,
+        type: "module",
+        scripts: {
+          build: "tsc",
+          dev: "tsc --watch",
+          start: "node dist/index.js",
+          prepublishOnly: "npm run build"
+        },
+        engines: { node: ">=18.0.0" },
+        dependencies: {
+          "@modelcontextprotocol/sdk": "^1.0.0"
+        },
+        devDependencies: {
+          "@types/node": "^22.0.0",
+          typescript: "^5.0.0"
+        }
+      }, null, 2)
+    },
+    {
+      path: "tsconfig.json",
+      content: JSON.stringify({
+        compilerOptions: {
+          target: "ES2022",
+          module: "NodeNext",
+          moduleResolution: "NodeNext",
+          lib: ["ES2022"],
+          outDir: "dist",
+          rootDir: "src",
+          strict: true,
+          esModuleInterop: true,
+          skipLibCheck: true,
+          declaration: true,
+          sourceMap: true,
+          resolveJsonModule: true
+        },
+        include: ["src/**/*"],
+        exclude: ["node_modules", "dist"]
+      }, null, 2)
+    },
+    {
+      path: ".gitignore",
+      content: `node_modules/
+dist/
+*.js.map
+*.d.ts.map
+.env
+.env.local
+*.log
+.DS_Store
+`
+    },
+    {
+      path: "README.md",
+      content: `# ${serverName}
+
+${serverDescription}
+
+A [Model Context Protocol (MCP)](https://modelcontextprotocol.io) resource server that exposes file system, database, and configuration data as addressable resources.
+
+## Resources
+
+| URI Pattern | Description |
+|-------------|-------------|
+| \`file:///workspace\` | List files in working directory |
+| \`file://{path}\` | Read any file by path |
+| \`db://index\` | List all database keys |
+| \`db://{namespace}/{key}\` | Fetch a specific record |
+| \`config://environment\` | Safe environment info |
+| \`config://package\` | Package.json info |
+
+## Setup
+
+\`\`\`bash
+npm install
+npm run build
+\`\`\`
+
+## Usage with Claude Desktop
+
+Add to your Claude Desktop config:
+
+\`\`\`json
+{
+  "mcpServers": {
+    "${serverName}": {
+      "command": "node",
+      "args": ["${config.targetDir}/dist/index.js"]
+    }
+  }
+}
+\`\`\`
+
+## Development
+
+\`\`\`bash
+npm run dev    # Watch mode
+npm start      # Run the server
+\`\`\`
+
+## Connecting a Real Database
+
+Replace the in-memory store in \`src/resources/database.ts\` with your actual data source:
+
+\`\`\`typescript
+// Example with SQLite
+import Database from 'better-sqlite3';
+const db = new Database('./data.db');
+
+// Example with Postgres
+import { Pool } from 'pg';
+const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+\`\`\`
+
+## Author
+
+${author}
+`
+    }
+  ];
+}
+
+// src/templates/prompt-server.ts
+function generatePromptServer(config) {
+  const { serverName, serverDescription, packageName, author } = config;
+  return [
+    {
+      path: "src/index.ts",
+      content: `import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { codeReviewPrompts } from './prompts/codeReview.js';
+import { documentationPrompts } from './prompts/documentation.js';
+import { debuggingPrompts } from './prompts/debugging.js';
+import { refactoringPrompts } from './prompts/refactoring.js';
+
+const server = new McpServer({
+  name: '${serverName}',
+  version: '0.1.0',
+});
+
+// Register prompt collections
+codeReviewPrompts.register(server);
+documentationPrompts.register(server);
+debuggingPrompts.register(server);
+refactoringPrompts.register(server);
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('${serverName} MCP prompt server running on stdio');
+}
+
+main().catch((err) => {
+  console.error('Fatal error:', err);
+  process.exit(1);
+});
+`
+    },
+    {
+      path: "src/prompts/codeReview.ts",
+      content: `import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+
+/**
+ * Code review prompt templates.
+ * Structured prompts that guide thorough, consistent code reviews.
+ */
+export const codeReviewPrompts = {
+  register(server: McpServer) {
+    server.prompt(
+      'code-review',
+      'Comprehensive code review with focus areas',
+      {
+        code: z.string().describe('The code to review'),
+        language: z.string().optional().describe('Programming language (e.g. TypeScript, Python)'),
+        context: z.string().optional().describe('What does this code do? Any relevant context?'),
+        focus: z.enum(['security', 'performance', 'readability', 'correctness', 'all'])
+          .optional()
+          .default('all')
+          .describe('Area to focus the review on'),
+      },
+      ({ code, language, context, focus }) => {
+        const lang = language ?? 'unknown';
+        const focusInstructions: Record<string, string> = {
+          security: \`Focus specifically on security vulnerabilities:
+- Input validation and sanitization
+- Authentication and authorization flaws
+- Injection vulnerabilities (SQL, XSS, command)
+- Sensitive data exposure
+- Insecure dependencies\`,
+          performance: \`Focus specifically on performance:
+- Time complexity of algorithms (Big O)
+- Unnecessary re-renders or recomputations
+- Memory leaks or excessive allocations
+- N+1 query problems
+- Missing indexes or caching opportunities\`,
+          readability: \`Focus specifically on readability and maintainability:
+- Naming clarity (variables, functions, classes)
+- Function/method length and single responsibility
+- Comment quality (explain why, not what)
+- Consistent style and conventions
+- Dead code or confusing abstractions\`,
+          correctness: \`Focus specifically on correctness:
+- Edge cases and boundary conditions
+- Error handling completeness
+- Race conditions or concurrency issues
+- Incorrect assumptions in logic
+- Missing null/undefined checks\`,
+          all: \`Review all aspects: security, performance, readability, correctness, and design.\`,
+        };
+        
+        return {
+          messages: [
+            {
+              role: 'user',
+              content: {
+                type: 'text',
+                text: \`Please perform a detailed code review of the following \${lang} code.
+
+\${context ? \`Context: \${context}\\n\\n\` : ''}\${focusInstructions[focus ?? 'all']}
+
+For each issue found:
+1. Quote the specific code
+2. Explain the problem
+3. Provide a concrete fix
+
+Rate severity as: \u{1F534} Critical | \u{1F7E0} High | \u{1F7E1} Medium | \u{1F535} Low | \u{1F4A1} Suggestion
+
+Code to review:
+\\\`\\\`\\\`\${lang}
+\${code}
+\\\`\\\`\\\`\`,
+              },
+            },
+          ],
+        };
+      },
+    );
+
+    server.prompt(
+      'security-audit',
+      'Security-focused code audit',
+      {
+        code: z.string().describe('Code to audit'),
+        threat_model: z.string().optional().describe('Who are the potential attackers? What are they after?'),
+      },
+      ({ code, threat_model }) => ({
+        messages: [
+          {
+            role: 'user',
+            content: {
+              type: 'text',
+              text: \`Perform a security audit on this code.
+
+\${threat_model ? \`Threat model: \${threat_model}\\n\\n\` : ''}
+Check for:
+- OWASP Top 10 vulnerabilities
+- Authentication/authorization bypasses
+- Data validation and sanitization
+- Cryptographic weaknesses
+- Dependency vulnerabilities
+- Secrets or credentials in code
+- Information disclosure
+
+For each finding, provide:
+- CVE category (if applicable)
+- Severity (Critical/High/Medium/Low)
+- Attack vector
+- Remediation steps
+
+Code:
+\\\`\\\`\\\`
+\${code}
+\\\`\\\`\\\`\`,
+            },
+          },
+        ],
+      }),
+    );
+  },
+};
+`
+    },
+    {
+      path: "src/prompts/documentation.ts",
+      content: `import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+
+/**
+ * Documentation generation prompts.
+ */
+export const documentationPrompts = {
+  register(server: McpServer) {
+    server.prompt(
+      'generate-docs',
+      'Generate comprehensive documentation for code',
+      {
+        code: z.string().describe('Code to document'),
+        style: z.enum(['jsdoc', 'tsdoc', 'docstring', 'markdown']).optional().default('tsdoc'),
+        audience: z.enum(['internal', 'public-api', 'tutorial']).optional().default('public-api'),
+      },
+      ({ code, style, audience }) => {
+        const styleGuides: Record<string, string> = {
+          jsdoc: 'Use JSDoc format with @param, @returns, @throws, @example tags',
+          tsdoc: 'Use TSDoc format with @param, @returns, @throws, @example, @remarks tags',
+          docstring: 'Use Python docstring format (Google style)',
+          markdown: 'Generate a Markdown documentation section',
+        };
+        
+        const audienceGuides: Record<string, string> = {
+          internal: 'This is for internal developers. Focus on implementation details and gotchas.',
+          'public-api': 'This is a public API. Focus on usage, parameters, and examples. Hide implementation details.',
+          tutorial: 'This is for beginners. Explain concepts, provide step-by-step examples.',
+        };
+        
+        return {
+          messages: [
+            {
+              role: 'user',
+              content: {
+                type: 'text',
+                text: \`Generate documentation for the following code.
+
+Format: \${styleGuides[style ?? 'tsdoc']}
+Audience: \${audienceGuides[audience ?? 'public-api']}
+
+Include:
+- Overview/description
+- Parameter documentation with types
+- Return value documentation
+- Thrown errors/exceptions
+- At least one usage example
+- Any important notes or caveats
+
+Code:
+\\\`\\\`\\\`
+\${code}
+\\\`\\\`\\\`\`,
+              },
+            },
+          ],
+        };
+      },
+    );
+
+    server.prompt(
+      'readme-generator',
+      'Generate a README.md for a project',
+      {
+        project_name: z.string().describe('Project name'),
+        description: z.string().describe('What does this project do?'),
+        tech_stack: z.string().describe('Technologies used (e.g. Node.js, TypeScript, React)'),
+        main_features: z.string().describe('Key features, one per line'),
+      },
+      ({ project_name, description, tech_stack, main_features }) => ({
+        messages: [
+          {
+            role: 'user',
+            content: {
+              type: 'text',
+              text: \`Generate a professional README.md for this project.
+
+Project: \${project_name}
+Description: \${description}
+Tech Stack: \${tech_stack}
+Features:
+\${main_features}
+
+Include these sections:
+1. Title and badges (placeholder)
+2. Description
+3. Features list
+4. Installation
+5. Quick start / usage example
+6. API reference (if applicable)
+7. Configuration
+8. Contributing
+9. License
+
+Make it clear, engaging, and developer-friendly.\`,
+            },
+          },
+        ],
+      }),
+    );
+  },
+};
+`
+    },
+    {
+      path: "src/prompts/debugging.ts",
+      content: `import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+
+/**
+ * Debugging assistance prompts.
+ */
+export const debuggingPrompts = {
+  register(server: McpServer) {
+    server.prompt(
+      'debug-error',
+      'Debug an error with full context analysis',
+      {
+        error_message: z.string().describe('The error message or stack trace'),
+        code: z.string().optional().describe('Relevant code where the error occurs'),
+        expected: z.string().optional().describe('What you expected to happen'),
+        actual: z.string().optional().describe('What actually happened'),
+        environment: z.string().optional().describe('Runtime environment (e.g. Node 18, Chrome 120)'),
+      },
+      ({ error_message, code, expected, actual, environment }) => ({
+        messages: [
+          {
+            role: 'user',
+            content: {
+              type: 'text',
+              text: \`Help me debug this error.
+
+Error:
+\\\`\\\`\\\`
+\${error_message}
+\\\`\\\`\\\`
+\${code ? \`\\nRelevant code:\\n\\\`\\\`\\\`\\n\${code}\\n\\\`\\\`\\\`\` : ''}
+\${expected ? \`\\nExpected: \${expected}\` : ''}
+\${actual ? \`\\nActual: \${actual}\` : ''}
+\${environment ? \`\\nEnvironment: \${environment}\` : ''}
+
+Please:
+1. Identify the root cause
+2. Explain why this error occurs
+3. Provide a step-by-step fix
+4. Suggest how to prevent this in the future\`,
+            },
+          },
+        ],
+      }),
+    );
+
+    server.prompt(
+      'rubber-duck',
+      'Explain code logic to find bugs through explanation',
+      {
+        code: z.string().describe('Code you want to explain/debug'),
+        problem: z.string().describe('What problem are you trying to solve with this code?'),
+      },
+      ({ code, problem }) => ({
+        messages: [
+          {
+            role: 'user',
+            content: {
+              type: 'text',
+              text: \`I'll explain my code to you and you help me find bugs through questioning.
+
+Problem I'm trying to solve: \${problem}
+
+My code:
+\\\`\\\`\\\`
+\${code}
+\\\`\\\`\\\`
+
+As I explain my code, please:
+1. Ask clarifying questions about assumptions I'm making
+2. Point out any logical inconsistencies
+3. Highlight edge cases I might not be handling
+4. Don't give me the answer directly \u2014 help me discover it through questions
+
+Let's start: what questions do you have about my approach?\`,
+            },
+          },
+        ],
+      }),
+    );
+  },
+};
+`
+    },
+    {
+      path: "src/prompts/refactoring.ts",
+      content: `import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+
+/**
+ * Code refactoring prompts.
+ */
+export const refactoringPrompts = {
+  register(server: McpServer) {
+    server.prompt(
+      'refactor',
+      'Refactor code with specific goals',
+      {
+        code: z.string().describe('Code to refactor'),
+        goals: z.string().describe('What do you want to improve? (e.g. reduce complexity, improve testability)'),
+        constraints: z.string().optional().describe('Any constraints (e.g. must keep same API, cannot use classes)'),
+        language: z.string().optional().describe('Programming language'),
+      },
+      ({ code, goals, constraints, language }) => ({
+        messages: [
+          {
+            role: 'user',
+            content: {
+              type: 'text',
+              text: \`Refactor this \${language ?? ''} code to achieve the following goals:
+
+Goals: \${goals}
+\${constraints ? \`Constraints: \${constraints}\` : ''}
+
+Original code:
+\\\`\\\`\\\`\${language ?? ''}
+\${code}
+\\\`\\\`\\\`
+
+Please:
+1. Explain your refactoring strategy
+2. Provide the refactored code
+3. Highlight what changed and why
+4. Note any tradeoffs\`,
+            },
+          },
+        ],
+      }),
+    );
+
+    server.prompt(
+      'extract-function',
+      'Extract logic into well-named functions',
+      {
+        code: z.string().describe('Code containing logic to extract'),
+        description: z.string().describe('Describe the logic you want to extract'),
+      },
+      ({ code, description }) => ({
+        messages: [
+          {
+            role: 'user',
+            content: {
+              type: 'text',
+              text: \`Help me extract the following logic into a well-named function:
+
+Logic to extract: \${description}
+
+From this code:
+\\\`\\\`\\\`
+\${code}
+\\\`\\\`\\\`
+
+Please provide:
+1. The extracted function with a clear, descriptive name
+2. The modified original code calling the new function
+3. Any parameters the function needs
+4. Proper TypeScript types if applicable\`,
+            },
+          },
+        ],
+      }),
+    );
+  },
+};
+`
+    },
+    {
+      path: "package.json",
+      content: JSON.stringify({
+        name: packageName,
+        version: "0.1.0",
+        description: serverDescription,
+        type: "module",
+        scripts: {
+          build: "tsc",
+          dev: "tsc --watch",
+          start: "node dist/index.js",
+          prepublishOnly: "npm run build"
+        },
+        engines: { node: ">=18.0.0" },
+        dependencies: {
+          "@modelcontextprotocol/sdk": "^1.0.0",
+          zod: "^3.22.0"
+        },
+        devDependencies: {
+          "@types/node": "^22.0.0",
+          typescript: "^5.0.0"
+        }
+      }, null, 2)
+    },
+    {
+      path: "tsconfig.json",
+      content: JSON.stringify({
+        compilerOptions: {
+          target: "ES2022",
+          module: "NodeNext",
+          moduleResolution: "NodeNext",
+          lib: ["ES2022"],
+          outDir: "dist",
+          rootDir: "src",
+          strict: true,
+          esModuleInterop: true,
+          skipLibCheck: true,
+          declaration: true,
+          sourceMap: true,
+          resolveJsonModule: true
+        },
+        include: ["src/**/*"],
+        exclude: ["node_modules", "dist"]
+      }, null, 2)
+    },
+    {
+      path: ".gitignore",
+      content: `node_modules/
+dist/
+*.js.map
+*.d.ts.map
+.env
+.env.local
+*.log
+.DS_Store
+`
+    },
+    {
+      path: "README.md",
+      content: `# ${serverName}
+
+${serverDescription}
+
+A [Model Context Protocol (MCP)](https://modelcontextprotocol.io) prompt server that provides structured, high-quality prompts for software development tasks.
+
+## Prompts
+
+### Code Review
+| Prompt | Description |
+|--------|-------------|
+| \`code-review\` | Comprehensive review with severity ratings |
+| \`security-audit\` | Security-focused code audit |
+
+### Documentation  
+| Prompt | Description |
+|--------|-------------|
+| \`generate-docs\` | Generate JSDoc/TSDoc/docstrings |
+| \`readme-generator\` | Generate a full README.md |
+
+### Debugging
+| Prompt | Description |
+|--------|-------------|
+| \`debug-error\` | Debug errors with full context |
+| \`rubber-duck\` | Guided explanation-based debugging |
+
+### Refactoring
+| Prompt | Description |
+|--------|-------------|
+| \`refactor\` | Refactor with specific goals and constraints |
+| \`extract-function\` | Extract logic into named functions |
+
+## Setup
+
+\`\`\`bash
+npm install
+npm run build
+\`\`\`
+
+## Usage with Claude Desktop
+
+\`\`\`json
+{
+  "mcpServers": {
+    "${serverName}": {
+      "command": "node",
+      "args": ["${config.targetDir}/dist/index.js"]
+    }
+  }
+}
+\`\`\`
+
+## Development
+
+\`\`\`bash
+npm run dev    # Watch mode
+npm start      # Run the server
+\`\`\`
+
+## Adding Prompts
+
+Create a new file in \`src/prompts/\` and register it in \`src/index.ts\`:
+
+\`\`\`typescript
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+
+export const myPrompts = {
+  register(server: McpServer) {
+    server.prompt(
+      'my-prompt-name',
+      'Description of what this prompt does',
+      {
+        input: z.string().describe('User input'),
+      },
+      ({ input }) => ({
+        messages: [
+          {
+            role: 'user',
+            content: { type: 'text', text: \`Do something with: \${input}\` },
+          },
+        ],
+      }),
+    );
+  },
+};
+\`\`\`
+
+## Author
+
+${author}
+`
+    }
+  ];
+}
+
+// src/commands/init.ts
+async function initCommand(dirArg, opts) {
+  const targetName = dirArg ?? ".";
+  const targetDir = path2.resolve(process.cwd(), targetName);
+  const dirName = path2.basename(targetDir);
+  console.log();
+  console.log(chalk2.bold.cyan("\u26A1 create-mcp-server") + chalk2.dim(" \u2014 scaffold your MCP server"));
+  console.log();
+  const targetExists = await fs2.pathExists(targetDir);
+  if (targetExists && !opts.dryRun) {
+    const entries = await fs2.readdir(targetDir).catch(() => []);
+    const hasContent = entries.some((e) => !e.startsWith("."));
+    if (hasContent && !opts.force) {
+      console.log(chalk2.yellow(`\u26A0\uFE0F  Directory ${chalk2.bold(targetDir)} already has files.`));
+      console.log(chalk2.dim("   Existing files will be skipped. Use --force to overwrite."));
+      console.log();
+    }
+  }
+  let config;
+  const isInteractive = !opts.yes && process.stdin.isTTY;
+  if (isInteractive) {
+    const answers = await runWizard({
+      serverName: dirName !== "." ? dirName : void 0,
+      template: opts.template
+    });
+    config = buildDefaultConfig(targetDir, dirName, {
+      serverName: answers.serverName,
+      serverDescription: answers.serverDescription,
+      template: answers.template,
+      packageName: answers.packageName,
+      author: answers.author,
+      gitInit: answers.gitInit,
+      dryRun: opts.dryRun ?? false
+    });
+  } else {
+    config = buildDefaultConfig(targetDir, dirName, {
+      serverName: dirName !== "." ? dirName : "my-mcp-server",
+      packageName: dirName !== "." ? dirName : "my-mcp-server",
+      template: opts.template ?? "tool-server",
+      dryRun: opts.dryRun ?? false,
+      yes: true
+    });
+    console.log(chalk2.dim(`Running with defaults. Template: ${config.template}`));
+    console.log();
+  }
+  const files = getTemplateFiles(config);
+  if (config.dryRun) {
+    console.log(chalk2.bold.yellow("\u{1F50D} Dry run \u2014 no files will be written\n"));
+    printDryRunTree(config.targetDir, files);
+    console.log(chalk2.dim(`  ${files.length} files would be created`));
+    console.log();
+    console.log(chalk2.dim("Run without --dry-run to scaffold the server."));
+    return;
+  }
+  const spinner = ora("Scaffolding MCP server...").start();
+  let results;
+  try {
+    results = await writeFiles(config.targetDir, files, opts.force ?? false);
+    spinner.succeed("Server scaffolded");
+  } catch (err) {
+    spinner.fail("Failed to write files");
+    throw err;
+  }
+  if (config.gitInit) {
+    const gitSpinner = ora("Initializing git...").start();
+    try {
+      const { simpleGit } = await import("simple-git");
+      const git = simpleGit(config.targetDir);
+      const isRepo = await git.checkIsRepo().catch(() => false);
+      if (!isRepo) {
+        await git.init();
+        gitSpinner.succeed("Git repository initialized");
+      } else {
+        gitSpinner.info("Git already initialized, skipped");
+      }
+    } catch {
+      gitSpinner.warn("Git init failed (git may not be installed)");
+    }
+  }
+  const created = results.filter((r) => r.status === "created");
+  const skipped = results.filter((r) => r.status === "skipped");
+  console.log();
+  console.log(chalk2.bold.green("\u2705 MCP server scaffolded at ") + chalk2.bold(config.targetDir));
+  console.log();
+  printWriteResults(results);
+  console.log();
+  console.log(chalk2.dim(`  ${created.length} file(s) created${skipped.length > 0 ? `, ${skipped.length} skipped` : ""}`));
+  console.log();
+  console.log(chalk2.bold("Next steps:"));
+  const rel = path2.relative(process.cwd(), config.targetDir);
+  if (rel && rel !== ".") {
+    console.log(`  ${chalk2.cyan(`cd ${rel}`)}`);
+  }
+  console.log(`  ${chalk2.cyan("npm install")}`);
+  console.log(`  ${chalk2.cyan("npm run build")}`);
+  console.log(`  ${chalk2.cyan("npm start")}`);
+  console.log();
+  console.log(chalk2.dim("  Then add to Claude Desktop config:"));
+  console.log(chalk2.dim(`  "command": "node", "args": ["${config.targetDir}/dist/index.js"]`));
+  console.log();
+  console.log(chalk2.dim("  See README.md for full setup instructions."));
+  console.log();
+}
+function getTemplateFiles(config) {
+  switch (config.template) {
+    case "tool-server":
+      return generateToolServer(config);
+    case "resource-server":
+      return generateResourceServer(config);
+    case "prompt-server":
+      return generatePromptServer(config);
+    default:
+      return generateToolServer(config);
+  }
+}
+
+// src/cli.ts
+var VERSION = "0.1.0";
+var program = new Command();
+program.name("create-mcp-server").description("Scaffold production-ready MCP (Model Context Protocol) servers").version(VERSION, "-v, --version", "Show version").addHelpText(
+  "after",
+  `
+${chalk3.bold("Examples:")}
+  ${chalk3.cyan("npx @webbywisp/create-mcp-server my-server")}                  Scaffold with prompts
+  ${chalk3.cyan("npx @webbywisp/create-mcp-server my-server --yes")}            Use all defaults (tool-server)
+  ${chalk3.cyan("npx @webbywisp/create-mcp-server my-server -t resource-server")}  Use resource-server template
+  ${chalk3.cyan("npx @webbywisp/create-mcp-server my-server --dry-run")}        Preview without writing files
+
+${chalk3.bold("Templates:")}
+  ${chalk3.cyan("tool-server")}     Expose tools (functions AI can call) \u2014 file I/O, HTTP, exec
+  ${chalk3.cyan("resource-server")} Expose data as addressable URIs \u2014 files, DB, config
+  ${chalk3.cyan("prompt-server")}   Provide structured prompt templates \u2014 review, debug, refactor
+`
+);
+program.command("init [directory]", { isDefault: true }).description("Scaffold a new MCP server (default command)").option("-t, --template <name>", "Template: tool-server | resource-server | prompt-server", "tool-server").option("-y, --yes", "Skip prompts, use all defaults").option("--dry-run", "Preview what would be created without writing files").option("--force", "Overwrite existing files").action(async (dir, opts) => {
+  try {
+    await initCommand(dir, {
+      template: opts.template,
+      yes: opts.yes,
+      dryRun: opts.dryRun,
+      force: opts.force
+    });
+  } catch (err) {
+    handleError(err);
+  }
+});
+program.command("list").description("Show available templates").action(() => {
+  console.log();
+  console.log(chalk3.bold("Available Templates:"));
+  console.log();
+  const templates = [
+    {
+      name: "tool-server",
+      desc: "Expose callable tools to AI models",
+      includes: "read_file, write_file, http_fetch, exec_command"
+    },
+    {
+      name: "resource-server",
+      desc: "Expose data as addressable resources",
+      includes: "file://, db://, config:// URI schemes"
+    },
+    {
+      name: "prompt-server",
+      desc: "Provide structured prompt templates",
+      includes: "code-review, debug-error, generate-docs, refactor"
+    }
+  ];
+  templates.forEach(({ name, desc, includes }) => {
+    console.log(`  ${chalk3.cyan.bold(name.padEnd(18))} ${desc}`);
+    console.log(`  ${" ".repeat(18)} ${chalk3.dim("Includes: " + includes)}`);
+    console.log();
+  });
+});
+function handleError(err) {
+  if (err instanceof Error) {
+    console.error(chalk3.red(`
+\u274C Error: ${err.message}`));
+    if (process.env.DEBUG) {
+      console.error(chalk3.dim(err.stack ?? ""));
+    }
+  } else {
+    console.error(chalk3.red("\n\u274C An unexpected error occurred"));
+    console.error(err);
+  }
+  process.exit(1);
+}
+program.parseAsync(process.argv).catch(handleError);
+//# sourceMappingURL=cli.js.map