@agiflowai/scaffold-mcp 0.5.0 → 1.0.0

package/dist/cli.js

@@ -0,0 +1,1355 @@
+#!/usr/bin/env node
+import { BoilerplateService, FileSystemService, GenerateBoilerplateFileTool, GenerateBoilerplateTool, GenerateFeatureScaffoldTool, HttpTransportHandler, ListBoilerplatesTool, ListScaffoldingMethodsTool, ScaffoldingMethodsService, SseTransportHandler, StdioTransportHandler, UseBoilerplateTool, UseScaffoldMethodTool, WriteToFileTool, cloneRepository, cloneSubdirectory, fetchGitHubDirectoryContents, findWorkspaceRoot, parseGitHubUrl } from "./stdio-Dmpwju2k.js";
+import "./ScaffoldConfigLoader-CI0T6zdG.js";
+import "./ScaffoldService-QgQKHMM-.js";
+import "./TemplateService-CiZJA06s.js";
+import "./VariableReplacementService-B3qARIC9.js";
+import { Command } from "commander";
+import path from "node:path";
+import { ProjectConfigResolver, ProjectType, TemplatesManagerService, icons, messages, print, sections } from "@agiflowai/aicode-utils";
+import * as fs$1 from "fs-extra";
+import { execa } from "execa";
+import { confirm, input, select } from "@inquirer/prompts";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+
+//#region package.json
+var name = "@agiflowai/scaffold-mcp";
+var description = "MCP server for scaffolding applications with boilerplate templates";
+var version = "0.6.0";
+var license = "AGPL-3.0";
+var author = "AgiflowIO";
+var repository = {
+	"type": "git",
+	"url": "https://github.com/AgiFlow/aicode-toolkit.git",
+	"directory": "packages/scaffold-mcp"
+};
+var homepage = "https://github.com/AgiFlow/aicode-toolkit#readme";
+var bugs = { "url": "https://github.com/AgiFlow/aicode-toolkit/issues" };
+var keywords = [
+	"mcp",
+	"model-context-protocol",
+	"scaffold",
+	"boilerplate",
+	"template",
+	"code-generation",
+	"nextjs",
+	"react",
+	"vite"
+];
+var bin = { "scaffold-mcp": "./dist/cli.cjs" };
+var main$1 = "./dist/index.cjs";
+var types = "./dist/index.d.cts";
+var module = "./dist/index.js";
+var files = ["dist", "README.md"];
+var scripts = {
+	"dev": "node --loader ts-node/esm src/cli.ts",
+	"build": "tsdown",
+	"test": "vitest --run",
+	"typecheck": "tsc --noEmit"
+};
+var dependencies = {
+	"@agiflowai/aicode-utils": "workspace:*",
+	"@composio/json-schema-to-zod": "0.1.15",
+	"@inquirer/prompts": "^7.8.6",
+	"@modelcontextprotocol/sdk": "1.19.1",
+	"chalk": "5.6.2",
+	"commander": "14.0.1",
+	"execa": "^9.5.2",
+	"express": "^4.21.2",
+	"fs-extra": "11.3.2",
+	"js-yaml": "4.1.0",
+	"liquidjs": "10.21.1",
+	"pino": "^10.0.0",
+	"pino-pretty": "^13.1.1",
+	"zod": "3.25.76"
+};
+var devDependencies = {
+	"@types/express": "^5.0.0",
+	"@types/fs-extra": "^11.0.4",
+	"@types/js-yaml": "^4.0.9",
+	"@types/node": "^22.0.0",
+	"tsdown": "^0.15.6",
+	"typescript": "5.9.3"
+};
+var publishConfig = { "access": "public" };
+var type = "module";
+var exports = {
+	".": {
+		"import": "./dist/index.js",
+		"require": "./dist/index.cjs"
+	},
+	"./cli": {
+		"import": "./dist/cli.js",
+		"require": "./dist/cli.cjs"
+	},
+	"./package.json": "./package.json"
+};
+var package_default = {
+	name,
+	description,
+	version,
+	license,
+	author,
+	repository,
+	homepage,
+	bugs,
+	keywords,
+	bin,
+	main: main$1,
+	types,
+	module,
+	files,
+	scripts,
+	dependencies,
+	devDependencies,
+	publishConfig,
+	type,
+	exports
+};
+
+//#endregion
+//#region src/commands/add.ts
+/**
+* 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>", "Override templates folder path (uses toolkit.yaml config by default)").option("--type <type>", "Template type: boilerplate or scaffold", "boilerplate").action(async (options) => {
+	try {
+		const templatesPath = options.path ? path.resolve(options.path) : await TemplatesManagerService.findTemplatesPath();
+		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);
+		}
+		print.info(`${icons.download} Downloading template '${templateName}' from ${templateUrl}...`);
+		await fs$1.ensureDir(path.dirname(targetFolder));
+		const parsedUrl = parseGitHubUrl(templateUrl);
+		try {
+			if (parsedUrl.isSubdirectory && parsedUrl.branch && parsedUrl.subdirectory) {
+				print.info(`${icons.folder} Detected subdirectory: ${parsedUrl.subdirectory} (branch: ${parsedUrl.branch})`);
+				await cloneSubdirectory(parsedUrl.repoUrl, parsedUrl.branch, parsedUrl.subdirectory, targetFolder);
+			} else await cloneRepository(parsedUrl.repoUrl, targetFolder);
+			messages.success(`Template '${templateName}' added successfully!`);
+			print.header(`\n${icons.folder} Template location:`);
+			print.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)) {
+				print.header(`\n${icons.config} Configuration file found:`);
+				print.indent(path.basename(configFile));
+				hasConfig = true;
+				break;
+			}
+			if (!hasConfig) {
+				messages.warning("Warning: No configuration file found (boilerplate.yaml or scaffold.yaml)");
+				print.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/commands/boilerplate.ts
+/**
+* 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(await TemplatesManagerService.findTemplatesPath()).listBoilerplates();
+		if (boilerplates.length === 0) {
+			messages.warning("No boilerplate templates found.");
+			return;
+		}
+		print.header(`\n${icons.package} Available Boilerplate Templates:\n`);
+		for (const bp of boilerplates) {
+			print.highlight(`  ${bp.name}`);
+			print.debug(`    ${bp.description}`);
+			print.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) print.debug(`    Required: ${required.join(", ")}`);
+			print.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("-m, --monolith", "Create as monolith project at workspace root with toolkit.yaml (default: false, creates as monorepo with project.json)").option("-t, --target-folder <path>", "Override target folder (defaults to boilerplate targetFolder for monorepo, workspace root for monolith)").option("--verbose", "Enable verbose logging").action(async (boilerplateName, options) => {
+	try {
+		const boilerplateService = new BoilerplateService(await TemplatesManagerService.findTemplatesPath());
+		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.`);
+			print.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}>`;
+			print.debug(`Example: scaffold-mcp boilerplate create ${boilerplateName} --vars '${JSON.stringify(exampleVars)}'`);
+			process.exit(1);
+		}
+		if (options.verbose) {
+			print.info(`${icons.wrench} Boilerplate: ${boilerplateName}`);
+			print.info(`${icons.chart} Variables: ${JSON.stringify(variables, null, 2)}`);
+		}
+		messages.loading(`Creating project from boilerplate '${boilerplateName}'...`);
+		const result = await boilerplateService.useBoilerplate({
+			boilerplateName,
+			variables,
+			monolith: options.monolith,
+			targetFolderOverride: options.targetFolder
+		});
+		if (result.success) {
+			messages.success("Project created successfully!");
+			print.info(result.message);
+			if (result.createdFiles && result.createdFiles.length > 0) sections.createdFiles(result.createdFiles);
+			const projectName = variables.appName || variables.packageName;
+			if (projectName) {
+				const targetFolder = options.targetFolder || (options.monolith ? "." : boilerplate.target_folder);
+				const projectPath = options.monolith ? "." : `${targetFolder}/${projectName}`;
+				const steps = projectPath === "." ? ["pnpm install", "pnpm dev"] : [
+					`cd ${projectPath}`,
+					"pnpm install",
+					"pnpm dev"
+				];
+				sections.nextSteps(steps);
+			}
+		} 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(await TemplatesManagerService.findTemplatesPath()).getBoilerplate(boilerplateName);
+		if (!bp) {
+			messages.error(`Boilerplate '${boilerplateName}' not found.`);
+			process.exit(1);
+		}
+		print.header(`\n${icons.package} Boilerplate: ${bp.name}\n`);
+		print.debug(`Description: ${bp.description}`);
+		print.debug(`Template Path: ${bp.template_path}`);
+		print.debug(`Target Folder: ${bp.target_folder}`);
+		print.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/commands/init.ts
+/**
+* Execute git init safely using execa to prevent command injection
+*/
+async function gitInit(projectPath) {
+	try {
+		await execa("git", ["init", projectPath]);
+	} catch (error) {
+		const execaError = error;
+		throw new Error(`Git init failed: ${execaError.stderr || execaError.message}`);
+	}
+}
+const DEFAULT_TEMPLATE_REPO = {
+	owner: "AgiFlow",
+	repo: "aicode-toolkit",
+	branch: "main",
+	path: "templates"
+};
+/**
+* Interactive setup for new projects
+* Prompts user for project details when no .git folder is found
+* @param providedName - Optional project name from CLI argument
+* @param providedProjectType - Optional project type from CLI argument
+*/
+async function setupNewProject(providedName, providedProjectType) {
+	print.header(`\n${icons.rocket} New Project Setup`);
+	print.info("No Git repository detected. Let's set up a new project!\n");
+	let projectName;
+	const reservedNames = [
+		".",
+		"..",
+		"CON",
+		"PRN",
+		"AUX",
+		"NUL",
+		"COM1",
+		"COM2",
+		"COM3",
+		"COM4",
+		"COM5",
+		"COM6",
+		"COM7",
+		"COM8",
+		"COM9",
+		"LPT1",
+		"LPT2",
+		"LPT3",
+		"LPT4",
+		"LPT5",
+		"LPT6",
+		"LPT7",
+		"LPT8",
+		"LPT9"
+	];
+	const validateProjectName = (value) => {
+		const trimmed = value.trim();
+		if (!trimmed) return "Project name is required";
+		if (!/^[a-zA-Z0-9]/.test(trimmed)) return "Project name must start with a letter or number";
+		if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(trimmed)) return "Project name can only contain letters, numbers, hyphens, and underscores";
+		if (reservedNames.includes(trimmed.toUpperCase())) return "Project name uses a reserved name";
+		return true;
+	};
+	if (providedName) {
+		const trimmedName = providedName.trim();
+		const validationResult = validateProjectName(trimmedName);
+		if (validationResult !== true) throw new Error(validationResult);
+		projectName = trimmedName;
+		print.info(`Project name: ${projectName}`);
+	} else projectName = await input({
+		message: "Enter your project name:",
+		validate: validateProjectName
+	});
+	let projectType;
+	if (providedProjectType) {
+		if (providedProjectType !== ProjectType.MONOLITH && providedProjectType !== ProjectType.MONOREPO) throw new Error(`Invalid project type '${providedProjectType}'. Must be '${ProjectType.MONOLITH}' or '${ProjectType.MONOREPO}'`);
+		projectType = providedProjectType;
+		print.info(`Project type: ${projectType}`);
+	} else projectType = await select({
+		message: "Select project type:",
+		choices: [{
+			name: "Monolith - Single application structure",
+			value: ProjectType.MONOLITH,
+			description: "Traditional single-application project structure"
+		}, {
+			name: "Monorepo - Multiple packages/apps in one repository",
+			value: ProjectType.MONOREPO,
+			description: "Multiple packages managed together (uses workspaces)"
+		}]
+	});
+	const hasExistingRepo = await confirm({
+		message: "Do you have an existing Git repository you want to use?",
+		default: false
+	});
+	const projectPath = path.join(process.cwd(), projectName.trim());
+	try {
+		await fs$1.mkdir(projectPath, { recursive: false });
+		print.success(`${icons.check} Created project directory: ${projectPath}`);
+	} catch (error) {
+		if (error.code === "EEXIST") throw new Error(`Directory '${projectName}' already exists. Please choose a different name.`);
+		throw error;
+	}
+	if (hasExistingRepo) {
+		const repoUrl = await input({
+			message: "Enter Git repository URL:",
+			validate: (value) => {
+				if (!value.trim()) return "Repository URL is required";
+				if (!value.match(/^(https?:\/\/|git@)/)) return "Please enter a valid Git repository URL";
+				return true;
+			}
+		});
+		print.info(`${icons.download} Cloning repository...`);
+		try {
+			const parsed = parseGitHubUrl(repoUrl.trim());
+			if (parsed.isSubdirectory && parsed.branch && parsed.subdirectory) await cloneSubdirectory(parsed.repoUrl, parsed.branch, parsed.subdirectory, projectPath);
+			else await cloneRepository(parsed.repoUrl, projectPath);
+			print.success(`${icons.check} Repository cloned successfully`);
+		} catch (error) {
+			await fs$1.remove(projectPath);
+			throw new Error(`Failed to clone repository: ${error.message}`);
+		}
+	} else if (await confirm({
+		message: "Initialize a new Git repository?",
+		default: true
+	})) {
+		print.info(`${icons.rocket} Initializing Git repository...`);
+		try {
+			await gitInit(projectPath);
+			print.success(`${icons.check} Git repository initialized`);
+		} catch (error) {
+			messages.warning(`Failed to initialize Git: ${error.message}`);
+		}
+	}
+	return {
+		projectPath,
+		projectType
+	};
+}
+/**
+* Download templates from GitHub repository
+*/
+async function downloadTemplates(templatesPath) {
+	try {
+		print.info(`${icons.download} Fetching templates from ${DEFAULT_TEMPLATE_REPO.owner}/${DEFAULT_TEMPLATE_REPO.repo}...`);
+		const templateDirs = (await fetchGitHubDirectoryContents(DEFAULT_TEMPLATE_REPO.owner, DEFAULT_TEMPLATE_REPO.repo, DEFAULT_TEMPLATE_REPO.path, DEFAULT_TEMPLATE_REPO.branch)).filter((item) => item.type === "dir");
+		if (templateDirs.length === 0) {
+			messages.warning("No templates found in repository");
+			return;
+		}
+		print.info(`${icons.folder} Found ${templateDirs.length} template(s)`);
+		for (const template of templateDirs) {
+			const targetFolder = path.join(templatesPath, template.name);
+			if (await fs$1.pathExists(targetFolder)) {
+				print.info(`${icons.skip} Skipping ${template.name} (already exists)`);
+				continue;
+			}
+			print.info(`${icons.download} Downloading ${template.name}...`);
+			await cloneSubdirectory(`https://github.com/${DEFAULT_TEMPLATE_REPO.owner}/${DEFAULT_TEMPLATE_REPO.repo}.git`, DEFAULT_TEMPLATE_REPO.branch, template.path, targetFolder);
+			print.success(`${icons.check} Downloaded ${template.name}`);
+		}
+		print.success(`\n${icons.check} All templates downloaded successfully!`);
+	} catch (error) {
+		throw new Error(`Failed to download templates: ${error.message}`);
+	}
+}
+/**
+* Init command - initialize templates folder
+*/
+const initCommand = new Command("init").description("Initialize templates folder structure at workspace root or create new project").option("--no-download", "Skip downloading templates from repository").option("--path <path>", "Custom path for templates folder (relative to workspace root)").option("--name <name>", "Project name (for new projects)").option("--project-type <type>", "Project type: monolith or monorepo (for new projects)").action(async (options) => {
+	try {
+		let workspaceRoot = await findWorkspaceRoot();
+		let projectType;
+		if (!workspaceRoot) {
+			const projectSetup = await setupNewProject(options.name, options.projectType);
+			workspaceRoot = projectSetup.projectPath;
+			projectType = projectSetup.projectType;
+			print.info(`\n${icons.folder} Project type: ${projectType}`);
+		}
+		let templatesPath = options.path ? path.join(workspaceRoot, options.path) : path.join(workspaceRoot, "templates");
+		if (await fs$1.pathExists(templatesPath)) {
+			messages.warning(`\n⚠️  Templates folder already exists at: ${templatesPath}`);
+			if (await confirm({
+				message: "Do you want to use a different folder for templates?",
+				default: false
+			})) {
+				const alternateFolder = await input({
+					message: "Enter alternate folder name for templates:",
+					default: "my-templates",
+					validate: (value) => {
+						if (!value.trim()) return "Folder name is required";
+						if (!/^[a-zA-Z0-9_\-/]+$/.test(value)) return "Folder name can only contain letters, numbers, hyphens, underscores, and slashes";
+						return true;
+					}
+				});
+				templatesPath = path.join(workspaceRoot, alternateFolder.trim());
+				const toolkitConfig = {
+					templatesPath: alternateFolder.trim(),
+					projectType
+				};
+				print.info(`\n${icons.config} Creating toolkit.yaml with custom templates path...`);
+				await TemplatesManagerService.writeToolkitConfig(toolkitConfig, workspaceRoot);
+				print.success(`${icons.check} toolkit.yaml created`);
+			} else print.info(`\n${icons.info} Using existing templates folder`);
+		}
+		print.info(`\n${icons.rocket} Initializing templates folder at: ${templatesPath}`);
+		await fs$1.ensureDir(templatesPath);
+		await fs$1.writeFile(path.join(templatesPath, "README.md"), `# Templates
+
+This folder contains boilerplate templates and scaffolding methods for your projects.
+
+## Templates
+
+Templates are organized by framework/technology and include configuration files (\`scaffold.yaml\`) that define:
+- Boilerplates: Full project starter templates
+- Features: Code scaffolding methods for adding new features to existing projects
+
+## Adding More Templates
+
+Use the \`aicode-toolkit\` CLI to add templates from remote repositories:
+
+\`\`\`bash
+npx @agiflowai/aicode-toolkit add --name my-template --url https://github.com/user/template
+\`\`\`
+
+Or add templates from subdirectories:
+
+\`\`\`bash
+npx @agiflowai/aicode-toolkit add --name nextjs-template --url https://github.com/user/repo/tree/main/templates/nextjs
+\`\`\`
+
+## Creating Custom Templates
+
+Each template should have a \`scaffold.yaml\` configuration file defining:
+- \`boilerplate\`: Array of boilerplate configurations
+- \`features\`: Array of feature scaffold configurations
+
+Template files use Liquid syntax for variable placeholders: \`{{ variableName }}\`
+
+See existing templates for examples and documentation for more details.
+`);
+		print.success(`${icons.check} Templates folder created!`);
+		if (options.download !== false) await downloadTemplates(templatesPath);
+		else print.info(`${icons.skip} Skipping template download (use --download to enable)`);
+		print.header(`\n${icons.folder} Templates location:`);
+		print.indent(templatesPath);
+		const nextSteps = [];
+		if (options.download === false) nextSteps.push(`Add templates: npx @agiflowai/aicode-toolkit add --name <name> --url <url>`);
+		else {
+			nextSteps.push(`List available boilerplates: scaffold-mcp boilerplate list`);
+			nextSteps.push(`Add more templates: npx @agiflowai/aicode-toolkit add --name <name> --url <url>`);
+		}
+		sections.nextSteps(nextSteps);
+	} catch (error) {
+		messages.error(`Error initializing templates folder: ${error.message}`);
+		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/prompts/ScaffoldApplicationPrompt.ts
+/**
+* Prompt for scaffolding a new application using boilerplate templates
+*/
+var ScaffoldApplicationPrompt = class ScaffoldApplicationPrompt {
+	static PROMPT_NAME = "scaffold-application";
+	/**
+	* Get the prompt definition for MCP
+	*/
+	getDefinition() {
+		return {
+			name: ScaffoldApplicationPrompt.PROMPT_NAME,
+			description: "Scaffold a new application from a boilerplate template",
+			arguments: [{
+				name: "request",
+				description: "Describe the application you want to create (optional)",
+				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 application using the scaffold-mcp MCP tools.
+
+${userRequest ? `User request: ${userRequest}\n` : ""}
+Your task is to scaffold a new application by following this workflow:
+
+## Step 1: List Available Boilerplates
+Use the \`list-boilerplates\` tool to see all available project templates.
+
+**What to look for:**
+- Boilerplate name (e.g., "scaffold-nextjs-app", "scaffold-vite-app")
+- Description of what the boilerplate creates
+- Target folder where projects will be created (e.g., "apps", "packages")
+- Required and optional variables in the variables_schema
+
+## Step 2: Gather Required Information
+Based on the selected boilerplate's variables_schema, collect:
+- **Project name**: Must be kebab-case (e.g., "my-new-app", not "MyNewApp")
+- **Required variables**: All variables marked as required: true
+- **Optional variables**: Variables with required: false (ask user if needed)
+
+Common variables:
+- \`appName\` or \`packageName\`: The project name (kebab-case)
+- \`description\`: Brief description of what the project does
+- \`author\`: Author name
+
+## Step 3: Execute the Boilerplate
+Use the \`use-boilerplate\` tool with:
+- \`boilerplateName\`: Exact name from list-boilerplates response
+- \`variables\`: Object matching the variables_schema exactly
+
+**Example:**
+\`\`\`json
+{
+  "boilerplateName": "scaffold-nextjs-app",
+  "variables": {
+    "appName": "my-dashboard",
+    "description": "Admin dashboard for managing users",
+    "author": "John Doe"
+  }
+}
+\`\`\`
+
+## Important Guidelines:
+- **Always call \`list-boilerplates\` first** to see available options and their schemas
+- **Use exact variable names** from the schema (case-sensitive)
+- **Provide all required variables** - the tool will fail if any are missing
+- **Use kebab-case for project names** (e.g., "user-dashboard", not "UserDashboard")
+- The tool will create the project in the appropriate directory automatically
+- After creation, inform the user where the project was created
+
+## Step 4: Review and Add Features (If Needed)
+After the boilerplate is created, **consider if additional features are needed**:
+1. **READ** the generated project structure to understand what was created
+2. **REVIEW** the user's request to see if they asked for specific features (e.g., "with tool for X", "with prompt for Y")
+3. **If features are needed**:
+   - Use \`list-scaffolding-methods\` with the new project path
+   - Use \`use-scaffold-method\` to add tools, services, prompts, etc.
+   - **IMPLEMENT** the actual logic in the scaffolded feature files
+   - **REGISTER** the features in \`src/server/index.ts\`
+4. **Install dependencies**: Remind user to run \`pnpm install\`
+5. **Report** the complete setup including any features added
+
+## Example Workflow:
+1. Call \`list-boilerplates\` → See available templates
+2. Ask user which template to use (or infer from request)
+3. Collect required variables based on schema
+4. Call \`use-boilerplate\` with boilerplateName and variables
+5. **Review if user requested specific features (tools, prompts, etc.)**
+6. **If features needed**: Add them using \`list-scaffolding-methods\` and \`use-scaffold-method\`
+7. **READ and IMPLEMENT** the scaffolded feature files with actual logic
+8. Report success and next steps to the user`
+			}
+		}];
+	}
+};
+
+//#endregion
+//#region src/prompts/ScaffoldFeaturePrompt.ts
+/**
+* Prompt for scaffolding a new feature in an existing project
+*/
+var ScaffoldFeaturePrompt = class ScaffoldFeaturePrompt {
+	static PROMPT_NAME = "scaffold-feature";
+	/**
+	* Get the prompt definition for MCP
+	*/
+	getDefinition() {
+		return {
+			name: ScaffoldFeaturePrompt.PROMPT_NAME,
+			description: "Scaffold a new feature (page, component, service, etc.) in an existing project",
+			arguments: [{
+				name: "request",
+				description: "Describe the feature you want to add (optional)",
+				required: false
+			}, {
+				name: "projectPath",
+				description: "Path to the project (e.g., \"apps/my-app\") - optional if can be inferred",
+				required: false
+			}]
+		};
+	}
+	/**
+	* Get the prompt messages
+	*/
+	getMessages(args) {
+		const userRequest = args?.request || "";
+		const projectPath = args?.projectPath || "";
+		return [{
+			role: "user",
+			content: {
+				type: "text",
+				text: `You are helping add a new feature to an existing project using the scaffold-mcp MCP tools.
+
+${userRequest ? `User request: ${userRequest}\n` : ""}${projectPath ? `Project path: ${projectPath}\n` : ""}
+Your task is to scaffold a new feature by following this workflow:
+
+## Step 1: Identify the Project
+Determine the project path where the feature will be added:
+- If projectPath is provided, use it
+- Otherwise, ask the user or infer from context (e.g., "apps/my-app", "packages/my-lib")
+- The path should point to a directory containing a \`project.json\` file
+
+## Step 2: List Available Scaffolding Methods
+Use the \`list-scaffolding-methods\` tool with the projectPath.
+
+**What to look for:**
+- Feature name (e.g., "scaffold-nextjs-page", "scaffold-react-component")
+- Description of what files/code it generates
+- Required and optional variables in the variables_schema
+- The template type (derived from project's sourceTemplate)
+
+**Example:**
+\`\`\`json
+{
+  "projectPath": "apps/my-dashboard"
+}
+\`\`\`
+
+## Step 3: Gather Required Information
+Based on the selected scaffolding method's variables_schema, collect:
+- **Feature-specific variables**: Name, path, type, etc.
+- **Required variables**: All variables marked as required: true
+- **Optional variables**: Variables with required: false (ask user if needed)
+
+Common variables:
+- \`componentName\` / \`pageName\` / \`serviceName\`: Name in PascalCase
+- \`componentPath\` / \`pagePath\`: Where to place the file (may use kebab-case)
+- Boolean flags: \`withTests\`, \`withLayout\`, \`withStyles\`, etc.
+
+## Step 4: Execute the Scaffolding Method
+Use the \`use-scaffold-method\` tool with:
+- \`projectPath\`: Same path from step 1
+- \`scaffold_feature_name\`: Exact name from list-scaffolding-methods response
+- \`variables\`: Object matching the variables_schema exactly
+
+**Example:**
+\`\`\`json
+{
+  "projectPath": "apps/my-dashboard",
+  "scaffold_feature_name": "scaffold-nextjs-page",
+  "variables": {
+    "pageName": "UserProfile",
+    "pagePath": "user/profile",
+    "withLayout": true,
+    "withTests": false
+  }
+}
+\`\`\`
+
+## Important Guidelines:
+- **Always call \`list-scaffolding-methods\` first** with the projectPath
+- **Use exact variable names** from the schema (case-sensitive)
+- **Provide all required variables** - the tool will fail if any are missing
+- **Follow naming conventions**:
+  - Component/Page/Service names: PascalCase (e.g., "UserProfile")
+  - File paths: kebab-case or as specified in schema (e.g., "user/profile")
+- **Conditional files**: Files with \`?condition=true\` are only included when the variable is true
+- The tool will create files in the appropriate locations automatically
+- After creation, inform the user what files were created
+
+## Step 5: Review and Implement Generated Files
+After scaffolding completes, **you MUST**:
+1. **READ** all generated files to understand their structure
+2. **IMPLEMENT** the actual business logic:
+   - Replace TODO comments with real code
+   - Replace template placeholders with actual implementation
+   - Add the specific functionality described in the user's request
+3. **REGISTER** the feature in appropriate files:
+   - Import and register tools in \`src/server/index.ts\`
+   - Export new modules from \`index.ts\` files
+   - Update any necessary configuration files
+4. **TEST** to ensure the implementation works correctly
+5. **DO NOT SKIP** this step - scaffolded files are templates that need actual code
+
+## Example Workflow:
+1. Identify project path (provided or ask user)
+2. Call \`list-scaffolding-methods\` → See available features for this project
+3. Ask user which feature to add (or infer from request)
+4. Collect required variables based on schema
+5. Call \`use-scaffold-method\` with projectPath, scaffold_feature_name, and variables
+6. **READ the generated files and IMPLEMENT the actual logic**
+7. **REGISTER the feature in server/index.ts and other config files**
+8. Report success and list created files with implementation details`
+			}
+		}];
+	}
+};
+
+//#endregion
+//#region src/server/index.ts
+function createServer(options = {}) {
+	const { adminEnabled = false } = options;
+	const templatesPath = TemplatesManagerService.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 scaffoldApplicationPrompt = new ScaffoldApplicationPrompt();
+	const scaffoldFeaturePrompt = new ScaffoldFeaturePrompt();
+	const server = new Server({
+		name: "scaffold-mcp",
+		version: "0.4.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 tools = [
+			listBoilerplatesTool.getDefinition(),
+			useBoilerplateTool.getDefinition(),
+			listScaffoldingMethodsTool.getDefinition(),
+			useScaffoldMethodTool.getDefinition(),
+			writeToFileTool.getDefinition()
+		];
+		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: name$1, arguments: args } = request.params;
+		if (name$1 === ListBoilerplatesTool.TOOL_NAME) return await listBoilerplatesTool.execute(args || {});
+		if (name$1 === UseBoilerplateTool.TOOL_NAME) return await useBoilerplateTool.execute(args || {});
+		if (name$1 === ListScaffoldingMethodsTool.TOOL_NAME) return await listScaffoldingMethodsTool.execute(args || {});
+		if (name$1 === UseScaffoldMethodTool.TOOL_NAME) return await useScaffoldMethodTool.execute(args || {});
+		if (name$1 === WriteToFileTool.TOOL_NAME) return await writeToFileTool.execute(args || {});
+		if (name$1 === 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$1 === 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$1 === 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$1}`);
+	});
+	server.setRequestHandler(ListPromptsRequestSchema, async () => {
+		const prompts = [];
+		prompts.push(scaffoldApplicationPrompt.getDefinition());
+		prompts.push(scaffoldFeaturePrompt.getDefinition());
+		if (adminEnabled) {
+			if (generateBoilerplatePrompt) prompts.push(generateBoilerplatePrompt.getDefinition());
+			if (generateFeatureScaffoldPrompt) prompts.push(generateFeatureScaffoldPrompt.getDefinition());
+		}
+		return { prompts };
+	});
+	server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+		const { name: name$1, arguments: args } = request.params;
+		if (name$1 === ScaffoldApplicationPrompt.PROMPT_NAME) return { messages: scaffoldApplicationPrompt.getMessages(args) };
+		if (name$1 === ScaffoldFeaturePrompt.PROMPT_NAME) return { messages: scaffoldFeaturePrompt.getMessages(args) };
+		if (name$1 === GenerateBoilerplatePrompt.PROMPT_NAME) {
+			if (!generateBoilerplatePrompt) throw new Error("Prompt not available");
+			return { messages: generateBoilerplatePrompt.getMessages(args) };
+		}
+		if (name$1 === GenerateFeatureScaffoldPrompt.PROMPT_NAME) {
+			if (!generateFeatureScaffoldPrompt) throw new Error("Prompt not available");
+			return { messages: generateFeatureScaffoldPrompt.getMessages(args) };
+		}
+		throw new Error(`Unknown prompt: ${name$1}`);
+	});
+	return server;
+}
+
+//#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/commands/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") await startServer(new StdioTransportHandler(createServer(serverOptions)));
+		else if (transportType === "http") await startServer(new HttpTransportHandler(() => createServer(serverOptions), {
+			mode: TransportMode.HTTP,
+			port: options.port || Number(process.env.MCP_PORT) || 3e3,
+			host: options.host || process.env.MCP_HOST || "localhost"
+		}));
+		else if (transportType === "sse") await startServer(new SseTransportHandler(() => createServer(serverOptions), {
+			mode: TransportMode.SSE,
+			port: options.port || Number(process.env.MCP_PORT) || 3e3,
+			host: options.host || process.env.MCP_HOST || "localhost"
+		}));
+		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/commands/scaffold.ts
+/**
+* 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 (!await ProjectConfigResolver.hasConfiguration(absolutePath)) {
+			messages.error(`No project configuration found in ${absolutePath}`);
+			messages.hint("For monorepo: ensure project.json exists with sourceTemplate field\nFor monolith: ensure toolkit.yaml exists at workspace root");
+			process.exit(1);
+		}
+		const templatesDir = await TemplatesManagerService.findTemplatesPath();
+		const methods = (await new ScaffoldingMethodsService(new FileSystemService(), templatesDir).listScaffoldingMethods(absolutePath)).methods;
+		if (methods.length === 0) {
+			messages.warning("No scaffolding methods available for this project.");
+			return;
+		}
+		print.header(`\n${icons.wrench} Available Scaffolding Methods for ${projectPath}:\n`);
+		for (const method of methods) {
+			print.highlight(`  ${method.name}`);
+			print.debug(`    ${method.instruction || method.description || "No description available"}`);
+			if (method.variables_schema.required && method.variables_schema.required.length > 0) print.debug(`    Required: ${method.variables_schema.required.join(", ")}`);
+			print.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 (!await ProjectConfigResolver.hasConfiguration(projectPath)) {
+			messages.error(`No project configuration found in ${projectPath}`);
+			messages.hint("For monorepo: ensure project.json exists with sourceTemplate field\nFor monolith: ensure toolkit.yaml exists at workspace root");
+			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 templatesDir = await TemplatesManagerService.findTemplatesPath();
+		const scaffoldingMethodsService = new ScaffoldingMethodsService(new 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.`);
+			print.warning(`Available methods: ${methods.map((m) => m.name).join(", ")}`);
+			print.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}>`;
+			print.debug(`Example: scaffold-mcp scaffold add ${featureName} --project ${options.project} --vars '${JSON.stringify(exampleVars)}'`);
+			process.exit(1);
+		}
+		if (options.verbose) {
+			print.info(`🔧 Feature: ${featureName}`);
+			print.info(`📊 Variables: ${JSON.stringify(variables, null, 2)}`);
+			print.info(`📁 Project Path: ${projectPath}`);
+		}
+		print.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) {
+				print.header("\n📁 Created files:");
+				result.createdFiles.forEach((file) => print.debug(`   - ${file}`));
+			}
+			if (result.warnings && result.warnings.length > 0) {
+				messages.warning("\n⚠️  Warnings:");
+				result.warnings.forEach((warning) => print.debug(`   - ${warning}`));
+			}
+			print.header("\n📋 Next steps:");
+			print.debug("   - Review the generated files");
+			print.debug("   - Update imports if necessary");
+			print.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 (!await ProjectConfigResolver.hasConfiguration(projectPath)) {
+			messages.error(`No project configuration found in ${projectPath}`);
+			messages.hint("For monorepo: ensure project.json exists with sourceTemplate field\nFor monolith: ensure toolkit.yaml exists at workspace root");
+			process.exit(1);
+		}
+		const templatesDir = await TemplatesManagerService.findTemplatesPath();
+		const method = (await new ScaffoldingMethodsService(new FileSystemService(), templatesDir).listScaffoldingMethods(projectPath)).methods.find((m) => m.name === featureName);
+		if (!method) {
+			messages.error(`❌ Scaffold method '${featureName}' not found.`);
+			process.exit(1);
+		}
+		print.header(`\n🔧 Scaffold Method: ${method.name}\n`);
+		print.debug(`Description: ${method.description}`);
+		print.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) {
+			print.header("\n📁 Files to be created:");
+			includes.forEach((include) => {
+				const parts = include.split(">>");
+				if (parts.length === 2) print.debug(`  - ${parts[1].trim()}`);
+				else print.debug(`  - ${include}`);
+			});
+		}
+	} catch (error) {
+		messages.error(`❌ Error getting scaffold info: ${error.message}`);
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/cli.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(package_default.version);
+	program.addCommand(mcpServeCommand);
+	program.addCommand(boilerplateCommand);
+	program.addCommand(scaffoldCommand);
+	program.addCommand(initCommand);
+	program.addCommand(addCommand);
+	await program.parseAsync(process.argv);
+}
+main();
+
+//#endregion
+export {  };