@agiflowai/scaffold-mcp 0.6.0 → 1.0.1

package/dist/index.cjs

@@ -1,41 +1,15 @@
-#!/usr/bin/env node
 const require_chunk = require('./chunk-CUT6urMc.cjs');
-const require_ScaffoldConfigLoader = require('./ScaffoldConfigLoader-1Pcv9cxm.cjs');
-const require_ScaffoldService = require('./ScaffoldService-BgFWAOLQ.cjs');
-const require_TemplateService = require('./TemplateService-_KpkoLfZ.cjs');
-const require_VariableReplacementService = require('./VariableReplacementService-ClshNY_C.cjs');
-let commander = require("commander");
-commander = require_chunk.__toESM(commander);
+const require_stdio = require('./stdio-TGsG8akc.cjs');
+const require_ScaffoldConfigLoader = require('./ScaffoldConfigLoader-BrmvENTo.cjs');
+const require_ScaffoldService = require('./ScaffoldService-BwDmXt83.cjs');
+const require_TemplateService = require('./TemplateService-DRubcvS9.cjs');
+const require_VariableReplacementService = require('./VariableReplacementService-D0QnWKUW.cjs');
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
-let __agiflowai_aicode_utils = require("@agiflowai/aicode-utils");
-__agiflowai_aicode_utils = require_chunk.__toESM(__agiflowai_aicode_utils);
 let fs_extra = require("fs-extra");
 fs_extra = require_chunk.__toESM(fs_extra);
 let execa = require("execa");
 execa = require_chunk.__toESM(execa);
-let __composio_json_schema_to_zod = require("@composio/json-schema-to-zod");
-__composio_json_schema_to_zod = require_chunk.__toESM(__composio_json_schema_to_zod);
-let js_yaml = require("js-yaml");
-js_yaml = require_chunk.__toESM(js_yaml);
-let zod = require("zod");
-zod = require_chunk.__toESM(zod);
-let __inquirer_prompts = require("@inquirer/prompts");
-__inquirer_prompts = require_chunk.__toESM(__inquirer_prompts);
-let __modelcontextprotocol_sdk_server_index_js = require("@modelcontextprotocol/sdk/server/index.js");
-__modelcontextprotocol_sdk_server_index_js = require_chunk.__toESM(__modelcontextprotocol_sdk_server_index_js);
-let __modelcontextprotocol_sdk_types_js = require("@modelcontextprotocol/sdk/types.js");
-__modelcontextprotocol_sdk_types_js = require_chunk.__toESM(__modelcontextprotocol_sdk_types_js);
-let node_crypto = require("node:crypto");
-node_crypto = require_chunk.__toESM(node_crypto);
-let __modelcontextprotocol_sdk_server_streamableHttp_js = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
-__modelcontextprotocol_sdk_server_streamableHttp_js = require_chunk.__toESM(__modelcontextprotocol_sdk_server_streamableHttp_js);
-let express = require("express");
-express = require_chunk.__toESM(express);
-let __modelcontextprotocol_sdk_server_sse_js = require("@modelcontextprotocol/sdk/server/sse.js");
-__modelcontextprotocol_sdk_server_sse_js = require_chunk.__toESM(__modelcontextprotocol_sdk_server_sse_js);
-let __modelcontextprotocol_sdk_server_stdio_js = require("@modelcontextprotocol/sdk/server/stdio.js");
-__modelcontextprotocol_sdk_server_stdio_js = require_chunk.__toESM(__modelcontextprotocol_sdk_server_stdio_js);
 
 //#region src/utils/git.ts
 /**
@@ -77,11 +51,11 @@ function parseGitHubUrl(url) {
 	if (treeMatch || blobMatch) {
 		const match = treeMatch || blobMatch;
 		return {
-			owner: match[1],
-			repo: match[2],
-			repoUrl: `https://github.com/${match[1]}/${match[2]}.git`,
-			branch: match[3],
-			subdirectory: match[4],
+			owner: match?.[1],
+			repo: match?.[2],
+			repoUrl: `https://github.com/${match?.[1]}/${match?.[2]}.git`,
+			branch: match?.[3],
+			subdirectory: match?.[4],
 			isSubdirectory: true
 		};
 	}
@@ -147,8 +121,8 @@ async function cloneRepository(repoUrl, targetFolder) {
 /**
 * Fetch directory listing from GitHub API
 */
-async function fetchGitHubDirectoryContents(owner, repo, path$6, branch = "main") {
-	const url = `https://api.github.com/repos/${owner}/${repo}/contents/${path$6}?ref=${branch}`;
+async function fetchGitHubDirectoryContents(owner, repo, path$1, branch = "main") {
+	const url = `https://api.github.com/repos/${owner}/${repo}/contents/${path$1}?ref=${branch}`;
 	const response = await fetch(url, { headers: {
 		Accept: "application/vnd.github.v3+json",
 		"User-Agent": "scaffold-mcp"
@@ -164,3173 +138,29 @@ async function fetchGitHubDirectoryContents(owner, repo, path$6, branch = "main"
 }
 
 //#endregion
-//#region src/cli/add.ts
-/**
-* Add command - add a template to templates folder
-*/
-const addCommand = new commander.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 ? node_path.default.resolve(options.path) : await __agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPath();
-		const templateType = options.type.toLowerCase();
-		const templateName = options.name;
-		const templateUrl = options.url;
-		if (templateType !== "boilerplate" && templateType !== "scaffold") {
-			__agiflowai_aicode_utils.messages.error("Invalid template type. Use: boilerplate or scaffold");
-			process.exit(1);
-		}
-		const targetFolder = node_path.default.join(templatesPath, `${templateType}s`, templateName);
-		if (await fs_extra.pathExists(targetFolder)) {
-			__agiflowai_aicode_utils.messages.error(`Template '${templateName}' already exists at ${targetFolder}`);
-			process.exit(1);
-		}
-		__agiflowai_aicode_utils.print.info(`${__agiflowai_aicode_utils.icons.download} Downloading template '${templateName}' from ${templateUrl}...`);
-		await fs_extra.ensureDir(node_path.default.dirname(targetFolder));
-		const parsedUrl = parseGitHubUrl(templateUrl);
-		try {
-			if (parsedUrl.isSubdirectory && parsedUrl.branch && parsedUrl.subdirectory) {
-				__agiflowai_aicode_utils.print.info(`${__agiflowai_aicode_utils.icons.folder} Detected subdirectory: ${parsedUrl.subdirectory} (branch: ${parsedUrl.branch})`);
-				await cloneSubdirectory(parsedUrl.repoUrl, parsedUrl.branch, parsedUrl.subdirectory, targetFolder);
-			} else await cloneRepository(parsedUrl.repoUrl, targetFolder);
-			__agiflowai_aicode_utils.messages.success(`Template '${templateName}' added successfully!`);
-			__agiflowai_aicode_utils.print.header(`\n${__agiflowai_aicode_utils.icons.folder} Template location:`);
-			__agiflowai_aicode_utils.print.indent(targetFolder);
-			const configFiles = [node_path.default.join(targetFolder, "boilerplate.yaml"), node_path.default.join(targetFolder, "scaffold.yaml")];
-			let hasConfig = false;
-			for (const configFile of configFiles) if (await fs_extra.pathExists(configFile)) {
-				__agiflowai_aicode_utils.print.header(`\n${__agiflowai_aicode_utils.icons.config} Configuration file found:`);
-				__agiflowai_aicode_utils.print.indent(node_path.default.basename(configFile));
-				hasConfig = true;
-				break;
-			}
-			if (!hasConfig) {
-				__agiflowai_aicode_utils.messages.warning("Warning: No configuration file found (boilerplate.yaml or scaffold.yaml)");
-				__agiflowai_aicode_utils.print.indent("You may need to create one manually.");
-			}
-			__agiflowai_aicode_utils.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")) __agiflowai_aicode_utils.messages.error("git command not found. Please install git first.");
-			else if (error.message.includes("Authentication failed")) __agiflowai_aicode_utils.messages.error("Authentication failed. Make sure you have access to the repository.");
-			else if (error.message.includes("Repository not found")) __agiflowai_aicode_utils.messages.error("Repository not found. Check the URL and try again.");
-			else __agiflowai_aicode_utils.messages.error("Failed to clone repository:", error);
-			process.exit(1);
-		}
-	} catch (error) {
-		__agiflowai_aicode_utils.messages.error("Error adding template:", error);
-		process.exit(1);
-	}
-});
-
-//#endregion
-//#region src/services/FileSystemService.ts
-var FileSystemService = class {
-	async pathExists(path$6) {
-		return fs_extra.default.pathExists(path$6);
-	}
-	async readFile(path$6, encoding = "utf8") {
-		return fs_extra.default.readFile(path$6, encoding);
-	}
-	async readJson(path$6) {
-		return fs_extra.default.readJson(path$6);
-	}
-	async writeFile(path$6, content, encoding = "utf8") {
-		return fs_extra.default.writeFile(path$6, content, encoding);
-	}
-	async ensureDir(path$6) {
-		return fs_extra.default.ensureDir(path$6);
-	}
-	async copy(src, dest) {
-		return fs_extra.default.copy(src, dest);
-	}
-	async readdir(path$6) {
-		return fs_extra.default.readdir(path$6);
-	}
-	async stat(path$6) {
-		return fs_extra.default.stat(path$6);
-	}
-};
-
-//#endregion
-//#region src/services/BoilerplateService.ts
-var BoilerplateService = class {
-	templatesPath;
-	templateService;
-	scaffoldService;
-	constructor(templatesPath) {
-		this.templatesPath = templatesPath;
-		this.templateService = new require_TemplateService.TemplateService();
-		const fileSystemService = new FileSystemService();
-		this.scaffoldService = new require_ScaffoldService.ScaffoldService(fileSystemService, new require_ScaffoldConfigLoader.ScaffoldConfigLoader(fileSystemService, this.templateService), new require_VariableReplacementService.VariableReplacementService(fileSystemService, this.templateService), 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 = node_path.join(this.templatesPath, templatePath, "scaffold.yaml");
-			if (fs_extra.existsSync(scaffoldYamlPath)) try {
-				const scaffoldContent = fs_extra.readFileSync(scaffoldYamlPath, "utf8");
-				const scaffoldConfig = js_yaml.load(scaffoldContent);
-				if (scaffoldConfig.boilerplate) for (const boilerplate of scaffoldConfig.boilerplate) {
-					if (!boilerplate.targetFolder) {
-						__agiflowai_aicode_utils.log.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) {
-				__agiflowai_aicode_utils.log.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_extra.existsSync(dir)) return;
-			const items = fs_extra.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 = node_path.join(dir, item);
-				if (fs_extra.statSync(itemPath).isDirectory() && !item.startsWith(".") && item !== "node_modules") findTemplates(itemPath, baseDir ? node_path.join(baseDir, item) : item);
-			}
-		};
-		findTemplates(this.templatesPath);
-		return templateDirs;
-	}
-	/**
-	* Executes a specific boilerplate with provided variables
-	*/
-	async useBoilerplate(request) {
-		const { boilerplateName, variables, monolith = false, targetFolderOverride } = 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;
-		const targetFolder = targetFolderOverride || (monolith ? "." : boilerplate.target_folder);
-		try {
-			const result = await this.scaffoldService.useBoilerplate({
-				projectName: folderName,
-				packageName,
-				targetFolder,
-				templateFolder: boilerplate.template_path,
-				boilerplateName,
-				variables: {
-					...variables,
-					packageName,
-					appName: folderName,
-					sourceTemplate: boilerplate.template_path
-				}
-			});
-			if (!result.success) return result;
-			if (monolith) await __agiflowai_aicode_utils.ProjectConfigResolver.createToolkitYaml(boilerplate.template_path);
-			else {
-				const projectPath = node_path.join(targetFolder, folderName);
-				await __agiflowai_aicode_utils.ProjectConfigResolver.createProjectJson(projectPath, 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 {
-			(0, __composio_json_schema_to_zod.jsonSchemaToZod)(boilerplate.variables_schema).parse(variables);
-			return {
-				isValid: true,
-				errors: []
-			};
-		} catch (error) {
-			if (error instanceof zod.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
-			};
-		}
-	}
-};
-
-//#endregion
-//#region src/cli/boilerplate.ts
-/**
-* Boilerplate CLI command
-*/
-const boilerplateCommand = new commander.Command("boilerplate").description("Manage boilerplate templates");
-boilerplateCommand.command("list").description("List all available boilerplate templates").action(async () => {
-	try {
-		const { boilerplates } = await new BoilerplateService(await __agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPath()).listBoilerplates();
-		if (boilerplates.length === 0) {
-			__agiflowai_aicode_utils.messages.warning("No boilerplate templates found.");
-			return;
-		}
-		__agiflowai_aicode_utils.print.header(`\n${__agiflowai_aicode_utils.icons.package} Available Boilerplate Templates:\n`);
-		for (const bp of boilerplates) {
-			__agiflowai_aicode_utils.print.highlight(`  ${bp.name}`);
-			__agiflowai_aicode_utils.print.debug(`    ${bp.description}`);
-			__agiflowai_aicode_utils.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) __agiflowai_aicode_utils.print.debug(`    Required: ${required.join(", ")}`);
-			__agiflowai_aicode_utils.print.newline();
-		}
-	} catch (error) {
-		__agiflowai_aicode_utils.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 __agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPath());
-		let variables = {};
-		if (options.vars) try {
-			variables = JSON.parse(options.vars);
-		} catch (error) {
-			__agiflowai_aicode_utils.messages.error("Error parsing variables JSON:", error);
-			__agiflowai_aicode_utils.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();
-			__agiflowai_aicode_utils.messages.error(`Boilerplate '${boilerplateName}' not found.`);
-			__agiflowai_aicode_utils.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) {
-			__agiflowai_aicode_utils.messages.error(`Missing required variables: ${missing.join(", ")}`);
-			__agiflowai_aicode_utils.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}>`;
-			__agiflowai_aicode_utils.print.debug(`Example: scaffold-mcp boilerplate create ${boilerplateName} --vars '${JSON.stringify(exampleVars)}'`);
-			process.exit(1);
-		}
-		if (options.verbose) {
-			__agiflowai_aicode_utils.print.info(`${__agiflowai_aicode_utils.icons.wrench} Boilerplate: ${boilerplateName}`);
-			__agiflowai_aicode_utils.print.info(`${__agiflowai_aicode_utils.icons.chart} Variables: ${JSON.stringify(variables, null, 2)}`);
-		}
-		__agiflowai_aicode_utils.messages.loading(`Creating project from boilerplate '${boilerplateName}'...`);
-		const result = await boilerplateService.useBoilerplate({
-			boilerplateName,
-			variables,
-			monolith: options.monolith,
-			targetFolderOverride: options.targetFolder
-		});
-		if (result.success) {
-			__agiflowai_aicode_utils.messages.success("Project created successfully!");
-			__agiflowai_aicode_utils.print.info(result.message);
-			if (result.createdFiles && result.createdFiles.length > 0) __agiflowai_aicode_utils.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"
-				];
-				__agiflowai_aicode_utils.sections.nextSteps(steps);
-			}
-		} else {
-			__agiflowai_aicode_utils.messages.error(`Failed to create project: ${result.message}`);
-			process.exit(1);
-		}
-	} catch (error) {
-		__agiflowai_aicode_utils.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 __agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPath()).getBoilerplate(boilerplateName);
-		if (!bp) {
-			__agiflowai_aicode_utils.messages.error(`Boilerplate '${boilerplateName}' not found.`);
-			process.exit(1);
-		}
-		__agiflowai_aicode_utils.print.header(`\n${__agiflowai_aicode_utils.icons.package} Boilerplate: ${bp.name}\n`);
-		__agiflowai_aicode_utils.print.debug(`Description: ${bp.description}`);
-		__agiflowai_aicode_utils.print.debug(`Template Path: ${bp.template_path}`);
-		__agiflowai_aicode_utils.print.debug(`Target Folder: ${bp.target_folder}`);
-		__agiflowai_aicode_utils.print.header(`\n${__agiflowai_aicode_utils.icons.config} Variables Schema:`);
-		console.log(JSON.stringify(bp.variables_schema, null, 2));
-		if (bp.includes && bp.includes.length > 0) __agiflowai_aicode_utils.sections.list(`${__agiflowai_aicode_utils.icons.folder} Included Files:`, bp.includes);
-	} catch (error) {
-		__agiflowai_aicode_utils.messages.error("Error getting boilerplate info:", error);
-		process.exit(1);
-	}
-});
-
-//#endregion
-//#region src/cli/init.ts
-/**
-* Execute git init safely using execa to prevent command injection
-*/
-async function gitInit(projectPath) {
-	try {
-		await (0, execa.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) {
-	__agiflowai_aicode_utils.print.header(`\n${__agiflowai_aicode_utils.icons.rocket} New Project Setup`);
-	__agiflowai_aicode_utils.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;
-		__agiflowai_aicode_utils.print.info(`Project name: ${projectName}`);
-	} else projectName = await (0, __inquirer_prompts.input)({
-		message: "Enter your project name:",
-		validate: validateProjectName
-	});
-	let projectType;
-	if (providedProjectType) {
-		if (providedProjectType !== __agiflowai_aicode_utils.ProjectType.MONOLITH && providedProjectType !== __agiflowai_aicode_utils.ProjectType.MONOREPO) throw new Error(`Invalid project type '${providedProjectType}'. Must be '${__agiflowai_aicode_utils.ProjectType.MONOLITH}' or '${__agiflowai_aicode_utils.ProjectType.MONOREPO}'`);
-		projectType = providedProjectType;
-		__agiflowai_aicode_utils.print.info(`Project type: ${projectType}`);
-	} else projectType = await (0, __inquirer_prompts.select)({
-		message: "Select project type:",
-		choices: [{
-			name: "Monolith - Single application structure",
-			value: __agiflowai_aicode_utils.ProjectType.MONOLITH,
-			description: "Traditional single-application project structure"
-		}, {
-			name: "Monorepo - Multiple packages/apps in one repository",
-			value: __agiflowai_aicode_utils.ProjectType.MONOREPO,
-			description: "Multiple packages managed together (uses workspaces)"
-		}]
-	});
-	const hasExistingRepo = await (0, __inquirer_prompts.confirm)({
-		message: "Do you have an existing Git repository you want to use?",
-		default: false
-	});
-	const projectPath = node_path.default.join(process.cwd(), projectName.trim());
-	try {
-		await fs_extra.mkdir(projectPath, { recursive: false });
-		__agiflowai_aicode_utils.print.success(`${__agiflowai_aicode_utils.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 (0, __inquirer_prompts.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;
-			}
-		});
-		__agiflowai_aicode_utils.print.info(`${__agiflowai_aicode_utils.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);
-			__agiflowai_aicode_utils.print.success(`${__agiflowai_aicode_utils.icons.check} Repository cloned successfully`);
-		} catch (error) {
-			await fs_extra.remove(projectPath);
-			throw new Error(`Failed to clone repository: ${error.message}`);
-		}
-	} else if (await (0, __inquirer_prompts.confirm)({
-		message: "Initialize a new Git repository?",
-		default: true
-	})) {
-		__agiflowai_aicode_utils.print.info(`${__agiflowai_aicode_utils.icons.rocket} Initializing Git repository...`);
-		try {
-			await gitInit(projectPath);
-			__agiflowai_aicode_utils.print.success(`${__agiflowai_aicode_utils.icons.check} Git repository initialized`);
-		} catch (error) {
-			__agiflowai_aicode_utils.messages.warning(`Failed to initialize Git: ${error.message}`);
-		}
-	}
-	return {
-		projectPath,
-		projectType
-	};
-}
-/**
-* Download templates from GitHub repository
-*/
-async function downloadTemplates(templatesPath) {
-	try {
-		__agiflowai_aicode_utils.print.info(`${__agiflowai_aicode_utils.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) {
-			__agiflowai_aicode_utils.messages.warning("No templates found in repository");
-			return;
-		}
-		__agiflowai_aicode_utils.print.info(`${__agiflowai_aicode_utils.icons.folder} Found ${templateDirs.length} template(s)`);
-		for (const template of templateDirs) {
-			const targetFolder = node_path.default.join(templatesPath, template.name);
-			if (await fs_extra.pathExists(targetFolder)) {
-				__agiflowai_aicode_utils.print.info(`${__agiflowai_aicode_utils.icons.skip} Skipping ${template.name} (already exists)`);
-				continue;
-			}
-			__agiflowai_aicode_utils.print.info(`${__agiflowai_aicode_utils.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);
-			__agiflowai_aicode_utils.print.success(`${__agiflowai_aicode_utils.icons.check} Downloaded ${template.name}`);
-		}
-		__agiflowai_aicode_utils.print.success(`\n${__agiflowai_aicode_utils.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 commander.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;
-			__agiflowai_aicode_utils.print.info(`\n${__agiflowai_aicode_utils.icons.folder} Project type: ${projectType}`);
-		}
-		let templatesPath = options.path ? node_path.default.join(workspaceRoot, options.path) : node_path.default.join(workspaceRoot, "templates");
-		if (await fs_extra.pathExists(templatesPath)) {
-			__agiflowai_aicode_utils.messages.warning(`\n⚠️  Templates folder already exists at: ${templatesPath}`);
-			if (await (0, __inquirer_prompts.confirm)({
-				message: "Do you want to use a different folder for templates?",
-				default: false
-			})) {
-				const alternateFolder = await (0, __inquirer_prompts.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 = node_path.default.join(workspaceRoot, alternateFolder.trim());
-				const toolkitConfig = {
-					templatesPath: alternateFolder.trim(),
-					projectType
-				};
-				__agiflowai_aicode_utils.print.info(`\n${__agiflowai_aicode_utils.icons.config} Creating toolkit.yaml with custom templates path...`);
-				await __agiflowai_aicode_utils.TemplatesManagerService.writeToolkitConfig(toolkitConfig, workspaceRoot);
-				__agiflowai_aicode_utils.print.success(`${__agiflowai_aicode_utils.icons.check} toolkit.yaml created`);
-			} else __agiflowai_aicode_utils.print.info(`\n${__agiflowai_aicode_utils.icons.info} Using existing templates folder`);
-		}
-		__agiflowai_aicode_utils.print.info(`\n${__agiflowai_aicode_utils.icons.rocket} Initializing templates folder at: ${templatesPath}`);
-		await fs_extra.ensureDir(templatesPath);
-		await fs_extra.writeFile(node_path.default.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 \`add\` command to add templates from remote repositories:
-
-\`\`\`bash
-scaffold-mcp add --name my-template --url https://github.com/user/template
-\`\`\`
-
-Or add templates from subdirectories:
-
-\`\`\`bash
-scaffold-mcp 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.
-`);
-		__agiflowai_aicode_utils.print.success(`${__agiflowai_aicode_utils.icons.check} Templates folder created!`);
-		if (options.download !== false) await downloadTemplates(templatesPath);
-		else __agiflowai_aicode_utils.print.info(`${__agiflowai_aicode_utils.icons.skip} Skipping template download (use --download to enable)`);
-		__agiflowai_aicode_utils.print.header(`\n${__agiflowai_aicode_utils.icons.folder} Templates location:`);
-		__agiflowai_aicode_utils.print.indent(templatesPath);
-		const nextSteps = [];
-		if (options.download === false) {
-			nextSteps.push(`Download templates: scaffold-mcp init --download`);
-			nextSteps.push(`Add templates manually: scaffold-mcp add --name <name> --url <url>`);
-		} else {
-			nextSteps.push(`List available boilerplates: scaffold-mcp boilerplate list`);
-			nextSteps.push(`Add more templates: scaffold-mcp add --name <name> --url <url>`);
-		}
-		__agiflowai_aicode_utils.sections.nextSteps(nextSteps);
-	} catch (error) {
-		__agiflowai_aicode_utils.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/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 js_yaml.Type("tag:yaml.org,2002:str", {
-			kind: "scalar",
-			construct: (data) => data,
-			represent: (data) => {
-				return data;
-			},
-			defaultStyle: "|"
-		});
-		const LITERAL_SCHEMA = js_yaml.DEFAULT_SCHEMA.extend([LiteralBlockType]);
-		const processedConfig = this.processConfigForLiteralBlocks(config);
-		return js_yaml.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 = node_path.join(this.templatesPath, templateName);
-		await fs_extra.ensureDir(templatePath);
-		const scaffoldYamlPath = node_path.join(templatePath, "scaffold.yaml");
-		let scaffoldConfig = {};
-		if (await fs_extra.pathExists(scaffoldYamlPath)) {
-			const yamlContent$1 = await fs_extra.readFile(scaffoldYamlPath, "utf-8");
-			scaffoldConfig = js_yaml.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 boilerplateDefinition = {
-			name: boilerplateName,
-			targetFolder,
-			description,
-			variables_schema: {
-				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
-			},
-			includes: includes.length > 0 ? includes : []
-		};
-		if (instruction) boilerplateDefinition.instruction = instruction;
-		scaffoldConfig.boilerplate.push(boilerplateDefinition);
-		const yamlContent = this.dumpYamlWithLiteralBlocks(scaffoldConfig);
-		await fs_extra.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_extra.readdir(this.templatesPath, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-	}
-	/**
-	* Check if a template exists
-	*/
-	async templateExists(templateName) {
-		const templatePath = node_path.join(this.templatesPath, templateName);
-		return fs_extra.pathExists(templatePath);
-	}
-	/**
-	* Create or update a template file for a boilerplate
-	*/
-	async createTemplateFile(options) {
-		const { templateName, filePath, content, sourceFile, header } = options;
-		const templatePath = node_path.join(this.templatesPath, templateName);
-		if (!await fs_extra.pathExists(templatePath)) return {
-			success: false,
-			message: `Template directory '${templateName}' does not exist at ${templatePath}`
-		};
-		let fileContent = content || "";
-		if (sourceFile) {
-			if (!await fs_extra.pathExists(sourceFile)) return {
-				success: false,
-				message: `Source file '${sourceFile}' does not exist`
-			};
-			fileContent = await fs_extra.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 = node_path.join(templatePath, templateFilePath);
-		await fs_extra.ensureDir(node_path.dirname(fullPath));
-		let finalContent = fileContent;
-		if (header) finalContent = `${header}\n\n${fileContent}`;
-		await fs_extra.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
-
-IMPORTANT - Always add header comments:
-- For code files (*.ts, *.tsx, *.js, *.jsx), ALWAYS include a header parameter with design patterns, coding standards, and things to avoid
-- Headers help AI understand and follow established patterns when working with generated code
-- Use the header parameter to document the architectural decisions and best practices
-
-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 using Liquid template syntax.
-
-LIQUID SYNTAX:
-- Variables: {{ variableName }} - Replaced with actual values
-- Conditionals: {% if condition %}...{% endif %} - Conditional rendering
-- Else: {% if condition %}...{% else %}...{% endif %}
-- Elsif: {% if condition %}...{% elsif other %}...{% endif %}
-- Equality: {% if var == 'value' %}...{% endif %}
-
-AVAILABLE FILTERS:
-You can transform variables using these filters with the pipe (|) syntax:
-
-Case Conversion:
-- {{ name | camelCase }} - Convert to camelCase (myVariableName)
-- {{ name | pascalCase }} - Convert to PascalCase (MyVariableName)
-- {{ name | titleCase }} - Convert to TitleCase (alias for pascalCase)
-- {{ name | kebabCase }} - Convert to kebab-case (my-variable-name)
-- {{ name | snakeCase }} - Convert to snake_case (my_variable_name)
-- {{ name | upperCase }} - Convert to UPPER_CASE (MY_VARIABLE_NAME)
-- {{ name | lower }} or {{ name | downcase }} - Convert to lowercase
-- {{ name | upper }} or {{ name | upcase }} - Convert to UPPERCASE
-
-String Manipulation:
-- {{ name | strip }} - Remove leading/trailing whitespace
-- {{ name | replace: "old", "new" }} - Replace text (e.g., replace: "Tool", "")
-- {{ name | pluralize }} - Add plural suffix (simple: book → books, class → classes)
-- {{ name | singularize }} - Remove plural suffix (simple: books → book)
-
-Chaining Filters:
-- {{ toolName | downcase | replace: "tool", "" | strip }} - Combine multiple filters
-
-Example with variables and conditionals:
-{
-  "name": "{{ packageName }}",{% if withFeature %}
-  "feature": "enabled",{% endif %}
-  "dependencies": {
-    "core": "1.0.0"{% if withOptional %},
-    "optional": "2.0.0"{% endif %}
-  }
-}
-
-Example with filters:
-export class {{ serviceName | pascalCase }} {
-  private {{ serviceName | camelCase }}: string;
-
-  constructor() {
-    this.{{ serviceName | camelCase }} = "{{ serviceName | kebabCase }}";
-  }
-}
-
-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 js_yaml.Type("tag:yaml.org,2002:str", {
-			kind: "scalar",
-			construct: (data) => data,
-			represent: (data) => {
-				return data;
-			},
-			defaultStyle: "|"
-		});
-		const LITERAL_SCHEMA = js_yaml.DEFAULT_SCHEMA.extend([LiteralBlockType]);
-		const processedConfig = this.processConfigForLiteralBlocks(config);
-		return js_yaml.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 = node_path.join(this.templatesPath, templateName);
-		await fs_extra.ensureDir(templatePath);
-		const scaffoldYamlPath = node_path.join(templatePath, "scaffold.yaml");
-		let scaffoldConfig = {};
-		if (await fs_extra.pathExists(scaffoldYamlPath)) {
-			const yamlContent$1 = await fs_extra.readFile(scaffoldYamlPath, "utf-8");
-			scaffoldConfig = js_yaml.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 featureDefinition = {
-			name: featureName,
-			description,
-			variables_schema: {
-				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
-			},
-			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_extra.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_extra.readdir(this.templatesPath, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-	}
-	/**
-	* Check if a template exists
-	*/
-	async templateExists(templateName) {
-		const templatePath = node_path.join(this.templatesPath, templateName);
-		return fs_extra.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`,
-						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 require_TemplateService.TemplateService();
-	}
-	async listScaffoldingMethods(projectPath) {
-		const absoluteProjectPath = node_path.default.resolve(projectPath);
-		const sourceTemplate = (await __agiflowai_aicode_utils.ProjectConfigResolver.resolveProjectConfig(absoluteProjectPath)).sourceTemplate;
-		const templatePath = await this.findTemplatePath(sourceTemplate);
-		if (!templatePath) throw new Error(`Template not found for sourceTemplate: ${sourceTemplate}`);
-		const fullTemplatePath = node_path.default.join(this.templatesRootPath, templatePath);
-		const scaffoldYamlPath = node_path.default.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 = js_yaml.default.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 = node_path.default.join(this.templatesRootPath, templateDir);
-			const scaffoldYamlPath = node_path.default.join(templatePath, "scaffold.yaml");
-			if (await this.fileSystem.pathExists(scaffoldYamlPath)) try {
-				const scaffoldContent = await this.fileSystem.readFile(scaffoldYamlPath, "utf8");
-				const architectConfig = js_yaml.default.load(scaffoldContent);
-				if (architectConfig.boilerplate && Array.isArray(architectConfig.boilerplate)) {
-					for (const boilerplate of architectConfig.boilerplate) if (boilerplate.name?.includes(sourceTemplate)) return templateDir;
-				}
-			} catch (error) {
-				__agiflowai_aicode_utils.log.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 = node_path.default.join(this.templatesRootPath, item);
-				if (!(await this.fileSystem.stat(itemPath)).isDirectory()) continue;
-				const scaffoldYamlPath = node_path.default.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 = node_path.default.join(itemPath, subItem);
-						if (!(await this.fileSystem.stat(subItemPath)).isDirectory()) continue;
-						const subScaffoldYamlPath = node_path.default.join(subItemPath, "scaffold.yaml");
-						if (await this.fileSystem.pathExists(subScaffoldYamlPath)) {
-							const relativePath = node_path.default.join(item, subItem);
-							templateDirs.push(relativePath);
-						}
-					}
-				} catch (error) {
-					__agiflowai_aicode_utils.log.warn(`Failed to read subdirectories in ${itemPath}:`, error);
-				}
-			}
-		} catch (error) {
-			__agiflowai_aicode_utils.log.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 Promise.resolve().then(() => require("./ScaffoldService-BvD9WvRi.cjs"))).ScaffoldService;
-		const ScaffoldConfigLoader$1 = (await Promise.resolve().then(() => require("./ScaffoldConfigLoader-DzcV5a_c.cjs"))).ScaffoldConfigLoader;
-		const VariableReplacementService$1 = (await Promise.resolve().then(() => require("./VariableReplacementService-YUpL5nAC.cjs"))).VariableReplacementService;
-		const TemplateService$1 = (await Promise.resolve().then(() => require("./TemplateService-B5EZjPB0.cjs"))).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 = node_path.default.resolve(projectPath);
-		const projectName = node_path.default.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 (monorepo) or toolkit.yaml (monolith)
-- 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 (for monorepo: containing project.json; for monolith: workspace root with toolkit.yaml)"
-				} },
-				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 directory (monorepo or monolith)
-- Set up initial configuration files (package.json, tsconfig.json, etc.)
-- Create toolkit.yaml (monolith) or project.json (monorepo) with sourceTemplate
-
-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
-- For monolith projects, use monolith: true to create at workspace root
-- For monorepo projects, files are created in targetFolder/projectName`,
-			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"
-					},
-					monolith: {
-						type: "boolean",
-						description: "If true, creates project at workspace root with toolkit.yaml. If false or omitted, creates in targetFolder/projectName with project.json (monorepo mode)"
-					},
-					targetFolderOverride: {
-						type: "string",
-						description: "Optional override for target folder. If not provided, uses boilerplate targetFolder (monorepo) or workspace root (monolith)"
-					}
-				},
-				required: ["boilerplateName", "variables"],
-				additionalProperties: false
-			}
-		};
-	}
-	/**
-	* Execute the tool
-	*/
-	async execute(args) {
-		try {
-			const { boilerplateName, variables, monolith, targetFolderOverride } = args;
-			if (!boilerplateName) throw new Error("Missing required parameter: boilerplateName");
-			if (!variables) throw new Error("Missing required parameter: variables");
-			const request = {
-				boilerplateName,
-				variables,
-				monolith,
-				targetFolderOverride
-			};
-			return { content: [{
-				type: "text",
-				text: `${(await this.boilerplateService.useBoilerplate(request)).message}
-
-IMPORTANT - Next Steps:
-1. READ the generated project files to understand their structure
-2. Review the boilerplate configuration and understand what was created
-3. If the project requires additional features, use list-scaffolding-methods to see available options
-4. Install dependencies (pnpm install) before testing or building
-5. Follow the project's README for setup instructions
-
-The boilerplate provides a starting point - you may need to add features or customize the generated code based on the project requirements.`
-			}] };
-		} 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 (for monorepo: containing project.json; for monolith: workspace root with toolkit.yaml)"
-					},
-					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}
-
-IMPORTANT - Next Steps:
-1. READ the generated files to understand their structure and template placeholders
-2. IMPLEMENT the actual business logic according to the feature's purpose (replace TODOs and template variables)
-3. REGISTER the feature in the appropriate files (e.g., import and register tools in server/index.ts, export from index.ts)
-4. TEST the implementation to ensure it works correctly
-5. Only after completing the implementation should you move to other tasks
-
-Do not skip the implementation step - the scaffolded files contain templates that need actual code.`
-			}] };
-		} 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 = node_path.default.isAbsolute(file_path) ? file_path : node_path.default.resolve(process.cwd(), file_path);
-			const dirPath = node_path.default.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 = __agiflowai_aicode_utils.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 __modelcontextprotocol_sdk_server_index_js.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(__modelcontextprotocol_sdk_types_js.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(__modelcontextprotocol_sdk_types_js.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}`);
-	});
-	server.setRequestHandler(__modelcontextprotocol_sdk_types_js.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(__modelcontextprotocol_sdk_types_js.GetPromptRequestSchema, async (request) => {
-		const { name, arguments: args } = request.params;
-		if (name === ScaffoldApplicationPrompt.PROMPT_NAME) return { messages: scaffoldApplicationPrompt.getMessages(args) };
-		if (name === ScaffoldFeaturePrompt.PROMPT_NAME) return { messages: scaffoldFeaturePrompt.getMessages(args) };
-		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
-/**
-* HTTP session manager
-*/
-var HttpFullSessionManager = class {
-	sessions = /* @__PURE__ */ new Map();
-	getSession(sessionId) {
-		return this.sessions.get(sessionId);
-	}
-	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();
-	}
-};
-/**
-* HTTP transport handler using Streamable HTTP (protocol version 2025-03-26)
-* Provides stateful session management with resumability support
-*/
-var HttpTransportHandler = class {
-	serverFactory;
-	app;
-	server = null;
-	sessionManager;
-	config;
-	constructor(serverFactory, config) {
-		this.serverFactory = typeof serverFactory === "function" ? serverFactory : () => serverFactory;
-		this.app = (0, express.default)();
-		this.sessionManager = new HttpFullSessionManager();
-		this.config = {
-			mode: config.mode,
-			port: config.port ?? 3e3,
-			host: config.host ?? "localhost"
-		};
-		this.setupMiddleware();
-		this.setupRoutes();
-	}
-	setupMiddleware() {
-		this.app.use(express.default.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).transport;
-		else if (!sessionId && (0, __modelcontextprotocol_sdk_types_js.isInitializeRequest)(req.body)) {
-			const mcpServer = this.serverFactory();
-			transport = new __modelcontextprotocol_sdk_server_streamableHttp_js.StreamableHTTPServerTransport({
-				sessionIdGenerator: () => (0, node_crypto.randomUUID)(),
-				enableJsonResponse: true,
-				onsessioninitialized: (sessionId$1) => {
-					this.sessionManager.setSession(sessionId$1, transport, mcpServer);
-				}
-			});
-			transport.onclose = () => {
-				if (transport.sessionId) this.sessionManager.deleteSession(transport.sessionId);
-			};
-			await 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).transport.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).transport.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 = (0, express.default)();
-		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.default.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 __modelcontextprotocol_sdk_server_sse_js.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 __modelcontextprotocol_sdk_server_stdio_js.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 commander.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/cli/scaffold.ts
-/**
-* Scaffold CLI command
-*/
-const scaffoldCommand = new commander.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 = node_path.default.resolve(projectPath);
-		if (!await __agiflowai_aicode_utils.ProjectConfigResolver.hasConfiguration(absolutePath)) {
-			__agiflowai_aicode_utils.messages.error(`No project configuration found in ${absolutePath}`);
-			__agiflowai_aicode_utils.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 __agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPath();
-		const methods = (await new ScaffoldingMethodsService(new FileSystemService(), templatesDir).listScaffoldingMethods(absolutePath)).methods;
-		if (methods.length === 0) {
-			__agiflowai_aicode_utils.messages.warning("No scaffolding methods available for this project.");
-			return;
-		}
-		__agiflowai_aicode_utils.print.header(`\n${__agiflowai_aicode_utils.icons.wrench} Available Scaffolding Methods for ${projectPath}:\n`);
-		for (const method of methods) {
-			__agiflowai_aicode_utils.print.highlight(`  ${method.name}`);
-			__agiflowai_aicode_utils.print.debug(`    ${method.instruction || method.description || "No description available"}`);
-			if (method.variables_schema.required && method.variables_schema.required.length > 0) __agiflowai_aicode_utils.print.debug(`    Required: ${method.variables_schema.required.join(", ")}`);
-			__agiflowai_aicode_utils.print.newline();
-		}
-	} catch (error) {
-		__agiflowai_aicode_utils.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 = node_path.default.resolve(options.project);
-		if (!await __agiflowai_aicode_utils.ProjectConfigResolver.hasConfiguration(projectPath)) {
-			__agiflowai_aicode_utils.messages.error(`No project configuration found in ${projectPath}`);
-			__agiflowai_aicode_utils.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) {
-			__agiflowai_aicode_utils.messages.error("Error parsing variables JSON:", error);
-			__agiflowai_aicode_utils.messages.hint("Example: --vars '{\"componentName\": \"UserProfile\", \"description\": \"User profile component\"}'");
-			process.exit(1);
-		}
-		const templatesDir = await __agiflowai_aicode_utils.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) {
-			__agiflowai_aicode_utils.messages.error(`Scaffold method '${featureName}' not found.`);
-			__agiflowai_aicode_utils.print.warning(`Available methods: ${methods.map((m) => m.name).join(", ")}`);
-			__agiflowai_aicode_utils.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) {
-			__agiflowai_aicode_utils.messages.error(`❌ Missing required variables: ${missing.join(", ")}`);
-			__agiflowai_aicode_utils.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}>`;
-			__agiflowai_aicode_utils.print.debug(`Example: scaffold-mcp scaffold add ${featureName} --project ${options.project} --vars '${JSON.stringify(exampleVars)}'`);
-			process.exit(1);
-		}
-		if (options.verbose) {
-			__agiflowai_aicode_utils.print.info(`🔧 Feature: ${featureName}`);
-			__agiflowai_aicode_utils.print.info(`📊 Variables: ${JSON.stringify(variables, null, 2)}`);
-			__agiflowai_aicode_utils.print.info(`📁 Project Path: ${projectPath}`);
-		}
-		__agiflowai_aicode_utils.print.info(`🚀 Adding '${featureName}' to project...`);
-		const result = await scaffoldingMethodsService.useScaffoldMethod({
-			projectPath,
-			scaffold_feature_name: featureName,
-			variables
-		});
-		if (result.success) {
-			__agiflowai_aicode_utils.messages.success("✅ Feature added successfully!");
-			console.log(result.message);
-			if (result.createdFiles && result.createdFiles.length > 0) {
-				__agiflowai_aicode_utils.print.header("\n📁 Created files:");
-				result.createdFiles.forEach((file) => __agiflowai_aicode_utils.print.debug(`   - ${file}`));
-			}
-			if (result.warnings && result.warnings.length > 0) {
-				__agiflowai_aicode_utils.messages.warning("\n⚠️  Warnings:");
-				result.warnings.forEach((warning) => __agiflowai_aicode_utils.print.debug(`   - ${warning}`));
-			}
-			__agiflowai_aicode_utils.print.header("\n📋 Next steps:");
-			__agiflowai_aicode_utils.print.debug("   - Review the generated files");
-			__agiflowai_aicode_utils.print.debug("   - Update imports if necessary");
-			__agiflowai_aicode_utils.print.debug("   - Run tests to ensure everything works");
-		} else {
-			__agiflowai_aicode_utils.messages.error(`❌ Failed to add feature: ${result.message}`);
-			process.exit(1);
-		}
-	} catch (error) {
-		__agiflowai_aicode_utils.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 = node_path.default.resolve(options.project);
-		if (!await __agiflowai_aicode_utils.ProjectConfigResolver.hasConfiguration(projectPath)) {
-			__agiflowai_aicode_utils.messages.error(`No project configuration found in ${projectPath}`);
-			__agiflowai_aicode_utils.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 __agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPath();
-		const method = (await new ScaffoldingMethodsService(new FileSystemService(), templatesDir).listScaffoldingMethods(projectPath)).methods.find((m) => m.name === featureName);
-		if (!method) {
-			__agiflowai_aicode_utils.messages.error(`❌ Scaffold method '${featureName}' not found.`);
-			process.exit(1);
-		}
-		__agiflowai_aicode_utils.print.header(`\n🔧 Scaffold Method: ${method.name}\n`);
-		__agiflowai_aicode_utils.print.debug(`Description: ${method.description}`);
-		__agiflowai_aicode_utils.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) {
-			__agiflowai_aicode_utils.print.header("\n📁 Files to be created:");
-			includes.forEach((include) => {
-				const parts = include.split(">>");
-				if (parts.length === 2) __agiflowai_aicode_utils.print.debug(`  - ${parts[1].trim()}`);
-				else __agiflowai_aicode_utils.print.debug(`  - ${include}`);
-			});
-		}
-	} catch (error) {
-		__agiflowai_aicode_utils.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 commander.Command();
-	program.name("scaffold-mcp").description("MCP server for scaffolding applications with boilerplate templates").version("0.4.0");
-	program.addCommand(mcpServeCommand);
-	program.addCommand(boilerplateCommand);
-	program.addCommand(scaffoldCommand);
-	program.addCommand(initCommand);
-	program.addCommand(addCommand);
-	await program.parseAsync(process.argv);
-}
-main();
-
-//#endregion
+exports.BoilerplateGeneratorService = require_stdio.BoilerplateGeneratorService;
+exports.BoilerplateService = require_stdio.BoilerplateService;
+exports.FileSystemService = require_stdio.FileSystemService;
+exports.GenerateBoilerplateFileTool = require_stdio.GenerateBoilerplateFileTool;
+exports.GenerateBoilerplateTool = require_stdio.GenerateBoilerplateTool;
+exports.GenerateFeatureScaffoldTool = require_stdio.GenerateFeatureScaffoldTool;
+exports.HttpTransportHandler = require_stdio.HttpTransportHandler;
+exports.ListBoilerplatesTool = require_stdio.ListBoilerplatesTool;
+exports.ListScaffoldingMethodsTool = require_stdio.ListScaffoldingMethodsTool;
+exports.ScaffoldConfigLoader = require_ScaffoldConfigLoader.ScaffoldConfigLoader;
+exports.ScaffoldGeneratorService = require_stdio.ScaffoldGeneratorService;
+exports.ScaffoldProcessingService = require_ScaffoldService.ScaffoldProcessingService;
+exports.ScaffoldService = require_ScaffoldService.ScaffoldService;
+exports.ScaffoldingMethodsService = require_stdio.ScaffoldingMethodsService;
+exports.SseTransportHandler = require_stdio.SseTransportHandler;
+exports.StdioTransportHandler = require_stdio.StdioTransportHandler;
+exports.TemplateService = require_TemplateService.TemplateService;
+exports.UseBoilerplateTool = require_stdio.UseBoilerplateTool;
+exports.UseScaffoldMethodTool = require_stdio.UseScaffoldMethodTool;
+exports.VariableReplacementService = require_VariableReplacementService.VariableReplacementService;
+exports.WriteToFileTool = require_stdio.WriteToFileTool;
+exports.cloneRepository = cloneRepository;
+exports.cloneSubdirectory = cloneSubdirectory;
+exports.fetchGitHubDirectoryContents = fetchGitHubDirectoryContents;
+exports.findWorkspaceRoot = findWorkspaceRoot;
+exports.parseGitHubUrl = parseGitHubUrl;