@agiflowai/scaffold-mcp 0.0.0

package/dist/index.js

@@ -0,0 +1,2812 @@
+#!/usr/bin/env node
+import { ScaffoldService, TemplatesManager } from "./ScaffoldService-CnJ1nj1v.js";
+import { ScaffoldConfigLoader } from "./ScaffoldConfigLoader-CI0T6zdG.js";
+import { TemplateService } from "./TemplateService-CnxvhRVW.js";
+import { VariableReplacementService } from "./VariableReplacementService-Bq0GDhTo.js";
+import { Command } from "commander";
+import { exec } from "node:child_process";
+import * as path$1 from "node:path";
+import path from "node:path";
+import { promisify } from "node:util";
+import * as fs$1 from "fs-extra";
+import fs from "fs-extra";
+import chalk from "chalk";
+import { jsonSchemaToZod } from "@composio/json-schema-to-zod";
+import * as yaml$1 from "js-yaml";
+import yaml from "js-yaml";
+import { z } from "zod";
+import { fileURLToPath } from "node:url";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListToolsRequestSchema, isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import { randomUUID } from "node:crypto";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import express from "express";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+//#region src/utils/console.ts
+/**
+* Themed console utilities for consistent CLI output
+*/
+const logger = {
+	info: (message) => {
+		console.log(chalk.cyan(message));
+	},
+	success: (message) => {
+		console.log(chalk.green(message));
+	},
+	warning: (message) => {
+		console.log(chalk.yellow(message));
+	},
+	error: (message, error) => {
+		if (error) {
+			const errorMsg = error instanceof Error ? error.message : error;
+			console.error(chalk.red(message), errorMsg);
+		} else console.error(chalk.red(message));
+	},
+	debug: (message) => {
+		console.log(chalk.gray(message));
+	},
+	header: (message) => {
+		console.log(chalk.bold.cyan(message));
+	},
+	item: (message) => {
+		console.log(chalk.gray(`   - ${message}`));
+	},
+	indent: (message) => {
+		console.log(chalk.gray(`   ${message}`));
+	},
+	highlight: (message) => {
+		console.log(chalk.bold.green(message));
+	},
+	newline: () => {
+		console.log();
+	}
+};
+/**
+* Emoji icons for consistent visual markers
+*/
+const icons = {
+	rocket: "=�",
+	check: "",
+	cross: "L",
+	warning: "�",
+	info: "9",
+	package: "=�",
+	folder: "=�",
+	file: "📄",
+	config: "📝",
+	wrench: "🔧",
+	chart: "📊",
+	bulb: "💡",
+	download: "=�",
+	upload: "=�",
+	gear: "�",
+	clipboard: "=�"
+};
+/**
+* Themed message helpers
+*/
+const messages = {
+	info: (message) => {
+		logger.info(`${icons.info} ${message}`);
+	},
+	success: (message) => {
+		logger.success(`${icons.check} ${message}`);
+	},
+	error: (message, error) => {
+		logger.error(`${icons.cross} ${message}`, error);
+	},
+	warning: (message) => {
+		logger.warning(`${icons.warning} ${message}`);
+	},
+	hint: (message) => {
+		logger.warning(`${icons.bulb} ${message}`);
+	},
+	loading: (message) => {
+		logger.info(`${icons.rocket} ${message}`);
+	}
+};
+/**
+* Section formatters
+*/
+const sections = {
+	header: (title) => {
+		logger.newline();
+		logger.header(`${title}`);
+		logger.newline();
+	},
+	list: (title, items) => {
+		logger.header(`\n${title}\n`);
+		items.forEach((item) => logger.item(item));
+	},
+	nextSteps: (steps) => {
+		logger.header(`\n${icons.clipboard} Next steps:`);
+		steps.forEach((step) => logger.indent(step));
+	},
+	createdFiles: (files, maxShow = 10) => {
+		logger.header(`\n${icons.folder} Created files:`);
+		files.slice(0, maxShow).forEach((file) => logger.item(file));
+		if (files.length > maxShow) logger.indent(`... and ${files.length - maxShow} more files`);
+	},
+	warnings: (warnings) => {
+		logger.warning(`\n${icons.warning} Warnings:`);
+		warnings.forEach((warning) => logger.item(warning));
+	}
+};
+
+//#endregion
+//#region src/cli/add.ts
+const execAsync = promisify(exec);
+/**
+* Add command - add a template to templates folder
+*/
+const addCommand = new Command("add").description("Add a template to templates folder").requiredOption("--name <name>", "Template name").requiredOption("--url <url>", "URL of the template repository to download").option("--path <path>", "Path to templates folder", "./templates").option("--type <type>", "Template type: boilerplate or scaffold", "boilerplate").action(async (options) => {
+	try {
+		const templatesPath = path.resolve(options.path);
+		const templateType = options.type.toLowerCase();
+		const templateName = options.name;
+		const templateUrl = options.url;
+		if (templateType !== "boilerplate" && templateType !== "scaffold") {
+			messages.error("Invalid template type. Use: boilerplate or scaffold");
+			process.exit(1);
+		}
+		const targetFolder = path.join(templatesPath, `${templateType}s`, templateName);
+		if (await fs$1.pathExists(targetFolder)) {
+			messages.error(`Template '${templateName}' already exists at ${targetFolder}`);
+			process.exit(1);
+		}
+		logger.info(`${icons.download} Downloading template '${templateName}' from ${templateUrl}...`);
+		await fs$1.ensureDir(path.dirname(targetFolder));
+		try {
+			await execAsync(`git clone ${templateUrl} "${targetFolder}"`);
+			const gitFolder = path.join(targetFolder, ".git");
+			if (await fs$1.pathExists(gitFolder)) await fs$1.remove(gitFolder);
+			messages.success(`Template '${templateName}' added successfully!`);
+			logger.header(`\n${icons.folder} Template location:`);
+			logger.indent(targetFolder);
+			const configFiles = [path.join(targetFolder, "boilerplate.yaml"), path.join(targetFolder, "scaffold.yaml")];
+			let hasConfig = false;
+			for (const configFile of configFiles) if (await fs$1.pathExists(configFile)) {
+				logger.header(`\n${icons.config} Configuration file found:`);
+				logger.indent(path.basename(configFile));
+				hasConfig = true;
+				break;
+			}
+			if (!hasConfig) {
+				messages.warning("Warning: No configuration file found (boilerplate.yaml or scaffold.yaml)");
+				logger.indent("You may need to create one manually.");
+			}
+			sections.nextSteps([`Review the template in ${targetFolder}`, `Test it with: scaffold-mcp ${templateType} list`]);
+		} catch (error) {
+			if (error.message.includes("not found") || error.message.includes("command not found")) messages.error("git command not found. Please install git first.");
+			else if (error.message.includes("Authentication failed")) messages.error("Authentication failed. Make sure you have access to the repository.");
+			else if (error.message.includes("Repository not found")) messages.error("Repository not found. Check the URL and try again.");
+			else messages.error("Failed to clone repository:", error);
+			process.exit(1);
+		}
+	} catch (error) {
+		messages.error("Error adding template:", error);
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/services/FileSystemService.ts
+var FileSystemService = class {
+	async pathExists(path$2) {
+		return fs.pathExists(path$2);
+	}
+	async readFile(path$2, encoding = "utf8") {
+		return fs.readFile(path$2, encoding);
+	}
+	async readJson(path$2) {
+		return fs.readJson(path$2);
+	}
+	async writeFile(path$2, content, encoding = "utf8") {
+		return fs.writeFile(path$2, content, encoding);
+	}
+	async ensureDir(path$2) {
+		return fs.ensureDir(path$2);
+	}
+	async copy(src, dest) {
+		return fs.copy(src, dest);
+	}
+	async readdir(path$2) {
+		return fs.readdir(path$2);
+	}
+	async stat(path$2) {
+		return fs.stat(path$2);
+	}
+};
+
+//#endregion
+//#region src/services/BoilerplateService.ts
+var BoilerplateService = class {
+	templatesPath;
+	templateService;
+	scaffoldService;
+	constructor(templatesPath) {
+		this.templatesPath = templatesPath;
+		this.templateService = new TemplateService();
+		const fileSystemService = new FileSystemService();
+		const scaffoldConfigLoader = new ScaffoldConfigLoader(fileSystemService, this.templateService);
+		const variableReplacementService = new VariableReplacementService(fileSystemService, this.templateService);
+		this.scaffoldService = new ScaffoldService(fileSystemService, scaffoldConfigLoader, variableReplacementService, templatesPath);
+	}
+	/**
+	* Scans all scaffold.yaml files and returns available boilerplates
+	*/
+	async listBoilerplates() {
+		const boilerplates = [];
+		const templateDirs = await this.discoverTemplateDirectories();
+		for (const templatePath of templateDirs) {
+			const scaffoldYamlPath = path$1.join(this.templatesPath, templatePath, "scaffold.yaml");
+			if (fs$1.existsSync(scaffoldYamlPath)) try {
+				const scaffoldContent = fs$1.readFileSync(scaffoldYamlPath, "utf8");
+				const scaffoldConfig = yaml$1.load(scaffoldContent);
+				if (scaffoldConfig.boilerplate) for (const boilerplate of scaffoldConfig.boilerplate) {
+					if (!boilerplate.targetFolder) {
+						console.warn(`Skipping boilerplate '${boilerplate.name}' in ${templatePath}: targetFolder is required in scaffold.yaml`);
+						continue;
+					}
+					boilerplates.push({
+						name: boilerplate.name,
+						description: boilerplate.description,
+						instruction: boilerplate.instruction,
+						variables_schema: boilerplate.variables_schema,
+						template_path: templatePath,
+						target_folder: boilerplate.targetFolder,
+						includes: boilerplate.includes
+					});
+				}
+			} catch (error) {
+				console.warn(`Failed to load scaffold.yaml for ${templatePath}:`, error);
+			}
+		}
+		return { boilerplates };
+	}
+	/**
+	* Dynamically discovers template directories by finding all directories
+	* that contain both package.json and scaffold.yaml files
+	*/
+	async discoverTemplateDirectories() {
+		const templateDirs = [];
+		const findTemplates = (dir, baseDir = "") => {
+			if (!fs$1.existsSync(dir)) return;
+			const items = fs$1.readdirSync(dir);
+			const hasPackageJson = items.includes("package.json") || items.includes("package.json.liquid");
+			const hasScaffoldYaml = items.includes("scaffold.yaml");
+			if (hasPackageJson && hasScaffoldYaml) templateDirs.push(baseDir);
+			for (const item of items) {
+				const itemPath = path$1.join(dir, item);
+				if (fs$1.statSync(itemPath).isDirectory() && !item.startsWith(".") && item !== "node_modules") {
+					const newBaseDir = baseDir ? path$1.join(baseDir, item) : item;
+					findTemplates(itemPath, newBaseDir);
+				}
+			}
+		};
+		findTemplates(this.templatesPath);
+		return templateDirs;
+	}
+	/**
+	* Executes a specific boilerplate with provided variables
+	*/
+	async useBoilerplate(request) {
+		const { boilerplateName, variables } = request;
+		const boilerplateList = await this.listBoilerplates();
+		const boilerplate = boilerplateList.boilerplates.find((b) => b.name === boilerplateName);
+		if (!boilerplate) return {
+			success: false,
+			message: `Boilerplate '${boilerplateName}' not found. Available boilerplates: ${boilerplateList.boilerplates.map((b) => b.name).join(", ")}`
+		};
+		const validationResult = this.validateBoilerplateVariables(boilerplate, variables);
+		if (!validationResult.isValid) return {
+			success: false,
+			message: `Validation failed: ${validationResult.errors.join(", ")}`
+		};
+		const packageName = variables.packageName || variables.appName;
+		if (!packageName) return {
+			success: false,
+			message: "Missing required parameter: packageName or appName"
+		};
+		const folderName = packageName.includes("/") ? packageName.split("/")[1] : packageName;
+		try {
+			const result = await this.scaffoldService.useBoilerplate({
+				projectName: folderName,
+				packageName,
+				targetFolder: boilerplate.target_folder,
+				templateFolder: boilerplate.template_path,
+				boilerplateName,
+				variables: {
+					...variables,
+					packageName,
+					appName: folderName,
+					sourceTemplate: boilerplate.template_path
+				}
+			});
+			if (!result.success) return result;
+			this.ensureProjectJsonSourceTemplate(boilerplate.target_folder, folderName, boilerplate.template_path);
+			return {
+				success: result.success,
+				message: result.message,
+				warnings: result.warnings,
+				createdFiles: result.createdFiles,
+				existingFiles: result.existingFiles
+			};
+		} catch (error) {
+			return {
+				success: false,
+				message: `Failed to scaffold boilerplate: ${error instanceof Error ? error.message : String(error)}`
+			};
+		}
+	}
+	/**
+	* Gets a specific boilerplate configuration by name with optional variable rendering
+	*/
+	async getBoilerplate(name, variables) {
+		const boilerplate = (await this.listBoilerplates()).boilerplates.find((b) => b.name === name);
+		if (!boilerplate) return null;
+		if (variables && this.templateService.containsTemplateVariables(boilerplate.instruction)) return {
+			...boilerplate,
+			instruction: this.templateService.renderString(boilerplate.instruction, variables)
+		};
+		return boilerplate;
+	}
+	/**
+	* Processes boilerplate instruction with template service
+	*/
+	processBoilerplateInstruction(instruction, variables) {
+		if (this.templateService.containsTemplateVariables(instruction)) return this.templateService.renderString(instruction, variables);
+		return instruction;
+	}
+	/**
+	* Validates boilerplate variables against schema using Zod
+	*/
+	validateBoilerplateVariables(boilerplate, variables) {
+		const errors = [];
+		try {
+			jsonSchemaToZod(boilerplate.variables_schema).parse(variables);
+			return {
+				isValid: true,
+				errors: []
+			};
+		} catch (error) {
+			if (error instanceof z.ZodError) {
+				const zodErrors = error.errors.map((err) => {
+					return `${err.path.length > 0 ? err.path.join(".") : "root"}: ${err.message}`;
+				});
+				errors.push(...zodErrors);
+			} else errors.push(`Validation error: ${error instanceof Error ? error.message : String(error)}`);
+			return {
+				isValid: false,
+				errors
+			};
+		}
+	}
+	/**
+	* Ensures project.json has sourceTemplate field
+	* If project.json exists, updates it; otherwise creates a new one
+	*/
+	ensureProjectJsonSourceTemplate(targetFolder, projectName, sourceTemplate) {
+		const projectJsonPath = path$1.join(targetFolder, projectName, "project.json");
+		try {
+			let projectJson;
+			if (fs$1.existsSync(projectJsonPath)) {
+				const content = fs$1.readFileSync(projectJsonPath, "utf8");
+				projectJson = JSON.parse(content);
+			} else projectJson = {
+				name: projectName,
+				$schema: "../../node_modules/nx/schemas/project-schema.json",
+				sourceRoot: `${targetFolder}/${projectName}`,
+				projectType: "application"
+			};
+			projectJson.sourceTemplate = sourceTemplate;
+			fs$1.writeFileSync(projectJsonPath, `${JSON.stringify(projectJson, null, 2)}\n`, "utf8");
+		} catch (error) {
+			console.warn(`Failed to update project.json with sourceTemplate: ${error}`);
+		}
+	}
+};
+
+//#endregion
+//#region src/cli/boilerplate.ts
+const templatesDir$1 = TemplatesManager.findTemplatesPathSync();
+/**
+* Boilerplate CLI command
+*/
+const boilerplateCommand = new Command("boilerplate").description("Manage boilerplate templates");
+boilerplateCommand.command("list").description("List all available boilerplate templates").action(async () => {
+	try {
+		const { boilerplates } = await new BoilerplateService(templatesDir$1).listBoilerplates();
+		if (boilerplates.length === 0) {
+			messages.warning("No boilerplate templates found.");
+			return;
+		}
+		logger.header(`\n${icons.package} Available Boilerplate Templates:\n`);
+		for (const bp of boilerplates) {
+			logger.highlight(`  ${bp.name}`);
+			logger.debug(`    ${bp.description}`);
+			logger.debug(`    Target: ${bp.target_folder}`);
+			const required = typeof bp.variables_schema === "object" && bp.variables_schema !== null && "required" in bp.variables_schema ? bp.variables_schema.required : [];
+			if (required && required.length > 0) logger.debug(`    Required: ${required.join(", ")}`);
+			logger.newline();
+		}
+	} catch (error) {
+		messages.error("Error listing boilerplates:", error);
+		process.exit(1);
+	}
+});
+boilerplateCommand.command("create <boilerplateName>").description("Create a new project from a boilerplate template").option("-v, --vars <json>", "JSON string containing variables for the boilerplate").option("--verbose", "Enable verbose logging").action(async (boilerplateName, options) => {
+	try {
+		const boilerplateService = new BoilerplateService(templatesDir$1);
+		let variables = {};
+		if (options.vars) try {
+			variables = JSON.parse(options.vars);
+		} catch (error) {
+			messages.error("Error parsing variables JSON:", error);
+			messages.hint("Example: --vars '{\"appName\": \"my-app\", \"description\": \"My application\"}'");
+			process.exit(1);
+		}
+		const boilerplate = await boilerplateService.getBoilerplate(boilerplateName);
+		if (!boilerplate) {
+			const { boilerplates } = await boilerplateService.listBoilerplates();
+			messages.error(`Boilerplate '${boilerplateName}' not found.`);
+			logger.warning(`Available boilerplates: ${boilerplates.map((b) => b.name).join(", ")}`);
+			process.exit(1);
+		}
+		const required = typeof boilerplate.variables_schema === "object" && boilerplate.variables_schema !== null && "required" in boilerplate.variables_schema ? boilerplate.variables_schema.required : [];
+		const missing = required.filter((key) => !variables[key]);
+		if (missing.length > 0) {
+			messages.error(`Missing required variables: ${missing.join(", ")}`);
+			messages.hint(`Use --vars with a JSON object containing: ${missing.join(", ")}`);
+			const exampleVars = {};
+			for (const key of required) if (key === "appName" || key === "packageName") exampleVars[key] = "my-app";
+			else if (key === "description") exampleVars[key] = "My application description";
+			else exampleVars[key] = `<${key}>`;
+			logger.debug(`Example: scaffold-mcp boilerplate create ${boilerplateName} --vars '${JSON.stringify(exampleVars)}'`);
+			process.exit(1);
+		}
+		if (options.verbose) {
+			logger.info(`${icons.wrench} Boilerplate: ${boilerplateName}`);
+			logger.info(`${icons.chart} Variables: ${JSON.stringify(variables, null, 2)}`);
+		}
+		messages.loading(`Creating project from boilerplate '${boilerplateName}'...`);
+		const result = await boilerplateService.useBoilerplate({
+			boilerplateName,
+			variables
+		});
+		if (result.success) {
+			messages.success("Project created successfully!");
+			logger.info(result.message);
+			if (result.createdFiles && result.createdFiles.length > 0) sections.createdFiles(result.createdFiles);
+			const projectName = variables.appName || variables.packageName;
+			if (projectName) sections.nextSteps([
+				`cd ${boilerplate.target_folder}/${projectName}`,
+				"pnpm install",
+				"pnpm dev"
+			]);
+		} else {
+			messages.error(`Failed to create project: ${result.message}`);
+			process.exit(1);
+		}
+	} catch (error) {
+		messages.error("Error creating project:", error);
+		if (options.verbose) console.error("Stack trace:", error.stack);
+		process.exit(1);
+	}
+});
+boilerplateCommand.command("info <boilerplateName>").description("Show detailed information about a boilerplate template").action(async (boilerplateName) => {
+	try {
+		const bp = await new BoilerplateService(templatesDir$1).getBoilerplate(boilerplateName);
+		if (!bp) {
+			messages.error(`Boilerplate '${boilerplateName}' not found.`);
+			process.exit(1);
+		}
+		logger.header(`\n${icons.package} Boilerplate: ${bp.name}\n`);
+		logger.debug(`Description: ${bp.description}`);
+		logger.debug(`Template Path: ${bp.template_path}`);
+		logger.debug(`Target Folder: ${bp.target_folder}`);
+		logger.header(`\n${icons.config} Variables Schema:`);
+		console.log(JSON.stringify(bp.variables_schema, null, 2));
+		if (bp.includes && bp.includes.length > 0) sections.list(`${icons.folder} Included Files:`, bp.includes);
+	} catch (error) {
+		messages.error("Error getting boilerplate info:", error);
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/cli/init.ts
+/**
+* Init command - initialize templates folder
+*/
+const initCommand = new Command("init").description("Initialize templates folder structure").option("--path <path>", "Path to templates folder", "./templates").action(async (options) => {
+	try {
+		const templatesPath = path.resolve(options.path);
+		logger.info(`${icons.rocket} Initializing templates folder at: ${templatesPath}`);
+		await fs$1.ensureDir(templatesPath);
+		await fs$1.ensureDir(path.join(templatesPath, "boilerplates"));
+		await fs$1.ensureDir(path.join(templatesPath, "scaffolds"));
+		await fs$1.writeFile(path.join(templatesPath, "README.md"), `# Templates
+
+This folder contains boilerplate templates and scaffolding methods for your projects.
+
+## Structure
+
+- \`boilerplates/\` - Full project boilerplate templates
+- \`scaffolds/\` - Feature scaffolding methods for existing projects
+
+## Adding Templates
+
+Use the \`add\` command to add templates from remote repositories:
+
+\`\`\`bash
+scaffold-mcp add --name my-template --url https://github.com/user/template
+\`\`\`
+
+## Creating Custom Templates
+
+### Boilerplate Template Structure
+
+Each boilerplate should have:
+- \`boilerplate.yaml\` - Configuration file
+- Template files with variable placeholders using Liquid syntax (\`{{ variableName }}\`)
+
+### Scaffold Method Structure
+
+Each scaffold method should have:
+- \`scaffold.yaml\` - Configuration file
+- Template files organized by project type
+
+See documentation for more details on template creation.
+`);
+		logger.success(`${icons.check} Templates folder initialized successfully!`);
+		logger.header(`\n${icons.folder} Created structure:`);
+		logger.indent(`${templatesPath}/`);
+		logger.indent(`├── boilerplates/`);
+		logger.indent(`├── scaffolds/`);
+		logger.indent(`└── README.md`);
+		sections.nextSteps([`Add templates using: scaffold-mcp add --name <name> --url <url>`, `Or manually create templates in ${templatesPath}/`]);
+	} catch (error) {
+		logger.error(`${icons.cross} Error initializing templates folder:`, error);
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/prompts/GenerateBoilerplatePrompt.ts
+/**
+* Prompt for generating boilerplates
+*/
+var GenerateBoilerplatePrompt = class GenerateBoilerplatePrompt {
+	static PROMPT_NAME = "generate-boilerplate";
+	/**
+	* Get the prompt definition for MCP
+	*/
+	getDefinition() {
+		return {
+			name: GenerateBoilerplatePrompt.PROMPT_NAME,
+			description: "Generate a new boilerplate template configuration",
+			arguments: [{
+				name: "request",
+				description: "Describe the boilerplate template you want to create",
+				required: false
+			}]
+		};
+	}
+	/**
+	* Get the prompt messages
+	*/
+	getMessages(args) {
+		const userRequest = args?.request || "";
+		return [{
+			role: "user",
+			content: {
+				type: "text",
+				text: `You are helping create a new boilerplate template configuration using the scaffold-mcp MCP tools.
+
+${userRequest ? `User request: ${userRequest}\n` : ""}
+Your task:
+
+1. **Gather Information**: Ask for any missing details:
+   - Framework/technology (e.g., "React Vite", "Express API", "Next.js 15")
+   - Template name (kebab-case, e.g., "react-vite", "nextjs-15")
+   - Boilerplate name (prefixed with "scaffold-", e.g., "scaffold-vite-app")
+   - Target folder (e.g., "apps", "packages")
+   - Project type (app, library, service, etc.)
+   - Required variables (at minimum: appName or packageName)
+   - Files to include in the template
+
+2. **Use MCP Tools** in order:
+   - \`generate-boilerplate\` - Creates the boilerplate configuration
+   - \`generate-boilerplate-file\` - Creates each template file
+   - \`list-boilerplates\` - Verify it appears
+   - \`use-boilerplate\` - Test the boilerplate
+
+Important:
+- Template naming: Use kebab-case (e.g., "react-vite", "express-api")
+- Boilerplate naming: Prefix with "scaffold-" (e.g., "scaffold-vite-app")
+- Target folder: "apps" for applications, "packages" for libraries
+- Include files explicitly - avoid wildcards
+- Template syntax: use {{ variableName }}
+
+**Description Field Guidelines (CRITICAL)**:
+The description should be a comprehensive multi-paragraph overview (3-5 sentences):
+- Paragraph 1: Core technology stack and primary value proposition
+- Paragraph 2: Target use cases and ideal project types
+- Paragraph 3: Key integrations or special features (if applicable)
+
+Example:
+"A modern React SPA template powered by Vite for lightning-fast HMR, featuring TanStack Router for type-safe routing and TanStack Query for server state management.
+Perfect for building data-driven dashboards, admin panels, and interactive web applications requiring client-side routing and real-time data synchronization.
+
+Includes Agiflow Config Management System integration with systematic environment variable naming (VITE_{CATEGORY}_{SUBCATEGORY}_{PROPERTY}) and auto-generated configuration templates for cloud deployment."
+
+**Instruction Field Guidelines (CRITICAL)**:
+The instruction should be a detailed multi-section guide that helps AI understand the codebase:
+
+1. **File purposes** section: List each major file/directory with its purpose
+   Format: "- path/to/file: Description of what this file does"
+
+2. **How to use the scaffolded code** section: Step-by-step workflows
+   Format: Numbered list with specific examples
+   - How to add routes/pages
+   - How to fetch data
+   - How to handle authentication
+   - How to configure environment variables
+
+3. **Design patterns to follow** section: Key architectural decisions
+   Format: "- Pattern Name: Explanation and when to use it"
+   - Routing patterns
+   - State management patterns
+   - Data fetching patterns
+   - Error handling patterns
+   - Performance optimization patterns
+
+Example structure:
+"[Framework] application template with [key technologies].
+
+File purposes:
+- package.json: NPM package configuration with [framework] and dependencies
+- src/main.tsx: Application entry point with [setup details]
+- src/routes/: Route definitions following [pattern]
+[... list all major files ...]
+
+How to use the scaffolded code:
+1. Routes: Create new routes by [specific instructions with example]
+2. Data Fetching: Use [specific pattern] for [use case]
+3. Authentication: Use [specific components/modules] for user management
+[... numbered steps for common tasks ...]
+
+Design patterns to follow:
+- File-based Routing: Use directory structure in src/routes/ to define URL paths
+- Type-safe Routes: Leverage [framework] type inference for params
+- State Management: Use [library] for server state, [library] for client state
+[... list key patterns with explanations ...]"
+
+Template File Content Guidelines:
+- Keep content MINIMAL and business-agnostic
+- Focus on structure and patterns, not business logic
+- Use placeholder/generic examples only
+- Include essential boilerplate code only
+- Let AI fill in specific logic later
+- Add clear headers with design patterns and coding standards`
+			}
+		}];
+	}
+};
+
+//#endregion
+//#region src/prompts/GenerateFeatureScaffoldPrompt.ts
+/**
+* Prompt for generating feature scaffolds
+*/
+var GenerateFeatureScaffoldPrompt = class GenerateFeatureScaffoldPrompt {
+	static PROMPT_NAME = "generate-feature-scaffold";
+	/**
+	* Get the prompt definition for MCP
+	*/
+	getDefinition() {
+		return {
+			name: GenerateFeatureScaffoldPrompt.PROMPT_NAME,
+			description: "Generate a new feature scaffold configuration",
+			arguments: [{
+				name: "request",
+				description: "Describe the feature scaffold you want to create",
+				required: false
+			}]
+		};
+	}
+	/**
+	* Get the prompt messages
+	*/
+	getMessages(args) {
+		const userRequest = args?.request || "";
+		return [{
+			role: "user",
+			content: {
+				type: "text",
+				text: `You are helping create a new feature scaffold configuration using the scaffold-mcp MCP tools.
+
+${userRequest ? `User request: ${userRequest}\n` : ""}
+Your task:
+
+1. **Gather Information**: Ask for any missing details:
+   - Template name (e.g., "nextjs-15", "react-vite")
+   - Feature name (prefixed with "scaffold-", e.g., "scaffold-nextjs-page")
+   - Feature type (page, component, service, etc.)
+   - Variables needed
+   - Files to include
+
+2. **Use MCP Tools** in order:
+   - \`generate-feature-scaffold\` - Creates the feature configuration
+   - \`generate-boilerplate-file\` - Creates each template file
+   - \`list-scaffolding-methods\` - Verify it appears
+   - \`use-scaffold-method\` - Test the feature
+
+Important:
+- Feature names: prefix with "scaffold-"
+- Conditional includes: use "file.tsx?withLayout=true"
+- Template syntax: use {{ variableName }}
+
+**Description Field Guidelines (CRITICAL)**:
+The description should explain what the feature scaffold generates (2-3 sentences):
+- Sentence 1: What type of code it generates (component, page, service, etc.)
+- Sentence 2: Key features or capabilities included
+- Sentence 3: Primary use cases or when to use it
+
+Example:
+"Generate a new service class for TypeScript libraries following best practices. Creates a service class with interface, implementation, and unit tests. Perfect for creating reusable service modules with dependency injection patterns."
+
+**Instruction Field Guidelines (CRITICAL)**:
+The instruction should provide specific guidance for using the generated feature:
+
+1. **Pattern explanation**: Describe the architectural pattern used
+2. **File organization**: Where files should be placed
+3. **Naming conventions**: How to name things (PascalCase, camelCase, etc.)
+4. **Usage guidelines**: How to use the generated code
+5. **Testing approach**: How to test the feature
+
+Example structure:
+"[Feature type] follow a [pattern name] pattern with [key characteristics].
+[Explanation of how it works and integrates with the project].
+Place [files] in [directory].
+For [features with X], define [Y] in [Z] for better separation of concerns.
+[Feature names] should be [case style] and [suffix/prefix rules].
+Write comprehensive [tests/docs] for all [public methods/exports]."
+
+Keep it concise but informative - focus on the patterns and conventions that AI needs to understand to work with the generated code effectively.
+
+Template File Content Guidelines:
+- Keep content MINIMAL and business-agnostic
+- Focus on structure and patterns, not business logic
+- Use placeholder/generic examples only
+- Include essential boilerplate code only
+- Let AI fill in specific logic later
+- Add clear headers with design patterns and coding standards`
+			}
+		}];
+	}
+};
+
+//#endregion
+//#region src/services/BoilerplateGeneratorService.ts
+/**
+* Service for generating boilerplate configurations in scaffold.yaml files
+*/
+var BoilerplateGeneratorService = class {
+	templatesPath;
+	constructor(templatesPath) {
+		this.templatesPath = templatesPath;
+	}
+	/**
+	* Custom YAML dumper that forces literal block style (|) for description and instruction fields
+	*/
+	dumpYamlWithLiteralBlocks(config) {
+		const LiteralBlockType = new yaml$1.Type("tag:yaml.org,2002:str", {
+			kind: "scalar",
+			construct: (data) => data,
+			represent: (data) => {
+				return data;
+			},
+			defaultStyle: "|"
+		});
+		const LITERAL_SCHEMA = yaml$1.DEFAULT_SCHEMA.extend([LiteralBlockType]);
+		const processedConfig = this.processConfigForLiteralBlocks(config);
+		return yaml$1.dump(processedConfig, {
+			schema: LITERAL_SCHEMA,
+			indent: 2,
+			lineWidth: -1,
+			noRefs: true,
+			sortKeys: false,
+			styles: { "!!str": "literal" },
+			replacer: (key, value) => {
+				if ((key === "description" || key === "instruction") && typeof value === "string") return value;
+				return value;
+			}
+		});
+	}
+	/**
+	* Process config to ensure description and instruction use literal block style
+	*/
+	processConfigForLiteralBlocks(config) {
+		const processed = JSON.parse(JSON.stringify(config));
+		if (processed.boilerplate) processed.boilerplate = processed.boilerplate.map((bp) => {
+			const newBp = { ...bp };
+			if (newBp.description && typeof newBp.description === "string") newBp.description = this.ensureMultilineFormat(newBp.description);
+			if (newBp.instruction && typeof newBp.instruction === "string") newBp.instruction = this.ensureMultilineFormat(newBp.instruction);
+			return newBp;
+		});
+		if (processed.features) processed.features = processed.features.map((feature) => {
+			const newFeature = { ...feature };
+			if (newFeature.description && typeof newFeature.description === "string") newFeature.description = this.ensureMultilineFormat(newFeature.description);
+			if (newFeature.instruction && typeof newFeature.instruction === "string") newFeature.instruction = this.ensureMultilineFormat(newFeature.instruction);
+			return newFeature;
+		});
+		return processed;
+	}
+	/**
+	* Ensure string is properly formatted for YAML literal blocks
+	*/
+	ensureMultilineFormat(text) {
+		return text.trim();
+	}
+	/**
+	* Generate or update a boilerplate configuration in scaffold.yaml
+	*/
+	async generateBoilerplate(options) {
+		const { templateName, boilerplateName, description, instruction, targetFolder, variables, includes = [] } = options;
+		const templatePath = path$1.join(this.templatesPath, templateName);
+		await fs$1.ensureDir(templatePath);
+		const scaffoldYamlPath = path$1.join(templatePath, "scaffold.yaml");
+		let scaffoldConfig = {};
+		if (await fs$1.pathExists(scaffoldYamlPath)) {
+			const yamlContent$1 = await fs$1.readFile(scaffoldYamlPath, "utf-8");
+			scaffoldConfig = yaml$1.load(yamlContent$1);
+		}
+		if (!scaffoldConfig.boilerplate) scaffoldConfig.boilerplate = [];
+		if (scaffoldConfig.boilerplate.findIndex((b) => b.name === boilerplateName) !== -1) return {
+			success: false,
+			message: `Boilerplate '${boilerplateName}' already exists in ${scaffoldYamlPath}`
+		};
+		const requiredVars = variables.filter((v) => v.required).map((v) => v.name);
+		const variablesSchema = {
+			type: "object",
+			properties: variables.reduce((acc, v) => {
+				acc[v.name] = {
+					type: v.type,
+					description: v.description
+				};
+				if (v.default !== void 0) acc[v.name].default = v.default;
+				return acc;
+			}, {}),
+			required: requiredVars,
+			additionalProperties: false
+		};
+		const boilerplateDefinition = {
+			name: boilerplateName,
+			targetFolder,
+			description,
+			variables_schema: variablesSchema,
+			includes: includes.length > 0 ? includes : []
+		};
+		if (instruction) boilerplateDefinition.instruction = instruction;
+		scaffoldConfig.boilerplate.push(boilerplateDefinition);
+		const yamlContent = this.dumpYamlWithLiteralBlocks(scaffoldConfig);
+		await fs$1.writeFile(scaffoldYamlPath, yamlContent, "utf-8");
+		return {
+			success: true,
+			message: `Boilerplate '${boilerplateName}' added to ${scaffoldYamlPath}`,
+			templatePath,
+			scaffoldYamlPath
+		};
+	}
+	/**
+	* List all templates (directories in templates folder)
+	*/
+	async listTemplates() {
+		return (await fs$1.readdir(this.templatesPath, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+	}
+	/**
+	* Check if a template exists
+	*/
+	async templateExists(templateName) {
+		const templatePath = path$1.join(this.templatesPath, templateName);
+		return fs$1.pathExists(templatePath);
+	}
+	/**
+	* Create or update a template file for a boilerplate
+	*/
+	async createTemplateFile(options) {
+		const { templateName, filePath, content, sourceFile, header } = options;
+		const templatePath = path$1.join(this.templatesPath, templateName);
+		if (!await fs$1.pathExists(templatePath)) return {
+			success: false,
+			message: `Template directory '${templateName}' does not exist at ${templatePath}`
+		};
+		let fileContent = content || "";
+		if (sourceFile) {
+			if (!await fs$1.pathExists(sourceFile)) return {
+				success: false,
+				message: `Source file '${sourceFile}' does not exist`
+			};
+			fileContent = await fs$1.readFile(sourceFile, "utf-8");
+		}
+		if (!fileContent && !sourceFile) return {
+			success: false,
+			message: "Either content or sourceFile must be provided"
+		};
+		const templateFilePath = filePath.endsWith(".liquid") ? filePath : `${filePath}.liquid`;
+		const fullPath = path$1.join(templatePath, templateFilePath);
+		await fs$1.ensureDir(path$1.dirname(fullPath));
+		let finalContent = fileContent;
+		if (header) finalContent = `${header}\n\n${fileContent}`;
+		await fs$1.writeFile(fullPath, finalContent, "utf-8");
+		return {
+			success: true,
+			message: "Template file created successfully",
+			filePath: templateFilePath,
+			fullPath
+		};
+	}
+};
+
+//#endregion
+//#region src/tools/GenerateBoilerplateFileTool.ts
+/**
+* Tool to generate template files for boilerplates and features
+*/
+var GenerateBoilerplateFileTool = class GenerateBoilerplateFileTool {
+	static TOOL_NAME = "generate-boilerplate-file";
+	boilerplateGeneratorService;
+	constructor(templatesPath) {
+		this.boilerplateGeneratorService = new BoilerplateGeneratorService(templatesPath);
+	}
+	/**
+	* Get the tool definition for MCP
+	*/
+	getDefinition() {
+		return {
+			name: GenerateBoilerplateFileTool.TOOL_NAME,
+			description: `Create or update template files for boilerplates or features in the specified template directory.
+
+This tool:
+- Creates template files with .liquid extension for variable substitution
+- Supports creating nested directory structures
+- Can create files from source files (copying and converting to templates)
+- Validates that the template directory exists
+- Works for both boilerplate includes and feature scaffold includes
+
+Use this after generate-boilerplate or generate-feature-scaffold to create the actual template files referenced in the includes array.`,
+			inputSchema: {
+				type: "object",
+				properties: {
+					templateName: {
+						type: "string",
+						description: "Name of the template folder (must already exist)"
+					},
+					filePath: {
+						type: "string",
+						description: "Path of the file to create within the template (e.g., \"package.json\", \"src/app/page.tsx\")"
+					},
+					content: {
+						type: "string",
+						description: `Content of the template file (use {{ variableName }} for Liquid placeholders).
+
+IMPORTANT - Keep content minimal and business-agnostic:
+- Focus on structure and patterns, not specific business logic
+- Use placeholder data and generic examples
+- Include only essential boilerplate code
+- Demonstrate the pattern, not a complete implementation
+- Let AI fill in business-specific logic later
+
+Example (good - minimal):
+export function {{ functionName }}() {
+  // TODO: Implement logic
+  return null;
+}
+
+Example (bad - too specific):
+export function calculateTax(income: number) {
+  const federalRate = 0.22;
+  const stateRate = 0.05;
+  return income * (federalRate + stateRate);
+}`
+					},
+					sourceFile: {
+						type: "string",
+						description: "Optional: Path to a source file to copy and convert to a template"
+					},
+					header: {
+						type: "string",
+						description: `Optional: Header comment to add at the top of the file to provide AI hints about design patterns, coding standards, and best practices.
+
+Example format for TypeScript/JavaScript files:
+/**
+ * {{ componentName }} Component
+ *
+ * DESIGN PATTERNS:
+ * - Component pattern description
+ * - Architecture decisions
+ *
+ * CODING STANDARDS:
+ * - Naming conventions
+ * - Required elements
+ *
+ * AVOID:
+ * - Common pitfalls
+ * - Anti-patterns
+ */
+
+The header helps AI understand and follow established patterns when working with generated code.`
+					}
+				},
+				required: ["templateName", "filePath"],
+				additionalProperties: false
+			}
+		};
+	}
+	/**
+	* Execute the tool
+	*/
+	async execute(args) {
+		try {
+			const result = await this.boilerplateGeneratorService.createTemplateFile(args);
+			if (!result.success) return {
+				content: [{
+					type: "text",
+					text: result.message
+				}],
+				isError: true
+			};
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					message: result.message,
+					filePath: result.filePath,
+					fullPath: result.fullPath,
+					sourceFile: args.sourceFile || null
+				}, null, 2)
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error creating template file: ${error instanceof Error ? error.message : String(error)}`
+				}],
+				isError: true
+			};
+		}
+	}
+};
+
+//#endregion
+//#region src/tools/GenerateBoilerplateTool.ts
+/**
+* Tool to generate a new boilerplate configuration in scaffold.yaml
+*/
+var GenerateBoilerplateTool = class GenerateBoilerplateTool {
+	static TOOL_NAME = "generate-boilerplate";
+	boilerplateGeneratorService;
+	constructor(templatesPath) {
+		this.boilerplateGeneratorService = new BoilerplateGeneratorService(templatesPath);
+	}
+	/**
+	* Get the tool definition for MCP
+	*/
+	getDefinition() {
+		return {
+			name: GenerateBoilerplateTool.TOOL_NAME,
+			description: `Add a new boilerplate configuration to a template's scaffold.yaml file.
+
+This tool:
+- Creates or updates scaffold.yaml in the specified template directory
+- Adds a boilerplate entry with proper schema following the nextjs-15 pattern
+- Validates the boilerplate name doesn't already exist
+- Creates the template directory if it doesn't exist
+
+Use this to add custom boilerplate configurations for frameworks not yet supported or for your specific project needs.`,
+			inputSchema: {
+				type: "object",
+				properties: {
+					templateName: {
+						type: "string",
+						description: "Name of the template folder (kebab-case, e.g., \"my-framework\")"
+					},
+					boilerplateName: {
+						type: "string",
+						description: "Name of the boilerplate (kebab-case, e.g., \"scaffold-my-app\")"
+					},
+					targetFolder: {
+						type: "string",
+						description: "Target folder where projects will be created (e.g., \"apps\", \"packages\")"
+					},
+					description: {
+						type: "string",
+						description: `Detailed description of what this boilerplate creates and its key features.
+
+STRUCTURE (3-5 sentences in multiple paragraphs):
+- Paragraph 1: Core technology stack and primary value proposition
+- Paragraph 2: Target use cases and ideal project types
+- Paragraph 3: Key integrations or special features (if applicable)
+
+Example: "A modern React SPA template powered by Vite for lightning-fast HMR, featuring TanStack Router for type-safe routing and TanStack Query for server state management.
+Perfect for building data-driven dashboards, admin panels, and interactive web applications requiring client-side routing and real-time data synchronization.
+
+Includes Agiflow Config Management System integration with systematic environment variable naming (VITE_{CATEGORY}_{SUBCATEGORY}_{PROPERTY}) and auto-generated configuration templates for cloud deployment."`
+					},
+					instruction: {
+						type: "string",
+						description: `Optional detailed instructions about the generated files, their purposes, and how to work with them.
+
+STRUCTURE (Multi-section guide):
+
+1. **File purposes** section:
+   List each major file/directory with its purpose
+   Format: "- path/to/file: Description of what this file does"
+
+2. **How to use the scaffolded code** section:
+   Step-by-step workflows for common tasks
+   Format: Numbered list with specific examples
+   - How to add routes/pages
+   - How to fetch data
+   - How to handle authentication
+   - How to configure environment variables
+
+3. **Design patterns to follow** section:
+   Key architectural decisions and conventions
+   Format: "- Pattern Name: Explanation and when to use it"
+   - Routing patterns
+   - State management patterns
+   - Data fetching patterns
+   - Error handling patterns
+   - Performance optimization patterns
+
+Example: "[Framework] application template with [key technologies].
+
+File purposes:
+- package.json: NPM package configuration with [framework] and dependencies
+- src/main.tsx: Application entry point with [setup details]
+- src/routes/: Route definitions following [pattern]
+[... list all major files ...]
+
+How to use the scaffolded code:
+1. Routes: Create new routes by [specific instructions with example]
+2. Data Fetching: Use [specific pattern] for [use case]
+3. Authentication: Use [specific components/modules] for user management
+[... numbered steps for common tasks ...]
+
+Design patterns to follow:
+- File-based Routing: Use directory structure in src/routes/ to define URL paths
+- Type-safe Routes: Leverage [framework] type inference for params
+- State Management: Use [library] for server state, [library] for client state
+[... list key patterns with explanations ...]"`
+					},
+					variables: {
+						type: "array",
+						description: "Array of variable definitions for the boilerplate",
+						items: {
+							type: "object",
+							properties: {
+								name: {
+									type: "string",
+									description: "Variable name (camelCase)"
+								},
+								description: {
+									type: "string",
+									description: "Variable description"
+								},
+								type: {
+									type: "string",
+									enum: [
+										"string",
+										"number",
+										"boolean"
+									],
+									description: "Variable type"
+								},
+								required: {
+									type: "boolean",
+									description: "Whether this variable is required"
+								},
+								default: { description: "Optional default value for the variable" }
+							},
+							required: [
+								"name",
+								"description",
+								"type",
+								"required"
+							]
+						}
+					},
+					includes: {
+						type: "array",
+						description: `Array of specific file paths to include in the boilerplate (highly recommended to list explicitly).
+
+Examples:
+- ["package.json", "tsconfig.json", "src/index.ts"] - Explicit file list (recommended)
+- ["**/*"] - Include all files (not recommended, too broad)
+
+Best practices:
+- List each file explicitly for clarity and control
+- Use relative paths from the template root
+- Include configuration files (package.json, tsconfig.json, etc.)
+- Include source files (src/index.ts, src/app/page.tsx, etc.)
+- Avoid wildcards unless you have a good reason
+
+See templates/nextjs-15/scaffold.yaml for a good example of explicit file listing.`,
+						items: { type: "string" }
+					}
+				},
+				required: [
+					"templateName",
+					"boilerplateName",
+					"description",
+					"targetFolder",
+					"variables"
+				],
+				additionalProperties: false
+			}
+		};
+	}
+	/**
+	* Execute the tool
+	*/
+	async execute(args) {
+		try {
+			const result = await this.boilerplateGeneratorService.generateBoilerplate(args);
+			if (!result.success) return {
+				content: [{
+					type: "text",
+					text: result.message
+				}],
+				isError: true
+			};
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					message: result.message,
+					templatePath: result.templatePath,
+					scaffoldYamlPath: result.scaffoldYamlPath,
+					nextSteps: [
+						"Use generate-boilerplate-file tool to create template files for the includes array",
+						"Customize the template files with Liquid variable placeholders ({{ variableName }})",
+						`Test with: scaffold-mcp boilerplate create ${args.boilerplateName} --vars '{"appName":"test"}'`
+					]
+				}, null, 2)
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error generating boilerplate: ${error instanceof Error ? error.message : String(error)}`
+				}],
+				isError: true
+			};
+		}
+	}
+};
+
+//#endregion
+//#region src/services/ScaffoldGeneratorService.ts
+/**
+* Service for generating feature scaffold configurations in scaffold.yaml files
+*/
+var ScaffoldGeneratorService = class {
+	templatesPath;
+	constructor(templatesPath) {
+		this.templatesPath = templatesPath;
+	}
+	/**
+	* Custom YAML dumper that forces literal block style (|) for description and instruction fields
+	*/
+	dumpYamlWithLiteralBlocks(config) {
+		const LiteralBlockType = new yaml$1.Type("tag:yaml.org,2002:str", {
+			kind: "scalar",
+			construct: (data) => data,
+			represent: (data) => {
+				return data;
+			},
+			defaultStyle: "|"
+		});
+		const LITERAL_SCHEMA = yaml$1.DEFAULT_SCHEMA.extend([LiteralBlockType]);
+		const processedConfig = this.processConfigForLiteralBlocks(config);
+		return yaml$1.dump(processedConfig, {
+			schema: LITERAL_SCHEMA,
+			indent: 2,
+			lineWidth: -1,
+			noRefs: true,
+			sortKeys: false,
+			styles: { "!!str": "literal" },
+			replacer: (key, value) => {
+				if ((key === "description" || key === "instruction") && typeof value === "string") return value;
+				return value;
+			}
+		});
+	}
+	/**
+	* Process config to ensure description and instruction use literal block style
+	*/
+	processConfigForLiteralBlocks(config) {
+		const processed = JSON.parse(JSON.stringify(config));
+		if (processed.boilerplate) processed.boilerplate = processed.boilerplate.map((bp) => {
+			const newBp = { ...bp };
+			if (newBp.description && typeof newBp.description === "string") newBp.description = this.ensureMultilineFormat(newBp.description);
+			if (newBp.instruction && typeof newBp.instruction === "string") newBp.instruction = this.ensureMultilineFormat(newBp.instruction);
+			return newBp;
+		});
+		if (processed.features) processed.features = processed.features.map((feature) => {
+			const newFeature = { ...feature };
+			if (newFeature.description && typeof newFeature.description === "string") newFeature.description = this.ensureMultilineFormat(newFeature.description);
+			if (newFeature.instruction && typeof newFeature.instruction === "string") newFeature.instruction = this.ensureMultilineFormat(newFeature.instruction);
+			return newFeature;
+		});
+		return processed;
+	}
+	/**
+	* Ensure string is properly formatted for YAML literal blocks
+	*/
+	ensureMultilineFormat(text) {
+		return text.trim();
+	}
+	/**
+	* Generate or update a feature configuration in scaffold.yaml
+	*/
+	async generateFeatureScaffold(options) {
+		const { templateName, featureName, description, instruction, variables, includes = [], patterns = [] } = options;
+		const templatePath = path$1.join(this.templatesPath, templateName);
+		await fs$1.ensureDir(templatePath);
+		const scaffoldYamlPath = path$1.join(templatePath, "scaffold.yaml");
+		let scaffoldConfig = {};
+		if (await fs$1.pathExists(scaffoldYamlPath)) {
+			const yamlContent$1 = await fs$1.readFile(scaffoldYamlPath, "utf-8");
+			scaffoldConfig = yaml$1.load(yamlContent$1);
+		}
+		if (!scaffoldConfig.features) scaffoldConfig.features = [];
+		if (scaffoldConfig.features.findIndex((f) => f.name === featureName) !== -1) return {
+			success: false,
+			message: `Feature '${featureName}' already exists in ${scaffoldYamlPath}`
+		};
+		const requiredVars = variables.filter((v) => v.required).map((v) => v.name);
+		const variablesSchema = {
+			type: "object",
+			properties: variables.reduce((acc, v) => {
+				acc[v.name] = {
+					type: v.type,
+					description: v.description
+				};
+				if (v.default !== void 0) acc[v.name].default = v.default;
+				return acc;
+			}, {}),
+			required: requiredVars,
+			additionalProperties: false
+		};
+		const featureDefinition = {
+			name: featureName,
+			description,
+			variables_schema: variablesSchema,
+			includes: includes.length > 0 ? includes : []
+		};
+		if (instruction) featureDefinition.instruction = instruction;
+		if (patterns && patterns.length > 0) featureDefinition.patterns = patterns;
+		scaffoldConfig.features.push(featureDefinition);
+		const yamlContent = this.dumpYamlWithLiteralBlocks(scaffoldConfig);
+		await fs$1.writeFile(scaffoldYamlPath, yamlContent, "utf-8");
+		return {
+			success: true,
+			message: `Feature '${featureName}' added to ${scaffoldYamlPath}`,
+			templatePath,
+			scaffoldYamlPath
+		};
+	}
+	/**
+	* List all templates (directories in templates folder)
+	*/
+	async listTemplates() {
+		return (await fs$1.readdir(this.templatesPath, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+	}
+	/**
+	* Check if a template exists
+	*/
+	async templateExists(templateName) {
+		const templatePath = path$1.join(this.templatesPath, templateName);
+		return fs$1.pathExists(templatePath);
+	}
+};
+
+//#endregion
+//#region src/tools/GenerateFeatureScaffoldTool.ts
+/**
+* Tool to generate a new feature scaffold configuration in scaffold.yaml
+*/
+var GenerateFeatureScaffoldTool = class GenerateFeatureScaffoldTool {
+	static TOOL_NAME = "generate-feature-scaffold";
+	scaffoldGeneratorService;
+	constructor(templatesPath) {
+		this.scaffoldGeneratorService = new ScaffoldGeneratorService(templatesPath);
+	}
+	/**
+	* Get the tool definition for MCP
+	*/
+	getDefinition() {
+		return {
+			name: GenerateFeatureScaffoldTool.TOOL_NAME,
+			description: `Add a new feature scaffold configuration to a template's scaffold.yaml file.
+
+This tool:
+- Creates or updates scaffold.yaml in the specified template directory
+- Adds a feature entry with proper schema following the nextjs-15 pattern
+- Validates the feature name doesn't already exist
+- Creates the template directory if it doesn't exist
+
+Use this to add custom feature scaffolds (pages, components, services, etc.) for frameworks not yet supported or for your specific project needs.`,
+			inputSchema: {
+				type: "object",
+				properties: {
+					templateName: {
+						type: "string",
+						description: "Name of the template folder (kebab-case, e.g., \"nextjs-15\")"
+					},
+					featureName: {
+						type: "string",
+						description: "Name of the feature (kebab-case, e.g., \"scaffold-nextjs-page\")"
+					},
+					description: {
+						type: "string",
+						description: `Detailed description of what this feature creates and its key capabilities.
+
+STRUCTURE (2-3 sentences):
+- Sentence 1: What type of code it generates (component, page, service, etc.)
+- Sentence 2: Key features or capabilities included
+- Sentence 3: Primary use cases or when to use it
+
+Example: "Generate a new service class for TypeScript libraries following best practices. Creates a service class with interface, implementation, and unit tests. Perfect for creating reusable service modules with dependency injection patterns."`
+					},
+					instruction: {
+						type: "string",
+						description: `Optional detailed instructions about the generated files, their purposes, and how to work with them.
+
+STRUCTURE (Concise multi-aspect guide):
+
+1. **Pattern explanation**: Describe the architectural pattern used
+2. **File organization**: Where files should be placed
+3. **Naming conventions**: How to name things (PascalCase, camelCase, etc.)
+4. **Usage guidelines**: How to use the generated code
+5. **Testing approach**: How to test the feature
+
+Example: "Services follow a class-based pattern with optional interface separation. The service class implements business logic and can be dependency injected. Place services in src/services/ directory. For services with interfaces, define the interface in src/types/interfaces/ for better separation of concerns. Service names should be PascalCase and end with 'Service' suffix. Write comprehensive unit tests for all public methods."`
+					},
+					variables: {
+						type: "array",
+						description: "Array of variable definitions for the feature",
+						items: {
+							type: "object",
+							properties: {
+								name: {
+									type: "string",
+									description: "Variable name (camelCase)"
+								},
+								description: {
+									type: "string",
+									description: "Variable description"
+								},
+								type: {
+									type: "string",
+									enum: [
+										"string",
+										"number",
+										"boolean"
+									],
+									description: "Variable type"
+								},
+								required: {
+									type: "boolean",
+									description: "Whether this variable is required"
+								},
+								default: { description: "Optional default value for the variable" }
+							},
+							required: [
+								"name",
+								"description",
+								"type",
+								"required"
+							]
+						}
+					},
+					includes: {
+						type: "array",
+						description: `Array of specific file paths to include in the feature (highly recommended to list explicitly).
+
+Supports advanced syntax:
+- Basic: "src/app/page/page.tsx" - Always included
+- Conditional: "src/app/page/layout.tsx?withLayout=true" - Only included when withLayout variable is true
+- Multiple conditions: "file.tsx?withLayout=true&withTests=true" - Use & to combine conditions
+- Path mapping: "source.tsx->target/path.tsx" - Map source template file to different target path
+- Combined: "source.tsx->{{ pagePath }}/page.tsx?withPage=true" - Combine path mapping with variables and conditions
+
+Examples:
+- ["src/components/Button.tsx", "src/components/Button.test.tsx"] - Explicit file list (recommended)
+- ["src/app/page/page.tsx", "src/app/page/layout.tsx?withLayout=true"] - Conditional include
+- ["template.tsx->src/app/{{ pagePath }}/page.tsx"] - Dynamic path with variables
+
+Best practices:
+- List each file explicitly for clarity and control
+- Use relative paths from the template root
+- Use conditional includes with ?variableName=value for optional files
+- Use path mapping with -> when source and target paths differ
+- Use {{ variableName }} in target paths for dynamic file placement
+- Avoid wildcards unless you have a good reason
+
+See templates/nextjs-15/scaffold.yaml features section for examples.`,
+						items: { type: "string" }
+					},
+					patterns: {
+						type: "array",
+						description: `Optional array of glob patterns to match existing files that this feature works with.
+
+Used to help identify where this feature can be applied in a project.
+
+Examples:
+- ["src/app/**/page.tsx", "src/app/**/layout.tsx"] - Next.js app router files
+- ["src/components/**/*.tsx"] - React component files
+- ["src/services/**/*.ts"] - Service files
+
+Best practices:
+- Use glob patterns that match the file types this feature works with
+- Keep patterns specific enough to be meaningful but broad enough to be useful
+- Consider both the feature's output and input files`,
+						items: { type: "string" }
+					}
+				},
+				required: [
+					"templateName",
+					"featureName",
+					"description",
+					"variables"
+				],
+				additionalProperties: false
+			}
+		};
+	}
+	/**
+	* Execute the tool
+	*/
+	async execute(args) {
+		try {
+			const result = await this.scaffoldGeneratorService.generateFeatureScaffold(args);
+			if (!result.success) return {
+				content: [{
+					type: "text",
+					text: result.message
+				}],
+				isError: true
+			};
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					message: result.message,
+					templatePath: result.templatePath,
+					scaffoldYamlPath: result.scaffoldYamlPath,
+					nextSteps: [
+						"Use generate-boilerplate-file tool to create template files for the includes array",
+						"Customize the template files with Liquid variable placeholders ({{ variableName }})",
+						"Create the generator file if it uses custom logic (referenced in the generator field)",
+						`Test with: scaffold-mcp feature create ${args.featureName} --vars '{"appName":"test"}'`
+					]
+				}, null, 2)
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error generating feature scaffold: ${error instanceof Error ? error.message : String(error)}`
+				}],
+				isError: true
+			};
+		}
+	}
+};
+
+//#endregion
+//#region src/tools/ListBoilerplatesTool.ts
+var ListBoilerplatesTool = class ListBoilerplatesTool {
+	static TOOL_NAME = "list-boilerplates";
+	boilerplateService;
+	constructor(templatesPath) {
+		this.boilerplateService = new BoilerplateService(templatesPath);
+	}
+	/**
+	* Get the tool definition for MCP
+	*/
+	getDefinition() {
+		return {
+			name: ListBoilerplatesTool.TOOL_NAME,
+			description: `Lists all available project boilerplates for creating new applications, APIs, or packages in the monorepo.
+
+Each boilerplate includes:
+- Complete project template with starter files
+- Variable schema for customization
+- Target directory information
+- Required and optional configuration options
+
+Use this FIRST when creating new projects to understand available templates and their requirements.`,
+			inputSchema: {
+				type: "object",
+				properties: {},
+				additionalProperties: false
+			}
+		};
+	}
+	/**
+	* Execute the tool
+	*/
+	async execute(_args = {}) {
+		try {
+			const result = await this.boilerplateService.listBoilerplates();
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error listing boilerplates: ${error instanceof Error ? error.message : String(error)}`
+				}],
+				isError: true
+			};
+		}
+	}
+};
+
+//#endregion
+//#region src/services/ScaffoldingMethodsService.ts
+var ScaffoldingMethodsService = class {
+	templateService;
+	constructor(fileSystem, templatesRootPath) {
+		this.fileSystem = fileSystem;
+		this.templatesRootPath = templatesRootPath;
+		this.templateService = new TemplateService();
+	}
+	async listScaffoldingMethods(projectPath) {
+		const absoluteProjectPath = path.resolve(projectPath);
+		const projectJsonPath = path.join(absoluteProjectPath, "project.json");
+		if (!await this.fileSystem.pathExists(projectJsonPath)) throw new Error(`project.json not found at ${projectJsonPath}`);
+		const projectConfig = await this.fileSystem.readJson(projectJsonPath);
+		if (!projectConfig.sourceTemplate) throw new Error(`sourceTemplate not specified in project.json at ${projectJsonPath}`);
+		const sourceTemplate = projectConfig.sourceTemplate;
+		const templatePath = await this.findTemplatePath(sourceTemplate);
+		if (!templatePath) throw new Error(`Template not found for sourceTemplate: ${sourceTemplate}`);
+		const fullTemplatePath = path.join(this.templatesRootPath, templatePath);
+		const scaffoldYamlPath = path.join(fullTemplatePath, "scaffold.yaml");
+		if (!await this.fileSystem.pathExists(scaffoldYamlPath)) throw new Error(`scaffold.yaml not found at ${scaffoldYamlPath}`);
+		const scaffoldContent = await this.fileSystem.readFile(scaffoldYamlPath, "utf8");
+		const architectConfig = yaml.load(scaffoldContent);
+		const methods = [];
+		if (architectConfig.features && Array.isArray(architectConfig.features)) architectConfig.features.forEach((feature) => {
+			if (feature.name) methods.push({
+				name: feature.name,
+				description: feature.description || "",
+				instruction: feature.instruction || "",
+				variables_schema: feature.variables_schema || {
+					type: "object",
+					properties: {},
+					required: [],
+					additionalProperties: false
+				},
+				generator: feature.generator
+			});
+		});
+		return {
+			sourceTemplate,
+			templatePath,
+			methods
+		};
+	}
+	/**
+	* Gets scaffolding methods with instructions rendered using provided variables
+	*/
+	async listScaffoldingMethodsWithVariables(projectPath, variables) {
+		const result = await this.listScaffoldingMethods(projectPath);
+		const processedMethods = result.methods.map((method) => ({
+			...method,
+			instruction: method.instruction ? this.processScaffoldInstruction(method.instruction, variables) : void 0
+		}));
+		return {
+			...result,
+			methods: processedMethods
+		};
+	}
+	/**
+	* Processes scaffold instruction with template service
+	*/
+	processScaffoldInstruction(instruction, variables) {
+		if (this.templateService.containsTemplateVariables(instruction)) return this.templateService.renderString(instruction, variables);
+		return instruction;
+	}
+	async findTemplatePath(sourceTemplate) {
+		const templateDirs = await this.discoverTemplateDirs();
+		if (templateDirs.includes(sourceTemplate)) return sourceTemplate;
+		for (const templateDir of templateDirs) {
+			const templatePath = path.join(this.templatesRootPath, templateDir);
+			const scaffoldYamlPath = path.join(templatePath, "scaffold.yaml");
+			if (await this.fileSystem.pathExists(scaffoldYamlPath)) try {
+				const scaffoldContent = await this.fileSystem.readFile(scaffoldYamlPath, "utf8");
+				const architectConfig = yaml.load(scaffoldContent);
+				if (architectConfig.boilerplate && Array.isArray(architectConfig.boilerplate)) {
+					for (const boilerplate of architectConfig.boilerplate) if (boilerplate.name?.includes(sourceTemplate)) return templateDir;
+				}
+			} catch (error) {
+				console.warn(`Failed to read scaffold.yaml at ${scaffoldYamlPath}:`, error);
+			}
+		}
+		return null;
+	}
+	/**
+	* Dynamically discovers all template directories
+	* Supports both flat structure (templates/nextjs-15) and nested structure (templates/apps/nextjs-15)
+	**/
+	async discoverTemplateDirs() {
+		const templateDirs = [];
+		try {
+			const items = await this.fileSystem.readdir(this.templatesRootPath);
+			for (const item of items) {
+				const itemPath = path.join(this.templatesRootPath, item);
+				if (!(await this.fileSystem.stat(itemPath)).isDirectory()) continue;
+				const scaffoldYamlPath = path.join(itemPath, "scaffold.yaml");
+				if (await this.fileSystem.pathExists(scaffoldYamlPath)) {
+					templateDirs.push(item);
+					continue;
+				}
+				try {
+					const subItems = await this.fileSystem.readdir(itemPath);
+					for (const subItem of subItems) {
+						const subItemPath = path.join(itemPath, subItem);
+						if (!(await this.fileSystem.stat(subItemPath)).isDirectory()) continue;
+						const subScaffoldYamlPath = path.join(subItemPath, "scaffold.yaml");
+						if (await this.fileSystem.pathExists(subScaffoldYamlPath)) {
+							const relativePath = path.join(item, subItem);
+							templateDirs.push(relativePath);
+						}
+					}
+				} catch (error) {
+					console.warn(`Failed to read subdirectories in ${itemPath}:`, error);
+				}
+			}
+		} catch (error) {
+			console.warn(`Failed to read templates root directory ${this.templatesRootPath}:`, error);
+		}
+		return templateDirs;
+	}
+	async useScaffoldMethod(request) {
+		const { projectPath, scaffold_feature_name, variables } = request;
+		const scaffoldingMethods = await this.listScaffoldingMethods(projectPath);
+		const method = scaffoldingMethods.methods.find((m) => m.name === scaffold_feature_name);
+		if (!method) {
+			const availableMethods = scaffoldingMethods.methods.map((m) => m.name).join(", ");
+			throw new Error(`Scaffold method '${scaffold_feature_name}' not found. Available methods: ${availableMethods}`);
+		}
+		const ScaffoldService$1 = (await import("./ScaffoldService-CDhYAUrp.js")).ScaffoldService;
+		const ScaffoldConfigLoader$1 = (await import("./ScaffoldConfigLoader-DhthV6xq.js")).ScaffoldConfigLoader;
+		const VariableReplacementService$1 = (await import("./VariableReplacementService-CrxFJrqU.js")).VariableReplacementService;
+		const TemplateService$1 = (await import("./TemplateService-PmTU3_On.js")).TemplateService;
+		const templateService = new TemplateService$1();
+		const scaffoldConfigLoader = new ScaffoldConfigLoader$1(this.fileSystem, templateService);
+		const variableReplacer = new VariableReplacementService$1(this.fileSystem, templateService);
+		const scaffoldService = new ScaffoldService$1(this.fileSystem, scaffoldConfigLoader, variableReplacer, this.templatesRootPath);
+		const absoluteProjectPath = path.resolve(projectPath);
+		const projectName = path.basename(absoluteProjectPath);
+		const result = await scaffoldService.useFeature({
+			projectPath: absoluteProjectPath,
+			templateFolder: scaffoldingMethods.templatePath,
+			featureName: scaffold_feature_name,
+			variables: {
+				...variables,
+				appPath: absoluteProjectPath,
+				appName: projectName
+			}
+		});
+		if (!result.success) throw new Error(result.message);
+		return {
+			success: true,
+			message: `
+Successfully scaffolded ${scaffold_feature_name} in ${projectPath}.
+Please follow this **instruction**: \n ${method.instruction}.
+-> Create or update the plan based on the instruction.
+`,
+			warnings: result.warnings,
+			createdFiles: result.createdFiles,
+			existingFiles: result.existingFiles
+		};
+	}
+};
+
+//#endregion
+//#region src/tools/ListScaffoldingMethodsTool.ts
+var ListScaffoldingMethodsTool = class ListScaffoldingMethodsTool {
+	static TOOL_NAME = "list-scaffolding-methods";
+	fileSystemService;
+	scaffoldingMethodsService;
+	constructor(templatesPath) {
+		this.fileSystemService = new FileSystemService();
+		this.scaffoldingMethodsService = new ScaffoldingMethodsService(this.fileSystemService, templatesPath);
+	}
+	/**
+	* Get the tool definition for MCP
+	*/
+	getDefinition() {
+		return {
+			name: ListScaffoldingMethodsTool.TOOL_NAME,
+			description: `Lists all available scaffolding methods (features) that can be added to an existing project.
+
+This tool:
+- Reads the project's sourceTemplate from project.json
+- Returns available features for that template type
+- Provides variable schemas for each scaffolding method
+- Shows descriptions of what each method creates
+
+Use this FIRST when adding features to existing projects to understand:
+- What scaffolding methods are available
+- What variables each method requires
+- What files/features will be generated
+
+Example methods might include:
+- Adding new React routes (for React apps)
+- Creating API endpoints (for backend projects)
+- Adding new components (for frontend projects)
+- Setting up database models (for API projects)`,
+			inputSchema: {
+				type: "object",
+				properties: { projectPath: {
+					type: "string",
+					description: "Absolute path to the project directory containing project.json (e.g., \"apps/my-app\", \"backend/apis/my-api\", \"packages/my-package\")"
+				} },
+				required: ["projectPath"],
+				additionalProperties: false
+			}
+		};
+	}
+	/**
+	* Execute the tool
+	*/
+	async execute(args) {
+		try {
+			const { projectPath } = args;
+			if (!projectPath) throw new Error("Missing required parameter: projectPath");
+			const result = await this.scaffoldingMethodsService.listScaffoldingMethods(projectPath);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error listing scaffolding methods: ${error instanceof Error ? error.message : String(error)}`
+				}],
+				isError: true
+			};
+		}
+	}
+};
+
+//#endregion
+//#region src/tools/UseBoilerplateTool.ts
+var UseBoilerplateTool = class UseBoilerplateTool {
+	static TOOL_NAME = "use-boilerplate";
+	boilerplateService;
+	constructor(templatesPath) {
+		this.boilerplateService = new BoilerplateService(templatesPath);
+	}
+	/**
+	* Get the tool definition for MCP
+	*/
+	getDefinition() {
+		return {
+			name: UseBoilerplateTool.TOOL_NAME,
+			description: `Creates a new project from a boilerplate template with the specified variables.
+
+This tool will:
+- Generate all necessary files from the template
+- Replace template variables with provided values
+- Create the project in the appropriate monorepo directory
+- Set up initial configuration files (package.json, tsconfig.json, etc.)
+
+IMPORTANT:
+- Always call \`list-boilerplates\` first to get the exact variable schema
+- Follow the schema exactly - required fields must be provided
+- Use kebab-case for project names (e.g., "my-new-app", not "MyNewApp")
+- The tool will validate all variables against the schema before proceeding`,
+			inputSchema: {
+				type: "object",
+				properties: {
+					boilerplateName: {
+						type: "string",
+						description: "Exact name of the boilerplate to use (from list-boilerplates response)"
+					},
+					variables: {
+						type: "object",
+						description: "Variables object matching the boilerplate's variables_schema exactly"
+					}
+				},
+				required: ["boilerplateName", "variables"],
+				additionalProperties: false
+			}
+		};
+	}
+	/**
+	* Execute the tool
+	*/
+	async execute(args) {
+		try {
+			const { boilerplateName, variables } = args;
+			if (!boilerplateName) throw new Error("Missing required parameter: boilerplateName");
+			if (!variables) throw new Error("Missing required parameter: variables");
+			const request = {
+				boilerplateName,
+				variables
+			};
+			return { content: [{
+				type: "text",
+				text: (await this.boilerplateService.useBoilerplate(request)).message
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error using boilerplate: ${error instanceof Error ? error.message : String(error)}`
+				}],
+				isError: true
+			};
+		}
+	}
+};
+
+//#endregion
+//#region src/tools/UseScaffoldMethodTool.ts
+var UseScaffoldMethodTool = class UseScaffoldMethodTool {
+	static TOOL_NAME = "use-scaffold-method";
+	fileSystemService;
+	scaffoldingMethodsService;
+	constructor(templatesPath) {
+		this.fileSystemService = new FileSystemService();
+		this.scaffoldingMethodsService = new ScaffoldingMethodsService(this.fileSystemService, templatesPath);
+	}
+	/**
+	* Get the tool definition for MCP
+	*/
+	getDefinition() {
+		return {
+			name: UseScaffoldMethodTool.TOOL_NAME,
+			description: `Generates and adds a specific feature to an existing project using a scaffolding method.
+
+This tool will:
+- Generate files based on the selected scaffolding method
+- Replace template variables with provided values
+- Add files to the appropriate locations in the project
+- Follow the project's existing patterns and conventions
+- Update imports and exports as needed
+
+IMPORTANT:
+- Always call \`list-scaffolding-methods\` first to see available methods and their schemas
+- Use the exact scaffold method name from the list response
+- Provide variables that match the method's variables_schema exactly
+- The tool validates all inputs before generating code
+`,
+			inputSchema: {
+				type: "object",
+				properties: {
+					projectPath: {
+						type: "string",
+						description: "Absolute path to the project directory containing project.json"
+					},
+					scaffold_feature_name: {
+						type: "string",
+						description: "Exact name of the scaffold method to use (from list-scaffolding-methods response)"
+					},
+					variables: {
+						type: "object",
+						description: "Variables object matching the scaffold method's variables_schema exactly"
+					}
+				},
+				required: [
+					"projectPath",
+					"scaffold_feature_name",
+					"variables"
+				],
+				additionalProperties: false
+			}
+		};
+	}
+	/**
+	* Execute the tool
+	*/
+	async execute(args) {
+		try {
+			const { projectPath, scaffold_feature_name, variables } = args;
+			if (!projectPath) throw new Error("Missing required parameter: projectPath");
+			if (!scaffold_feature_name) throw new Error("Missing required parameter: scaffold_feature_name");
+			if (!variables) throw new Error("Missing required parameter: variables");
+			return { content: [{
+				type: "text",
+				text: (await this.scaffoldingMethodsService.useScaffoldMethod({
+					projectPath,
+					scaffold_feature_name,
+					variables
+				})).message
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error using scaffold method: ${error instanceof Error ? error.message : String(error)}`
+				}],
+				isError: true
+			};
+		}
+	}
+};
+
+//#endregion
+//#region src/tools/WriteToFileTool.ts
+var WriteToFileTool = class WriteToFileTool {
+	static TOOL_NAME = "write-to-file";
+	fileSystemService;
+	constructor() {
+		this.fileSystemService = new FileSystemService();
+	}
+	/**
+	* Get the tool definition for MCP
+	*/
+	getDefinition() {
+		return {
+			name: WriteToFileTool.TOOL_NAME,
+			description: `Writes content to a file, creating the file and any necessary directories if they don't exist.
+
+This tool will:
+- Create the target file if it doesn't exist
+- Create any necessary parent directories
+- Write the provided content to the file
+- Overwrite existing files with new content
+
+Parameters:
+- file_path: Absolute or relative path to the target file
+- content: The content to write to the file`,
+			inputSchema: {
+				type: "object",
+				properties: {
+					file_path: {
+						type: "string",
+						description: "Path to the file to write (absolute or relative to current working directory)"
+					},
+					content: {
+						type: "string",
+						description: "Content to write to the file"
+					}
+				},
+				required: ["file_path", "content"],
+				additionalProperties: false
+			}
+		};
+	}
+	/**
+	* Execute the tool
+	*/
+	async execute(args) {
+		try {
+			const { file_path, content } = args;
+			if (!file_path) throw new Error("Missing required parameter: file_path");
+			if (content === void 0 || content === null) throw new Error("Missing required parameter: content");
+			const resolvedPath = path.isAbsolute(file_path) ? file_path : path.resolve(process.cwd(), file_path);
+			const dirPath = path.dirname(resolvedPath);
+			await this.fileSystemService.ensureDir(dirPath);
+			await this.fileSystemService.writeFile(resolvedPath, content);
+			return { content: [{
+				type: "text",
+				text: `Successfully wrote content to file: ${resolvedPath}`
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error writing to file: ${error instanceof Error ? error.message : String(error)}`
+				}],
+				isError: true
+			};
+		}
+	}
+};
+
+//#endregion
+//#region src/server/index.ts
+function createServer(options = {}) {
+	const { adminEnabled = false } = options;
+	const templatesPath = TemplatesManager.findTemplatesPathSync();
+	const listBoilerplatesTool = new ListBoilerplatesTool(templatesPath);
+	const useBoilerplateTool = new UseBoilerplateTool(templatesPath);
+	const listScaffoldingMethodsTool = new ListScaffoldingMethodsTool(templatesPath);
+	const useScaffoldMethodTool = new UseScaffoldMethodTool(templatesPath);
+	const writeToFileTool = new WriteToFileTool();
+	const generateBoilerplateTool = adminEnabled ? new GenerateBoilerplateTool(templatesPath) : null;
+	const generateBoilerplateFileTool = adminEnabled ? new GenerateBoilerplateFileTool(templatesPath) : null;
+	const generateFeatureScaffoldTool = adminEnabled ? new GenerateFeatureScaffoldTool(templatesPath) : null;
+	const generateBoilerplatePrompt = adminEnabled ? new GenerateBoilerplatePrompt() : null;
+	const generateFeatureScaffoldPrompt = adminEnabled ? new GenerateFeatureScaffoldPrompt() : null;
+	const server = new Server({
+		name: "scaffold-mcp",
+		version: "1.0.0"
+	}, {
+		instructions: `Use this MCP server to create new project and adding a new feature (pages, component, services, etc...).
+
+## Workflow:
+
+1. **Creating New Project**: Use \`list-boilerplates\` → \`use-boilerplate\`
+2. **Adding Features**: Use \`list-scaffolding-methods\` → \`use-scaffold-method\`
+
+## AI Usage Guidelines:
+
+- Always call \`list-boilerplates\` first when creating new projects to see available options
+- Always call \`list-scaffolding-methods\` first when adding features to understand what's available
+- Follow the exact variable schema provided - validation will fail if required fields are missing
+- Use kebab-case for project names (e.g., "my-new-app")
+- The tools automatically handle file placement, imports, and code generation
+- Check the returned JSON schemas to understand required vs optional variables` + (adminEnabled ? `
+
+## Admin Mode (Template Generation):
+
+When creating custom boilerplate templates for frameworks not yet supported:
+
+1. **Create Boilerplate Configuration**: Use \`generate-boilerplate\` to add a new boilerplate entry to a template's scaffold.yaml
+   - Specify template name, boilerplate name, description, target folder, and variable schema
+   - This creates the scaffold.yaml structure following the nextjs-15 pattern
+   - Optional: Add detailed instruction about file purposes and design patterns
+
+2. **Create Feature Configuration**: Use \`generate-feature-scaffold\` to add a new feature entry to a template's scaffold.yaml
+   - Specify template name, feature name, generator, description, and variable schema
+   - This creates the scaffold.yaml structure for feature scaffolds (pages, components, etc.)
+   - Optional: Add detailed instruction about file purposes and design patterns
+   - Optional: Specify patterns to match existing files this feature works with
+
+3. **Create Template Files**: Use \`generate-boilerplate-file\` to create the actual template files
+   - Create files referenced in the boilerplate's or feature's includes array
+   - Use {{ variableName }} syntax for Liquid variable placeholders
+   - Can copy from existing source files or provide content directly
+   - Files automatically get .liquid extension
+
+4. **Test the Template**: Use \`list-boilerplates\`/\`list-scaffolding-methods\` and \`use-boilerplate\`/\`use-scaffold-method\` to verify your template works
+
+Example workflow for boilerplate:
+\`\`\`
+1. generate-boilerplate { templateName: "react-vite", boilerplateName: "scaffold-vite-app", ... }
+2. generate-boilerplate-file { templateName: "react-vite", filePath: "package.json", content: "..." }
+3. generate-boilerplate-file { templateName: "react-vite", filePath: "src/App.tsx", content: "..." }
+4. list-boilerplates (verify it appears)
+5. use-boilerplate { boilerplateName: "scaffold-vite-app", variables: {...} }
+\`\`\`
+
+Example workflow for feature:
+\`\`\`
+1. generate-feature-scaffold { templateName: "nextjs-15", featureName: "scaffold-nextjs-component", generator: "componentGenerator.ts", ... }
+2. generate-boilerplate-file { templateName: "nextjs-15", filePath: "src/components/Component.tsx", content: "..." }
+3. list-scaffolding-methods (verify it appears)
+4. use-scaffold-method { scaffoldName: "scaffold-nextjs-component", variables: {...} }
+\`\`\`` : ""),
+		capabilities: {
+			tools: {},
+			prompts: {}
+		}
+	});
+	server.setRequestHandler(ListToolsRequestSchema, async () => {
+		const listBoilerplateTool = listBoilerplatesTool.getDefinition();
+		const useBoilerplateToolDef = useBoilerplateTool.getDefinition();
+		const listScaffoldingMethodsToolDef = listScaffoldingMethodsTool.getDefinition();
+		const useScaffoldMethodToolDef = useScaffoldMethodTool.getDefinition();
+		const writeToFileToolDef = writeToFileTool.getDefinition();
+		const tools = [
+			listBoilerplateTool,
+			useBoilerplateToolDef,
+			listScaffoldingMethodsToolDef,
+			useScaffoldMethodToolDef,
+			writeToFileToolDef
+		];
+		if (adminEnabled) {
+			if (generateBoilerplateTool) tools.push(generateBoilerplateTool.getDefinition());
+			if (generateBoilerplateFileTool) tools.push(generateBoilerplateFileTool.getDefinition());
+			if (generateFeatureScaffoldTool) tools.push(generateFeatureScaffoldTool.getDefinition());
+		}
+		return { tools };
+	});
+	server.setRequestHandler(CallToolRequestSchema, async (request) => {
+		const { name, arguments: args } = request.params;
+		if (name === ListBoilerplatesTool.TOOL_NAME) return await listBoilerplatesTool.execute(args || {});
+		if (name === UseBoilerplateTool.TOOL_NAME) return await useBoilerplateTool.execute(args || {});
+		if (name === ListScaffoldingMethodsTool.TOOL_NAME) return await listScaffoldingMethodsTool.execute(args || {});
+		if (name === UseScaffoldMethodTool.TOOL_NAME) return await useScaffoldMethodTool.execute(args || {});
+		if (name === WriteToFileTool.TOOL_NAME) return await writeToFileTool.execute(args || {});
+		if (name === GenerateBoilerplateTool.TOOL_NAME) {
+			if (!adminEnabled || !generateBoilerplateTool) throw new Error("Admin tools are not enabled. Use --admin-enable flag to enable.");
+			return await generateBoilerplateTool.execute(args);
+		}
+		if (name === GenerateBoilerplateFileTool.TOOL_NAME) {
+			if (!adminEnabled || !generateBoilerplateFileTool) throw new Error("Admin tools are not enabled. Use --admin-enable flag to enable.");
+			return await generateBoilerplateFileTool.execute(args);
+		}
+		if (name === GenerateFeatureScaffoldTool.TOOL_NAME) {
+			if (!adminEnabled || !generateFeatureScaffoldTool) throw new Error("Admin tools are not enabled. Use --admin-enable flag to enable.");
+			return await generateFeatureScaffoldTool.execute(args);
+		}
+		throw new Error(`Unknown tool: ${name}`);
+	});
+	if (adminEnabled) {
+		server.setRequestHandler(ListPromptsRequestSchema, async () => {
+			const prompts = [];
+			if (generateBoilerplatePrompt) prompts.push(generateBoilerplatePrompt.getDefinition());
+			if (generateFeatureScaffoldPrompt) prompts.push(generateFeatureScaffoldPrompt.getDefinition());
+			return { prompts };
+		});
+		server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+			const { name, arguments: args } = request.params;
+			if (name === GenerateBoilerplatePrompt.PROMPT_NAME) {
+				if (!generateBoilerplatePrompt) throw new Error("Prompt not available");
+				return { messages: generateBoilerplatePrompt.getMessages(args) };
+			}
+			if (name === GenerateFeatureScaffoldPrompt.PROMPT_NAME) {
+				if (!generateFeatureScaffoldPrompt) throw new Error("Prompt not available");
+				return { messages: generateFeatureScaffoldPrompt.getMessages(args) };
+			}
+			throw new Error(`Unknown prompt: ${name}`);
+		});
+	}
+	return server;
+}
+
+//#endregion
+//#region src/transports/http.ts
+/**
+* Session manager for HTTP transports
+*/
+var HttpSessionManager = class {
+	transports = /* @__PURE__ */ new Map();
+	getSession(sessionId) {
+		return this.transports.get(sessionId);
+	}
+	setSession(sessionId, transport) {
+		this.transports.set(sessionId, transport);
+	}
+	deleteSession(sessionId) {
+		this.transports.delete(sessionId);
+	}
+	hasSession(sessionId) {
+		return this.transports.has(sessionId);
+	}
+	clear() {
+		this.transports.clear();
+	}
+};
+/**
+* HTTP transport handler using Streamable HTTP (protocol version 2025-03-26)
+* Provides stateful session management with resumability support
+*/
+var HttpTransportHandler = class {
+	mcpServer;
+	app;
+	server = null;
+	sessionManager;
+	config;
+	constructor(mcpServer, config) {
+		this.mcpServer = mcpServer;
+		this.app = express();
+		this.sessionManager = new HttpSessionManager();
+		this.config = {
+			mode: config.mode,
+			port: config.port ?? 3e3,
+			host: config.host ?? "localhost"
+		};
+		this.setupMiddleware();
+		this.setupRoutes();
+	}
+	setupMiddleware() {
+		this.app.use(express.json());
+	}
+	setupRoutes() {
+		this.app.post("/mcp", async (req, res) => {
+			await this.handlePostRequest(req, res);
+		});
+		this.app.get("/mcp", async (req, res) => {
+			await this.handleGetRequest(req, res);
+		});
+		this.app.delete("/mcp", async (req, res) => {
+			await this.handleDeleteRequest(req, res);
+		});
+		this.app.get("/health", (_req, res) => {
+			res.json({
+				status: "ok",
+				transport: "http"
+			});
+		});
+	}
+	async handlePostRequest(req, res) {
+		const sessionId = req.headers["mcp-session-id"];
+		let transport;
+		if (sessionId && this.sessionManager.hasSession(sessionId)) transport = this.sessionManager.getSession(sessionId);
+		else if (!sessionId && isInitializeRequest(req.body)) {
+			transport = new StreamableHTTPServerTransport({
+				sessionIdGenerator: () => randomUUID(),
+				onsessioninitialized: (sessionId$1) => {
+					this.sessionManager.setSession(sessionId$1, transport);
+				}
+			});
+			transport.onclose = () => {
+				if (transport.sessionId) this.sessionManager.deleteSession(transport.sessionId);
+			};
+			await this.mcpServer.connect(transport);
+		} else {
+			res.status(400).json({
+				jsonrpc: "2.0",
+				error: {
+					code: -32e3,
+					message: "Bad Request: No valid session ID provided"
+				},
+				id: null
+			});
+			return;
+		}
+		await transport.handleRequest(req, res, req.body);
+	}
+	async handleGetRequest(req, res) {
+		const sessionId = req.headers["mcp-session-id"];
+		if (!sessionId || !this.sessionManager.hasSession(sessionId)) {
+			res.status(400).send("Invalid or missing session ID");
+			return;
+		}
+		await this.sessionManager.getSession(sessionId).handleRequest(req, res);
+	}
+	async handleDeleteRequest(req, res) {
+		const sessionId = req.headers["mcp-session-id"];
+		if (!sessionId || !this.sessionManager.hasSession(sessionId)) {
+			res.status(400).send("Invalid or missing session ID");
+			return;
+		}
+		await this.sessionManager.getSession(sessionId).handleRequest(req, res);
+		this.sessionManager.deleteSession(sessionId);
+	}
+	async start() {
+		return new Promise((resolve, reject) => {
+			try {
+				this.server = this.app.listen(this.config.port, this.config.host, () => {
+					console.error(`Scaffolding MCP server started on http://${this.config.host}:${this.config.port}/mcp`);
+					console.error(`Health check: http://${this.config.host}:${this.config.port}/health`);
+					resolve();
+				});
+				this.server.on("error", (error) => {
+					reject(error);
+				});
+			} catch (error) {
+				reject(error);
+			}
+		});
+	}
+	async stop() {
+		return new Promise((resolve, reject) => {
+			if (this.server) {
+				this.sessionManager.clear();
+				this.server.close((err) => {
+					if (err) reject(err);
+					else {
+						this.server = null;
+						resolve();
+					}
+				});
+			} else resolve();
+		});
+	}
+	getPort() {
+		return this.config.port;
+	}
+	getHost() {
+		return this.config.host;
+	}
+};
+
+//#endregion
+//#region src/transports/sse.ts
+/**
+* Session manager for SSE transports
+*/
+var SseSessionManager = class {
+	sessions = /* @__PURE__ */ new Map();
+	getSession(sessionId) {
+		return this.sessions.get(sessionId)?.transport;
+	}
+	setSession(sessionId, transport, server) {
+		this.sessions.set(sessionId, {
+			transport,
+			server
+		});
+	}
+	deleteSession(sessionId) {
+		const session = this.sessions.get(sessionId);
+		if (session) session.server.close();
+		this.sessions.delete(sessionId);
+	}
+	hasSession(sessionId) {
+		return this.sessions.has(sessionId);
+	}
+	clear() {
+		for (const session of this.sessions.values()) session.server.close();
+		this.sessions.clear();
+	}
+};
+/**
+* SSE (Server-Sent Events) transport handler
+* Legacy transport for backwards compatibility (protocol version 2024-11-05)
+* Uses separate endpoints: /sse for SSE stream (GET) and /messages for client messages (POST)
+*/
+var SseTransportHandler = class {
+	serverFactory;
+	app;
+	server = null;
+	sessionManager;
+	config;
+	constructor(serverFactory, config) {
+		this.serverFactory = typeof serverFactory === "function" ? serverFactory : () => serverFactory;
+		this.app = express();
+		this.sessionManager = new SseSessionManager();
+		this.config = {
+			mode: config.mode,
+			port: config.port ?? 3e3,
+			host: config.host ?? "localhost"
+		};
+		this.setupMiddleware();
+		this.setupRoutes();
+	}
+	setupMiddleware() {
+		this.app.use(express.json());
+	}
+	setupRoutes() {
+		this.app.get("/sse", async (req, res) => {
+			await this.handleSseConnection(req, res);
+		});
+		this.app.post("/messages", async (req, res) => {
+			await this.handlePostMessage(req, res);
+		});
+		this.app.get("/health", (_req, res) => {
+			res.json({
+				status: "ok",
+				transport: "sse"
+			});
+		});
+	}
+	async handleSseConnection(_req, res) {
+		try {
+			const mcpServer = this.serverFactory();
+			const transport = new SSEServerTransport("/messages", res);
+			this.sessionManager.setSession(transport.sessionId, transport, mcpServer);
+			res.on("close", () => {
+				this.sessionManager.deleteSession(transport.sessionId);
+			});
+			await mcpServer.connect(transport);
+			console.error(`SSE session established: ${transport.sessionId}`);
+		} catch (error) {
+			console.error("Error handling SSE connection:", error);
+			if (!res.headersSent) res.status(500).send("Internal Server Error");
+		}
+	}
+	async handlePostMessage(req, res) {
+		const sessionId = req.query.sessionId;
+		if (!sessionId) {
+			res.status(400).send("Missing sessionId query parameter");
+			return;
+		}
+		const transport = this.sessionManager.getSession(sessionId);
+		if (!transport) {
+			res.status(404).send("No transport found for sessionId");
+			return;
+		}
+		try {
+			await transport.handlePostMessage(req, res, req.body);
+		} catch (error) {
+			console.error("Error handling post message:", error);
+			if (!res.headersSent) res.status(500).send("Internal Server Error");
+		}
+	}
+	async start() {
+		return new Promise((resolve, reject) => {
+			try {
+				this.server = this.app.listen(this.config.port, this.config.host, () => {
+					console.error(`Scaffolding MCP server started with SSE transport on http://${this.config.host}:${this.config.port}`);
+					console.error(`SSE endpoint: http://${this.config.host}:${this.config.port}/sse`);
+					console.error(`Messages endpoint: http://${this.config.host}:${this.config.port}/messages`);
+					console.error(`Health check: http://${this.config.host}:${this.config.port}/health`);
+					resolve();
+				});
+				this.server.on("error", (error) => {
+					reject(error);
+				});
+			} catch (error) {
+				reject(error);
+			}
+		});
+	}
+	async stop() {
+		return new Promise((resolve, reject) => {
+			if (this.server) {
+				this.sessionManager.clear();
+				this.server.close((err) => {
+					if (err) reject(err);
+					else {
+						this.server = null;
+						resolve();
+					}
+				});
+			} else resolve();
+		});
+	}
+	getPort() {
+		return this.config.port;
+	}
+	getHost() {
+		return this.config.host;
+	}
+};
+
+//#endregion
+//#region src/transports/stdio.ts
+/**
+* Stdio transport handler for MCP server
+* Used for command-line and direct integrations
+*/
+var StdioTransportHandler = class {
+	server;
+	transport = null;
+	constructor(server) {
+		this.server = server;
+	}
+	async start() {
+		this.transport = new StdioServerTransport();
+		await this.server.connect(this.transport);
+		console.error("Scaffolding MCP server started on stdio");
+	}
+	async stop() {
+		if (this.transport) {
+			await this.transport.close();
+			this.transport = null;
+		}
+	}
+};
+
+//#endregion
+//#region src/transports/types.ts
+/**
+* Transport mode types
+*/
+let TransportMode = /* @__PURE__ */ function(TransportMode$1) {
+	TransportMode$1["STDIO"] = "stdio";
+	TransportMode$1["HTTP"] = "http";
+	TransportMode$1["SSE"] = "sse";
+	TransportMode$1["CLI"] = "cli";
+	return TransportMode$1;
+}({});
+
+//#endregion
+//#region src/cli/mcp-serve.ts
+/**
+* Start MCP server with given transport handler
+*/
+async function startServer(handler) {
+	await handler.start();
+	const shutdown = async (signal) => {
+		console.error(`\nReceived ${signal}, shutting down gracefully...`);
+		try {
+			await handler.stop();
+			process.exit(0);
+		} catch (error) {
+			console.error("Error during shutdown:", error);
+			process.exit(1);
+		}
+	};
+	process.on("SIGINT", () => shutdown("SIGINT"));
+	process.on("SIGTERM", () => shutdown("SIGTERM"));
+}
+/**
+* MCP Serve command
+*/
+const mcpServeCommand = new Command("mcp-serve").description("Start MCP server with specified transport").option("-t, --type <type>", "Transport type: stdio, http, or sse", "stdio").option("-p, --port <port>", "Port to listen on (http/sse only)", (val) => parseInt(val, 10), 3e3).option("--host <host>", "Host to bind to (http/sse only)", "localhost").option("--admin-enable", "Enable admin tools (generate-boilerplate)", false).action(async (options) => {
+	try {
+		const transportType = options.type.toLowerCase();
+		const serverOptions = { adminEnabled: options.adminEnable };
+		if (transportType === "stdio") {
+			const server = createServer(serverOptions);
+			const handler = new StdioTransportHandler(server);
+			await startServer(handler);
+		} else if (transportType === "http") {
+			const server = createServer(serverOptions);
+			const config = {
+				mode: TransportMode.HTTP,
+				port: options.port || Number(process.env.MCP_PORT) || 3e3,
+				host: options.host || process.env.MCP_HOST || "localhost"
+			};
+			const handler = new HttpTransportHandler(server, config);
+			await startServer(handler);
+		} else if (transportType === "sse") {
+			const config = {
+				mode: TransportMode.SSE,
+				port: options.port || Number(process.env.MCP_PORT) || 3e3,
+				host: options.host || process.env.MCP_HOST || "localhost"
+			};
+			const handler = new SseTransportHandler(() => createServer(serverOptions), config);
+			await startServer(handler);
+		} else {
+			console.error(`Unknown transport type: ${transportType}. Use: stdio, http, or sse`);
+			process.exit(1);
+		}
+	} catch (error) {
+		console.error("Failed to start MCP server:", error);
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/cli/scaffold.ts
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const templatesDir = path.resolve(__dirname, "../../../../templates");
+/**
+* Scaffold CLI command
+*/
+const scaffoldCommand = new Command("scaffold").description("Add features to existing projects");
+scaffoldCommand.command("list <projectPath>").description("List available scaffolding methods for a project").action(async (projectPath) => {
+	try {
+		const absolutePath = path.resolve(projectPath);
+		if (!fs$1.existsSync(path.join(absolutePath, "project.json"))) {
+			messages.error(`No project.json found in ${absolutePath}`);
+			messages.hint("Make sure you are in a valid project directory");
+			process.exit(1);
+		}
+		const fileSystemService = new FileSystemService();
+		const methods = (await new ScaffoldingMethodsService(fileSystemService, templatesDir).listScaffoldingMethods(absolutePath)).methods;
+		if (methods.length === 0) {
+			messages.warning("No scaffolding methods available for this project.");
+			return;
+		}
+		logger.header(`\n${icons.wrench} Available Scaffolding Methods for ${projectPath}:\n`);
+		for (const method of methods) {
+			logger.highlight(`  ${method.name}`);
+			logger.debug(`    ${method.instruction || method.description || "No description available"}`);
+			if (method.variables_schema.required && method.variables_schema.required.length > 0) logger.debug(`    Required: ${method.variables_schema.required.join(", ")}`);
+			logger.newline();
+		}
+	} catch (error) {
+		messages.error("Error listing scaffolding methods:", error);
+		process.exit(1);
+	}
+});
+scaffoldCommand.command("add <featureName>").description("Add a feature to an existing project").option("-p, --project <path>", "Project path", process.cwd()).option("-v, --vars <json>", "JSON string containing variables for the feature").option("--verbose", "Enable verbose logging").action(async (featureName, options) => {
+	try {
+		const projectPath = path.resolve(options.project);
+		if (!fs$1.existsSync(path.join(projectPath, "project.json"))) {
+			messages.error(`No project.json found in ${projectPath}`);
+			messages.hint("Make sure you are in a valid project directory");
+			process.exit(1);
+		}
+		let variables = {};
+		if (options.vars) try {
+			variables = JSON.parse(options.vars);
+		} catch (error) {
+			messages.error("Error parsing variables JSON:", error);
+			messages.hint("Example: --vars '{\"componentName\": \"UserProfile\", \"description\": \"User profile component\"}'");
+			process.exit(1);
+		}
+		const fileSystemService = new FileSystemService();
+		const scaffoldingMethodsService = new ScaffoldingMethodsService(fileSystemService, templatesDir);
+		const methods = (await scaffoldingMethodsService.listScaffoldingMethods(projectPath)).methods;
+		const method = methods.find((m) => m.name === featureName);
+		if (!method) {
+			messages.error(`Scaffold method '${featureName}' not found.`);
+			logger.warning(`Available methods: ${methods.map((m) => m.name).join(", ")}`);
+			logger.debug(`Run 'scaffold-mcp scaffold list ${options.project}' to see all available methods`);
+			process.exit(1);
+		}
+		const required = typeof method.variables_schema === "object" && method.variables_schema !== null && "required" in method.variables_schema ? method.variables_schema.required : [];
+		const missing = required.filter((key) => !variables[key]);
+		if (missing.length > 0) {
+			messages.error(`❌ Missing required variables: ${missing.join(", ")}`);
+			messages.hint(`💡 Use --vars with a JSON object containing: ${missing.join(", ")}`);
+			const exampleVars = {};
+			for (const key of required) if (key.includes("Name")) exampleVars[key] = "MyFeature";
+			else if (key === "description") exampleVars[key] = "Feature description";
+			else exampleVars[key] = `<${key}>`;
+			logger.debug(`Example: scaffold-mcp scaffold add ${featureName} --project ${options.project} --vars '${JSON.stringify(exampleVars)}'`);
+			process.exit(1);
+		}
+		if (options.verbose) {
+			logger.info(`🔧 Feature: ${featureName}`);
+			logger.info(`📊 Variables: ${JSON.stringify(variables, null, 2)}`);
+			logger.info(`📁 Project Path: ${projectPath}`);
+		}
+		logger.info(`🚀 Adding '${featureName}' to project...`);
+		const result = await scaffoldingMethodsService.useScaffoldMethod({
+			projectPath,
+			scaffold_feature_name: featureName,
+			variables
+		});
+		if (result.success) {
+			messages.success("✅ Feature added successfully!");
+			console.log(result.message);
+			if (result.createdFiles && result.createdFiles.length > 0) {
+				logger.header("\n📁 Created files:");
+				result.createdFiles.forEach((file) => logger.debug(`   - ${file}`));
+			}
+			if (result.warnings && result.warnings.length > 0) {
+				messages.warning("\n⚠️  Warnings:");
+				result.warnings.forEach((warning) => logger.debug(`   - ${warning}`));
+			}
+			logger.header("\n📋 Next steps:");
+			logger.debug("   - Review the generated files");
+			logger.debug("   - Update imports if necessary");
+			logger.debug("   - Run tests to ensure everything works");
+		} else {
+			messages.error(`❌ Failed to add feature: ${result.message}`);
+			process.exit(1);
+		}
+	} catch (error) {
+		messages.error(`❌ Error adding feature: ${error.message}`);
+		if (options.verbose) console.error("Stack trace:", error.stack);
+		process.exit(1);
+	}
+});
+scaffoldCommand.command("info <featureName>").description("Show detailed information about a scaffold method").option("-p, --project <path>", "Project path", process.cwd()).action(async (featureName, options) => {
+	try {
+		const projectPath = path.resolve(options.project);
+		if (!fs$1.existsSync(path.join(projectPath, "project.json"))) {
+			messages.error(`❌ No project.json found in ${projectPath}`);
+			process.exit(1);
+		}
+		const fileSystemService = new FileSystemService();
+		const method = (await new ScaffoldingMethodsService(fileSystemService, templatesDir).listScaffoldingMethods(projectPath)).methods.find((m) => m.name === featureName);
+		if (!method) {
+			messages.error(`❌ Scaffold method '${featureName}' not found.`);
+			process.exit(1);
+		}
+		logger.header(`\n🔧 Scaffold Method: ${method.name}\n`);
+		logger.debug(`Description: ${method.description}`);
+		logger.header("\n📝 Variables Schema:");
+		console.log(JSON.stringify(method.variables_schema, null, 2));
+		const includes = "includes" in method ? method.includes : [];
+		if (includes && includes.length > 0) {
+			logger.header("\n📁 Files to be created:");
+			includes.forEach((include) => {
+				const parts = include.split(">>");
+				if (parts.length === 2) logger.debug(`  - ${parts[1].trim()}`);
+				else logger.debug(`  - ${include}`);
+			});
+		}
+	} catch (error) {
+		messages.error(`❌ Error getting scaffold info: ${error.message}`);
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/index.ts
+/**
+* Main entry point
+*/
+async function main() {
+	const program = new Command();
+	program.name("scaffold-mcp").description("MCP server for scaffolding applications with boilerplate templates").version("1.0.0");
+	program.addCommand(mcpServeCommand);
+	program.addCommand(boilerplateCommand);
+	program.addCommand(scaffoldCommand);
+	program.addCommand(initCommand);
+	program.addCommand(addCommand);
+	await program.parseAsync(process.argv);
+}
+main();
+
+//#endregion
+export {  };