@agiflowai/scaffold-mcp 0.5.0 → 1.0.0

package/dist/stdio-Dmpwju2k.js

@@ -0,0 +1,2074 @@
+import { ScaffoldConfigLoader } from "./ScaffoldConfigLoader-CI0T6zdG.js";
+import { ScaffoldService } from "./ScaffoldService-QgQKHMM-.js";
+import { TemplateService } from "./TemplateService-CiZJA06s.js";
+import { VariableReplacementService } from "./VariableReplacementService-B3qARIC9.js";
+import * as path$1 from "node:path";
+import path from "node:path";
+import { ProjectConfigResolver, log } from "@agiflowai/aicode-utils";
+import * as fs$1 from "fs-extra";
+import fs from "fs-extra";
+import { execa } from "execa";
+import { jsonSchemaToZod } from "@composio/json-schema-to-zod";
+import * as yaml$1 from "js-yaml";
+import yaml from "js-yaml";
+import { z } from "zod";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import { randomUUID } from "node:crypto";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import express from "express";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+//#region src/utils/git.ts
+/**
+* Execute a git command safely using execa to prevent command injection
+*/
+async function execGit(args, cwd) {
+	try {
+		await execa("git", args, { cwd });
+	} catch (error) {
+		const execaError = error;
+		throw new Error(`Git command failed: ${execaError.stderr || execaError.message}`);
+	}
+}
+/**
+* Find the workspace root by searching upwards for .git folder
+* Returns null if no .git folder is found (indicating a new project setup is needed)
+*/
+async function findWorkspaceRoot(startPath = process.cwd()) {
+	let currentPath = path.resolve(startPath);
+	const rootPath = path.parse(currentPath).root;
+	while (true) {
+		const gitPath = path.join(currentPath, ".git");
+		if (await fs$1.pathExists(gitPath)) return currentPath;
+		if (currentPath === rootPath) return null;
+		currentPath = path.dirname(currentPath);
+	}
+}
+/**
+* Parse GitHub URL to detect if it's a subdirectory
+* Supports formats:
+* - https://github.com/user/repo
+* - https://github.com/user/repo/tree/branch/path/to/dir
+* - https://github.com/user/repo/tree/main/path/to/dir
+*/
+function parseGitHubUrl(url) {
+	const treeMatch = url.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)\/(.+)$/);
+	const blobMatch = url.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/blob\/([^/]+)\/(.+)$/);
+	const rootMatch = url.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?$/);
+	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],
+			isSubdirectory: true
+		};
+	}
+	if (rootMatch) return {
+		owner: rootMatch[1],
+		repo: rootMatch[2],
+		repoUrl: `https://github.com/${rootMatch[1]}/${rootMatch[2]}.git`,
+		isSubdirectory: false
+	};
+	return {
+		repoUrl: url,
+		isSubdirectory: false
+	};
+}
+/**
+* Clone a subdirectory from a git repository using sparse checkout
+*/
+async function cloneSubdirectory(repoUrl, branch, subdirectory, targetFolder) {
+	const tempFolder = `${targetFolder}.tmp`;
+	try {
+		await execGit(["init", tempFolder]);
+		await execGit([
+			"remote",
+			"add",
+			"origin",
+			repoUrl
+		], tempFolder);
+		await execGit([
+			"config",
+			"core.sparseCheckout",
+			"true"
+		], tempFolder);
+		const sparseCheckoutFile = path.join(tempFolder, ".git", "info", "sparse-checkout");
+		await fs$1.writeFile(sparseCheckoutFile, `${subdirectory}\n`);
+		await execGit([
+			"pull",
+			"--depth=1",
+			"origin",
+			branch
+		], tempFolder);
+		const sourceDir = path.join(tempFolder, subdirectory);
+		if (!await fs$1.pathExists(sourceDir)) throw new Error(`Subdirectory '${subdirectory}' not found in repository at branch '${branch}'`);
+		if (await fs$1.pathExists(targetFolder)) throw new Error(`Target folder already exists: ${targetFolder}`);
+		await fs$1.move(sourceDir, targetFolder);
+		await fs$1.remove(tempFolder);
+	} catch (error) {
+		if (await fs$1.pathExists(tempFolder)) await fs$1.remove(tempFolder);
+		throw error;
+	}
+}
+/**
+* Clone entire repository
+*/
+async function cloneRepository(repoUrl, targetFolder) {
+	await execGit([
+		"clone",
+		repoUrl,
+		targetFolder
+	]);
+	const gitFolder = path.join(targetFolder, ".git");
+	if (await fs$1.pathExists(gitFolder)) await fs$1.remove(gitFolder);
+}
+/**
+* Fetch directory listing from GitHub API
+*/
+async function fetchGitHubDirectoryContents(owner, repo, path$2, branch = "main") {
+	const url = `https://api.github.com/repos/${owner}/${repo}/contents/${path$2}?ref=${branch}`;
+	const response = await fetch(url, { headers: {
+		Accept: "application/vnd.github.v3+json",
+		"User-Agent": "scaffold-mcp"
+	} });
+	if (!response.ok) throw new Error(`Failed to fetch directory contents: ${response.statusText}`);
+	const data = await response.json();
+	if (!Array.isArray(data)) throw new Error("Expected directory but got file");
+	return data.map((item) => ({
+		name: item.name,
+		type: item.type,
+		path: item.path
+	}));
+}
+
+//#endregion
+//#region src/services/FileSystemService.ts
+var FileSystemService = class {
+	async pathExists(path$2) {
+		return fs.pathExists(path$2);
+	}
+	async readFile(path$2, encoding = "utf8") {
+		return fs.readFile(path$2, encoding);
+	}
+	async readJson(path$2) {
+		return fs.readJson(path$2);
+	}
+	async writeFile(path$2, content, encoding = "utf8") {
+		return fs.writeFile(path$2, content, encoding);
+	}
+	async ensureDir(path$2) {
+		return fs.ensureDir(path$2);
+	}
+	async copy(src, dest) {
+		return fs.copy(src, dest);
+	}
+	async readdir(path$2) {
+		return fs.readdir(path$2);
+	}
+	async stat(path$2) {
+		return fs.stat(path$2);
+	}
+};
+
+//#endregion
+//#region src/services/BoilerplateService.ts
+var BoilerplateService = class {
+	templatesPath;
+	templateService;
+	scaffoldService;
+	constructor(templatesPath) {
+		this.templatesPath = templatesPath;
+		this.templateService = new TemplateService();
+		const fileSystemService = new FileSystemService();
+		this.scaffoldService = new ScaffoldService(fileSystemService, new ScaffoldConfigLoader(fileSystemService, this.templateService), new 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 = path$1.join(this.templatesPath, templatePath, "scaffold.yaml");
+			if (fs$1.existsSync(scaffoldYamlPath)) try {
+				const scaffoldContent = fs$1.readFileSync(scaffoldYamlPath, "utf8");
+				const scaffoldConfig = yaml$1.load(scaffoldContent);
+				if (scaffoldConfig.boilerplate) for (const boilerplate of scaffoldConfig.boilerplate) {
+					if (!boilerplate.targetFolder) {
+						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) {
+				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$1.existsSync(dir)) return;
+			const items = fs$1.readdirSync(dir);
+			const hasPackageJson = items.includes("package.json") || items.includes("package.json.liquid");
+			const hasScaffoldYaml = items.includes("scaffold.yaml");
+			if (hasPackageJson && hasScaffoldYaml) templateDirs.push(baseDir);
+			for (const item of items) {
+				const itemPath = path$1.join(dir, item);
+				if (fs$1.statSync(itemPath).isDirectory() && !item.startsWith(".") && item !== "node_modules") findTemplates(itemPath, baseDir ? path$1.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 ProjectConfigResolver.createToolkitYaml(boilerplate.template_path);
+			else {
+				const projectPath = path$1.join(targetFolder, folderName);
+				await 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 {
+			jsonSchemaToZod(boilerplate.variables_schema).parse(variables);
+			return {
+				isValid: true,
+				errors: []
+			};
+		} catch (error) {
+			if (error instanceof z.ZodError) {
+				const zodErrors = error.errors.map((err) => {
+					return `${err.path.length > 0 ? err.path.join(".") : "root"}: ${err.message}`;
+				});
+				errors.push(...zodErrors);
+			} else errors.push(`Validation error: ${error instanceof Error ? error.message : String(error)}`);
+			return {
+				isValid: false,
+				errors
+			};
+		}
+	}
+};
+
+//#endregion
+//#region src/services/BoilerplateGeneratorService.ts
+/**
+* Service for generating boilerplate configurations in scaffold.yaml files
+*/
+var BoilerplateGeneratorService = class {
+	templatesPath;
+	constructor(templatesPath) {
+		this.templatesPath = templatesPath;
+	}
+	/**
+	* Custom YAML dumper that forces literal block style (|) for description and instruction fields
+	*/
+	dumpYamlWithLiteralBlocks(config) {
+		const LiteralBlockType = new yaml$1.Type("tag:yaml.org,2002:str", {
+			kind: "scalar",
+			construct: (data) => data,
+			represent: (data) => {
+				return data;
+			},
+			defaultStyle: "|"
+		});
+		const LITERAL_SCHEMA = yaml$1.DEFAULT_SCHEMA.extend([LiteralBlockType]);
+		const processedConfig = this.processConfigForLiteralBlocks(config);
+		return yaml$1.dump(processedConfig, {
+			schema: LITERAL_SCHEMA,
+			indent: 2,
+			lineWidth: -1,
+			noRefs: true,
+			sortKeys: false,
+			styles: { "!!str": "literal" },
+			replacer: (key, value) => {
+				if ((key === "description" || key === "instruction") && typeof value === "string") return value;
+				return value;
+			}
+		});
+	}
+	/**
+	* Process config to ensure description and instruction use literal block style
+	*/
+	processConfigForLiteralBlocks(config) {
+		const processed = JSON.parse(JSON.stringify(config));
+		if (processed.boilerplate) processed.boilerplate = processed.boilerplate.map((bp) => {
+			const newBp = { ...bp };
+			if (newBp.description && typeof newBp.description === "string") newBp.description = this.ensureMultilineFormat(newBp.description);
+			if (newBp.instruction && typeof newBp.instruction === "string") newBp.instruction = this.ensureMultilineFormat(newBp.instruction);
+			return newBp;
+		});
+		if (processed.features) processed.features = processed.features.map((feature) => {
+			const newFeature = { ...feature };
+			if (newFeature.description && typeof newFeature.description === "string") newFeature.description = this.ensureMultilineFormat(newFeature.description);
+			if (newFeature.instruction && typeof newFeature.instruction === "string") newFeature.instruction = this.ensureMultilineFormat(newFeature.instruction);
+			return newFeature;
+		});
+		return processed;
+	}
+	/**
+	* Ensure string is properly formatted for YAML literal blocks
+	*/
+	ensureMultilineFormat(text) {
+		return text.trim();
+	}
+	/**
+	* Generate or update a boilerplate configuration in scaffold.yaml
+	*/
+	async generateBoilerplate(options) {
+		const { templateName, boilerplateName, description, instruction, targetFolder, variables, includes = [] } = options;
+		const templatePath = path$1.join(this.templatesPath, templateName);
+		await fs$1.ensureDir(templatePath);
+		const scaffoldYamlPath = path$1.join(templatePath, "scaffold.yaml");
+		let scaffoldConfig = {};
+		if (await fs$1.pathExists(scaffoldYamlPath)) {
+			const yamlContent$1 = await fs$1.readFile(scaffoldYamlPath, "utf-8");
+			scaffoldConfig = yaml$1.load(yamlContent$1);
+		}
+		if (!scaffoldConfig.boilerplate) scaffoldConfig.boilerplate = [];
+		if (scaffoldConfig.boilerplate.findIndex((b) => b.name === boilerplateName) !== -1) return {
+			success: false,
+			message: `Boilerplate '${boilerplateName}' already exists in ${scaffoldYamlPath}`
+		};
+		const requiredVars = variables.filter((v) => v.required).map((v) => v.name);
+		const 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$1.writeFile(scaffoldYamlPath, yamlContent, "utf-8");
+		return {
+			success: true,
+			message: `Boilerplate '${boilerplateName}' added to ${scaffoldYamlPath}`,
+			templatePath,
+			scaffoldYamlPath
+		};
+	}
+	/**
+	* List all templates (directories in templates folder)
+	*/
+	async listTemplates() {
+		return (await fs$1.readdir(this.templatesPath, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+	}
+	/**
+	* Check if a template exists
+	*/
+	async templateExists(templateName) {
+		const templatePath = path$1.join(this.templatesPath, templateName);
+		return fs$1.pathExists(templatePath);
+	}
+	/**
+	* Create or update a template file for a boilerplate
+	*/
+	async createTemplateFile(options) {
+		const { templateName, filePath, content, sourceFile, header } = options;
+		const templatePath = path$1.join(this.templatesPath, templateName);
+		if (!await fs$1.pathExists(templatePath)) return {
+			success: false,
+			message: `Template directory '${templateName}' does not exist at ${templatePath}`
+		};
+		let fileContent = content || "";
+		if (sourceFile) {
+			if (!await fs$1.pathExists(sourceFile)) return {
+				success: false,
+				message: `Source file '${sourceFile}' does not exist`
+			};
+			fileContent = await fs$1.readFile(sourceFile, "utf-8");
+		}
+		if (!fileContent && !sourceFile) return {
+			success: false,
+			message: "Either content or sourceFile must be provided"
+		};
+		const templateFilePath = filePath.endsWith(".liquid") ? filePath : `${filePath}.liquid`;
+		const fullPath = path$1.join(templatePath, templateFilePath);
+		await fs$1.ensureDir(path$1.dirname(fullPath));
+		let finalContent = fileContent;
+		if (header) finalContent = `${header}\n\n${fileContent}`;
+		await fs$1.writeFile(fullPath, finalContent, "utf-8");
+		return {
+			success: true,
+			message: "Template file created successfully",
+			filePath: templateFilePath,
+			fullPath
+		};
+	}
+};
+
+//#endregion
+//#region src/tools/GenerateBoilerplateFileTool.ts
+/**
+* Tool to generate template files for boilerplates and features
+*/
+var GenerateBoilerplateFileTool = class GenerateBoilerplateFileTool {
+	static TOOL_NAME = "generate-boilerplate-file";
+	boilerplateGeneratorService;
+	constructor(templatesPath) {
+		this.boilerplateGeneratorService = new BoilerplateGeneratorService(templatesPath);
+	}
+	/**
+	* Get the tool definition for MCP
+	*/
+	getDefinition() {
+		return {
+			name: GenerateBoilerplateFileTool.TOOL_NAME,
+			description: `Create or update template files for boilerplates or features in the specified template directory.
+
+This tool:
+- Creates template files with .liquid extension for variable substitution
+- Supports creating nested directory structures
+- Can create files from source files (copying and converting to templates)
+- Validates that the template directory exists
+- Works for both boilerplate includes and feature scaffold includes
+
+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 yaml$1.Type("tag:yaml.org,2002:str", {
+			kind: "scalar",
+			construct: (data) => data,
+			represent: (data) => {
+				return data;
+			},
+			defaultStyle: "|"
+		});
+		const LITERAL_SCHEMA = yaml$1.DEFAULT_SCHEMA.extend([LiteralBlockType]);
+		const processedConfig = this.processConfigForLiteralBlocks(config);
+		return yaml$1.dump(processedConfig, {
+			schema: LITERAL_SCHEMA,
+			indent: 2,
+			lineWidth: -1,
+			noRefs: true,
+			sortKeys: false,
+			styles: { "!!str": "literal" },
+			replacer: (key, value) => {
+				if ((key === "description" || key === "instruction") && typeof value === "string") return value;
+				return value;
+			}
+		});
+	}
+	/**
+	* Process config to ensure description and instruction use literal block style
+	*/
+	processConfigForLiteralBlocks(config) {
+		const processed = JSON.parse(JSON.stringify(config));
+		if (processed.boilerplate) processed.boilerplate = processed.boilerplate.map((bp) => {
+			const newBp = { ...bp };
+			if (newBp.description && typeof newBp.description === "string") newBp.description = this.ensureMultilineFormat(newBp.description);
+			if (newBp.instruction && typeof newBp.instruction === "string") newBp.instruction = this.ensureMultilineFormat(newBp.instruction);
+			return newBp;
+		});
+		if (processed.features) processed.features = processed.features.map((feature) => {
+			const newFeature = { ...feature };
+			if (newFeature.description && typeof newFeature.description === "string") newFeature.description = this.ensureMultilineFormat(newFeature.description);
+			if (newFeature.instruction && typeof newFeature.instruction === "string") newFeature.instruction = this.ensureMultilineFormat(newFeature.instruction);
+			return newFeature;
+		});
+		return processed;
+	}
+	/**
+	* Ensure string is properly formatted for YAML literal blocks
+	*/
+	ensureMultilineFormat(text) {
+		return text.trim();
+	}
+	/**
+	* Generate or update a feature configuration in scaffold.yaml
+	*/
+	async generateFeatureScaffold(options) {
+		const { templateName, featureName, description, instruction, variables, includes = [], patterns = [] } = options;
+		const templatePath = path$1.join(this.templatesPath, templateName);
+		await fs$1.ensureDir(templatePath);
+		const scaffoldYamlPath = path$1.join(templatePath, "scaffold.yaml");
+		let scaffoldConfig = {};
+		if (await fs$1.pathExists(scaffoldYamlPath)) {
+			const yamlContent$1 = await fs$1.readFile(scaffoldYamlPath, "utf-8");
+			scaffoldConfig = yaml$1.load(yamlContent$1);
+		}
+		if (!scaffoldConfig.features) scaffoldConfig.features = [];
+		if (scaffoldConfig.features.findIndex((f) => f.name === featureName) !== -1) return {
+			success: false,
+			message: `Feature '${featureName}' already exists in ${scaffoldYamlPath}`
+		};
+		const requiredVars = variables.filter((v) => v.required).map((v) => v.name);
+		const 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$1.writeFile(scaffoldYamlPath, yamlContent, "utf-8");
+		return {
+			success: true,
+			message: `Feature '${featureName}' added to ${scaffoldYamlPath}`,
+			templatePath,
+			scaffoldYamlPath
+		};
+	}
+	/**
+	* List all templates (directories in templates folder)
+	*/
+	async listTemplates() {
+		return (await fs$1.readdir(this.templatesPath, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+	}
+	/**
+	* Check if a template exists
+	*/
+	async templateExists(templateName) {
+		const templatePath = path$1.join(this.templatesPath, templateName);
+		return fs$1.pathExists(templatePath);
+	}
+};
+
+//#endregion
+//#region src/tools/GenerateFeatureScaffoldTool.ts
+/**
+* Tool to generate a new feature scaffold configuration in scaffold.yaml
+*/
+var GenerateFeatureScaffoldTool = class GenerateFeatureScaffoldTool {
+	static TOOL_NAME = "generate-feature-scaffold";
+	scaffoldGeneratorService;
+	constructor(templatesPath) {
+		this.scaffoldGeneratorService = new ScaffoldGeneratorService(templatesPath);
+	}
+	/**
+	* Get the tool definition for MCP
+	*/
+	getDefinition() {
+		return {
+			name: GenerateFeatureScaffoldTool.TOOL_NAME,
+			description: `Add a new feature scaffold configuration to a template's scaffold.yaml file.
+
+This tool:
+- Creates or updates scaffold.yaml in the specified template directory
+- Adds a feature entry with proper schema following the nextjs-15 pattern
+- Validates the feature name doesn't already exist
+- Creates the template directory if it doesn't exist
+
+Use this to add custom feature scaffolds (pages, components, services, etc.) for frameworks not yet supported or for your specific project needs.`,
+			inputSchema: {
+				type: "object",
+				properties: {
+					templateName: {
+						type: "string",
+						description: "Name of the template folder (kebab-case, e.g., \"nextjs-15\")"
+					},
+					featureName: {
+						type: "string",
+						description: "Name of the feature (kebab-case, e.g., \"scaffold-nextjs-page\")"
+					},
+					description: {
+						type: "string",
+						description: `Detailed description of what this feature creates and its key capabilities.
+
+STRUCTURE (2-3 sentences):
+- Sentence 1: What type of code it generates (component, page, service, etc.)
+- Sentence 2: Key features or capabilities included
+- Sentence 3: Primary use cases or when to use it
+
+Example: "Generate a new service class for TypeScript libraries following best practices. Creates a service class with interface, implementation, and unit tests. Perfect for creating reusable service modules with dependency injection patterns."`
+					},
+					instruction: {
+						type: "string",
+						description: `Optional detailed instructions about the generated files, their purposes, and how to work with them.
+
+STRUCTURE (Concise multi-aspect guide):
+
+1. **Pattern explanation**: Describe the architectural pattern used
+2. **File organization**: Where files should be placed
+3. **Naming conventions**: How to name things (PascalCase, camelCase, etc.)
+4. **Usage guidelines**: How to use the generated code
+5. **Testing approach**: How to test the feature
+
+Example: "Services follow a class-based pattern with optional interface separation. The service class implements business logic and can be dependency injected. Place services in src/services/ directory. For services with interfaces, define the interface in src/types/interfaces/ for better separation of concerns. Service names should be PascalCase and end with 'Service' suffix. Write comprehensive unit tests for all public methods."`
+					},
+					variables: {
+						type: "array",
+						description: "Array of variable definitions for the feature",
+						items: {
+							type: "object",
+							properties: {
+								name: {
+									type: "string",
+									description: "Variable name (camelCase)"
+								},
+								description: {
+									type: "string",
+									description: "Variable description"
+								},
+								type: {
+									type: "string",
+									enum: [
+										"string",
+										"number",
+										"boolean"
+									],
+									description: "Variable type"
+								},
+								required: {
+									type: "boolean",
+									description: "Whether this variable is required"
+								},
+								default: { description: "Optional default value for the variable" }
+							},
+							required: [
+								"name",
+								"description",
+								"type",
+								"required"
+							]
+						}
+					},
+					includes: {
+						type: "array",
+						description: `Array of specific file paths to include in the feature (highly recommended to list explicitly).
+
+Supports advanced syntax:
+- Basic: "src/app/page/page.tsx" - Always included
+- Conditional: "src/app/page/layout.tsx?withLayout=true" - Only included when withLayout variable is true
+- Multiple conditions: "file.tsx?withLayout=true&withTests=true" - Use & to combine conditions
+- Path mapping: "source.tsx->target/path.tsx" - Map source template file to different target path
+- Combined: "source.tsx->{{ pagePath }}/page.tsx?withPage=true" - Combine path mapping with variables and conditions
+
+Examples:
+- ["src/components/Button.tsx", "src/components/Button.test.tsx"] - Explicit file list (recommended)
+- ["src/app/page/page.tsx", "src/app/page/layout.tsx?withLayout=true"] - Conditional include
+- ["template.tsx->src/app/{{ pagePath }}/page.tsx"] - Dynamic path with variables
+
+Best practices:
+- List each file explicitly for clarity and control
+- Use relative paths from the template root
+- Use conditional includes with ?variableName=value for optional files
+- Use path mapping with -> when source and target paths differ
+- Use {{ variableName }} in target paths for dynamic file placement
+- Avoid wildcards unless you have a good reason`,
+						items: { type: "string" }
+					},
+					patterns: {
+						type: "array",
+						description: `Optional array of glob patterns to match existing files that this feature works with.
+
+Used to help identify where this feature can be applied in a project.
+
+Examples:
+- ["src/app/**/page.tsx", "src/app/**/layout.tsx"] - Next.js app router files
+- ["src/components/**/*.tsx"] - React component files
+- ["src/services/**/*.ts"] - Service files
+
+Best practices:
+- Use glob patterns that match the file types this feature works with
+- Keep patterns specific enough to be meaningful but broad enough to be useful
+- Consider both the feature's output and input files`,
+						items: { type: "string" }
+					}
+				},
+				required: [
+					"templateName",
+					"featureName",
+					"description",
+					"variables"
+				],
+				additionalProperties: false
+			}
+		};
+	}
+	/**
+	* Execute the tool
+	*/
+	async execute(args) {
+		try {
+			const result = await this.scaffoldGeneratorService.generateFeatureScaffold(args);
+			if (!result.success) return {
+				content: [{
+					type: "text",
+					text: result.message
+				}],
+				isError: true
+			};
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					message: result.message,
+					templatePath: result.templatePath,
+					scaffoldYamlPath: result.scaffoldYamlPath,
+					nextSteps: [
+						"Use generate-boilerplate-file tool to create template files for the includes array",
+						"Customize the template files with Liquid variable placeholders ({{ variableName }})",
+						"Create the generator file if it uses custom logic (referenced in the generator field)",
+						`Test with: scaffold-mcp feature create ${args.featureName} --vars '{"appName":"test"}'`
+					]
+				}, null, 2)
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error generating feature scaffold: ${error instanceof Error ? error.message : String(error)}`
+				}],
+				isError: true
+			};
+		}
+	}
+};
+
+//#endregion
+//#region src/tools/ListBoilerplatesTool.ts
+var ListBoilerplatesTool = class ListBoilerplatesTool {
+	static TOOL_NAME = "list-boilerplates";
+	boilerplateService;
+	constructor(templatesPath) {
+		this.boilerplateService = new BoilerplateService(templatesPath);
+	}
+	/**
+	* Get the tool definition for MCP
+	*/
+	getDefinition() {
+		return {
+			name: ListBoilerplatesTool.TOOL_NAME,
+			description: `Lists all available project boilerplates for creating new applications, APIs, or packages in the monorepo.
+
+Each boilerplate includes:
+- Complete project template with starter files
+- Variable schema for customization
+- Target directory information
+- Required and optional configuration options
+
+Use this FIRST when creating new projects to understand available templates and their requirements.`,
+			inputSchema: {
+				type: "object",
+				properties: {},
+				additionalProperties: false
+			}
+		};
+	}
+	/**
+	* Execute the tool
+	*/
+	async execute(_args = {}) {
+		try {
+			const result = await this.boilerplateService.listBoilerplates();
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error listing boilerplates: ${error instanceof Error ? error.message : String(error)}`
+				}],
+				isError: true
+			};
+		}
+	}
+};
+
+//#endregion
+//#region src/services/ScaffoldingMethodsService.ts
+var ScaffoldingMethodsService = class {
+	templateService;
+	constructor(fileSystem, templatesRootPath) {
+		this.fileSystem = fileSystem;
+		this.templatesRootPath = templatesRootPath;
+		this.templateService = new TemplateService();
+	}
+	async listScaffoldingMethods(projectPath) {
+		const absoluteProjectPath = path.resolve(projectPath);
+		const sourceTemplate = (await ProjectConfigResolver.resolveProjectConfig(absoluteProjectPath)).sourceTemplate;
+		const templatePath = await this.findTemplatePath(sourceTemplate);
+		if (!templatePath) throw new Error(`Template not found for sourceTemplate: ${sourceTemplate}`);
+		const fullTemplatePath = path.join(this.templatesRootPath, templatePath);
+		const scaffoldYamlPath = path.join(fullTemplatePath, "scaffold.yaml");
+		if (!await this.fileSystem.pathExists(scaffoldYamlPath)) throw new Error(`scaffold.yaml not found at ${scaffoldYamlPath}`);
+		const scaffoldContent = await this.fileSystem.readFile(scaffoldYamlPath, "utf8");
+		const architectConfig = yaml.load(scaffoldContent);
+		const methods = [];
+		if (architectConfig.features && Array.isArray(architectConfig.features)) architectConfig.features.forEach((feature) => {
+			if (feature.name) methods.push({
+				name: feature.name,
+				description: feature.description || "",
+				instruction: feature.instruction || "",
+				variables_schema: feature.variables_schema || {
+					type: "object",
+					properties: {},
+					required: [],
+					additionalProperties: false
+				},
+				generator: feature.generator
+			});
+		});
+		return {
+			sourceTemplate,
+			templatePath,
+			methods
+		};
+	}
+	/**
+	* Gets scaffolding methods with instructions rendered using provided variables
+	*/
+	async listScaffoldingMethodsWithVariables(projectPath, variables) {
+		const result = await this.listScaffoldingMethods(projectPath);
+		const processedMethods = result.methods.map((method) => ({
+			...method,
+			instruction: method.instruction ? this.processScaffoldInstruction(method.instruction, variables) : void 0
+		}));
+		return {
+			...result,
+			methods: processedMethods
+		};
+	}
+	/**
+	* Processes scaffold instruction with template service
+	*/
+	processScaffoldInstruction(instruction, variables) {
+		if (this.templateService.containsTemplateVariables(instruction)) return this.templateService.renderString(instruction, variables);
+		return instruction;
+	}
+	async findTemplatePath(sourceTemplate) {
+		const templateDirs = await this.discoverTemplateDirs();
+		if (templateDirs.includes(sourceTemplate)) return sourceTemplate;
+		for (const templateDir of templateDirs) {
+			const templatePath = path.join(this.templatesRootPath, templateDir);
+			const scaffoldYamlPath = path.join(templatePath, "scaffold.yaml");
+			if (await this.fileSystem.pathExists(scaffoldYamlPath)) try {
+				const scaffoldContent = await this.fileSystem.readFile(scaffoldYamlPath, "utf8");
+				const architectConfig = yaml.load(scaffoldContent);
+				if (architectConfig.boilerplate && Array.isArray(architectConfig.boilerplate)) {
+					for (const boilerplate of architectConfig.boilerplate) if (boilerplate.name?.includes(sourceTemplate)) return templateDir;
+				}
+			} catch (error) {
+				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 = path.join(this.templatesRootPath, item);
+				if (!(await this.fileSystem.stat(itemPath)).isDirectory()) continue;
+				const scaffoldYamlPath = path.join(itemPath, "scaffold.yaml");
+				if (await this.fileSystem.pathExists(scaffoldYamlPath)) {
+					templateDirs.push(item);
+					continue;
+				}
+				try {
+					const subItems = await this.fileSystem.readdir(itemPath);
+					for (const subItem of subItems) {
+						const subItemPath = path.join(itemPath, subItem);
+						if (!(await this.fileSystem.stat(subItemPath)).isDirectory()) continue;
+						const subScaffoldYamlPath = path.join(subItemPath, "scaffold.yaml");
+						if (await this.fileSystem.pathExists(subScaffoldYamlPath)) {
+							const relativePath = path.join(item, subItem);
+							templateDirs.push(relativePath);
+						}
+					}
+				} catch (error) {
+					log.warn(`Failed to read subdirectories in ${itemPath}:`, error);
+				}
+			}
+		} catch (error) {
+			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 import("./ScaffoldService-DVsusUh5.js")).ScaffoldService;
+		const ScaffoldConfigLoader$1 = (await import("./ScaffoldConfigLoader-DhthV6xq.js")).ScaffoldConfigLoader;
+		const VariableReplacementService$1 = (await import("./VariableReplacementService-D8C-IsP-.js")).VariableReplacementService;
+		const TemplateService$1 = (await import("./TemplateService-DropYdp8.js")).TemplateService;
+		const templateService = new TemplateService$1();
+		const scaffoldConfigLoader = new ScaffoldConfigLoader$1(this.fileSystem, templateService);
+		const variableReplacer = new VariableReplacementService$1(this.fileSystem, templateService);
+		const scaffoldService = new ScaffoldService$1(this.fileSystem, scaffoldConfigLoader, variableReplacer, this.templatesRootPath);
+		const absoluteProjectPath = path.resolve(projectPath);
+		const projectName = path.basename(absoluteProjectPath);
+		const result = await scaffoldService.useFeature({
+			projectPath: absoluteProjectPath,
+			templateFolder: scaffoldingMethods.templatePath,
+			featureName: scaffold_feature_name,
+			variables: {
+				...variables,
+				appPath: absoluteProjectPath,
+				appName: projectName
+			}
+		});
+		if (!result.success) throw new Error(result.message);
+		return {
+			success: true,
+			message: `
+Successfully scaffolded ${scaffold_feature_name} in ${projectPath}.
+Please follow this **instruction**: \n ${method.instruction}.
+-> Create or update the plan based on the instruction.
+`,
+			warnings: result.warnings,
+			createdFiles: result.createdFiles,
+			existingFiles: result.existingFiles
+		};
+	}
+};
+
+//#endregion
+//#region src/tools/ListScaffoldingMethodsTool.ts
+var ListScaffoldingMethodsTool = class ListScaffoldingMethodsTool {
+	static TOOL_NAME = "list-scaffolding-methods";
+	fileSystemService;
+	scaffoldingMethodsService;
+	constructor(templatesPath) {
+		this.fileSystemService = new FileSystemService();
+		this.scaffoldingMethodsService = new ScaffoldingMethodsService(this.fileSystemService, templatesPath);
+	}
+	/**
+	* Get the tool definition for MCP
+	*/
+	getDefinition() {
+		return {
+			name: ListScaffoldingMethodsTool.TOOL_NAME,
+			description: `Lists all available scaffolding methods (features) that can be added to an existing project.
+
+This tool:
+- Reads the project's sourceTemplate from project.json (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 = path.isAbsolute(file_path) ? file_path : path.resolve(process.cwd(), file_path);
+			const dirPath = path.dirname(resolvedPath);
+			await this.fileSystemService.ensureDir(dirPath);
+			await this.fileSystemService.writeFile(resolvedPath, content);
+			return { content: [{
+				type: "text",
+				text: `Successfully wrote content to file: ${resolvedPath}`
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error writing to file: ${error instanceof Error ? error.message : String(error)}`
+				}],
+				isError: true
+			};
+		}
+	}
+};
+
+//#endregion
+//#region src/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 = express();
+		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.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 && isInitializeRequest(req.body)) {
+			const mcpServer = this.serverFactory();
+			transport = new StreamableHTTPServerTransport({
+				sessionIdGenerator: () => 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 = express();
+		this.sessionManager = new SseSessionManager();
+		this.config = {
+			mode: config.mode,
+			port: config.port ?? 3e3,
+			host: config.host ?? "localhost"
+		};
+		this.setupMiddleware();
+		this.setupRoutes();
+	}
+	setupMiddleware() {
+		this.app.use(express.json());
+	}
+	setupRoutes() {
+		this.app.get("/sse", async (req, res) => {
+			await this.handleSseConnection(req, res);
+		});
+		this.app.post("/messages", async (req, res) => {
+			await this.handlePostMessage(req, res);
+		});
+		this.app.get("/health", (_req, res) => {
+			res.json({
+				status: "ok",
+				transport: "sse"
+			});
+		});
+	}
+	async handleSseConnection(_req, res) {
+		try {
+			const mcpServer = this.serverFactory();
+			const transport = new SSEServerTransport("/messages", res);
+			this.sessionManager.setSession(transport.sessionId, transport, mcpServer);
+			res.on("close", () => {
+				this.sessionManager.deleteSession(transport.sessionId);
+			});
+			await mcpServer.connect(transport);
+			console.error(`SSE session established: ${transport.sessionId}`);
+		} catch (error) {
+			console.error("Error handling SSE connection:", error);
+			if (!res.headersSent) res.status(500).send("Internal Server Error");
+		}
+	}
+	async handlePostMessage(req, res) {
+		const sessionId = req.query.sessionId;
+		if (!sessionId) {
+			res.status(400).send("Missing sessionId query parameter");
+			return;
+		}
+		const transport = this.sessionManager.getSession(sessionId);
+		if (!transport) {
+			res.status(404).send("No transport found for sessionId");
+			return;
+		}
+		try {
+			await transport.handlePostMessage(req, res, req.body);
+		} catch (error) {
+			console.error("Error handling post message:", error);
+			if (!res.headersSent) res.status(500).send("Internal Server Error");
+		}
+	}
+	async start() {
+		return new Promise((resolve, reject) => {
+			try {
+				this.server = this.app.listen(this.config.port, this.config.host, () => {
+					console.error(`Scaffolding MCP server started with SSE transport on http://${this.config.host}:${this.config.port}`);
+					console.error(`SSE endpoint: http://${this.config.host}:${this.config.port}/sse`);
+					console.error(`Messages endpoint: http://${this.config.host}:${this.config.port}/messages`);
+					console.error(`Health check: http://${this.config.host}:${this.config.port}/health`);
+					resolve();
+				});
+				this.server.on("error", (error) => {
+					reject(error);
+				});
+			} catch (error) {
+				reject(error);
+			}
+		});
+	}
+	async stop() {
+		return new Promise((resolve, reject) => {
+			if (this.server) {
+				this.sessionManager.clear();
+				this.server.close((err) => {
+					if (err) reject(err);
+					else {
+						this.server = null;
+						resolve();
+					}
+				});
+			} else resolve();
+		});
+	}
+	getPort() {
+		return this.config.port;
+	}
+	getHost() {
+		return this.config.host;
+	}
+};
+
+//#endregion
+//#region src/transports/stdio.ts
+/**
+* Stdio transport handler for MCP server
+* Used for command-line and direct integrations
+*/
+var StdioTransportHandler = class {
+	server;
+	transport = null;
+	constructor(server) {
+		this.server = server;
+	}
+	async start() {
+		this.transport = new StdioServerTransport();
+		await this.server.connect(this.transport);
+		console.error("Scaffolding MCP server started on stdio");
+	}
+	async stop() {
+		if (this.transport) {
+			await this.transport.close();
+			this.transport = null;
+		}
+	}
+};
+
+//#endregion
+export { BoilerplateGeneratorService, BoilerplateService, FileSystemService, GenerateBoilerplateFileTool, GenerateBoilerplateTool, GenerateFeatureScaffoldTool, HttpTransportHandler, ListBoilerplatesTool, ListScaffoldingMethodsTool, ScaffoldGeneratorService, ScaffoldingMethodsService, SseTransportHandler, StdioTransportHandler, UseBoilerplateTool, UseScaffoldMethodTool, WriteToFileTool, cloneRepository, cloneSubdirectory, fetchGitHubDirectoryContents, findWorkspaceRoot, parseGitHubUrl };