@agiflowai/scaffold-mcp 1.0.3 → 1.0.5

package/dist/{stdio-BheRzmRj.js → stdio-wAlpLC6l.mjs}

@@ -1,23 +1,181 @@
-import { ScaffoldConfigLoader } from "./ScaffoldConfigLoader-CI0T6zdG.js";
-import { ScaffoldService } from "./ScaffoldService-DB7-Cyod.js";
-import { TemplateService } from "./TemplateService-CiZJA06s.js";
-import { VariableReplacementService } from "./VariableReplacementService-DRxd9ILB.js";
-import { ProjectConfigResolver, log } from "@agiflowai/aicode-utils";
+import { t as ScaffoldConfigLoader } from "./ScaffoldConfigLoader-BDMJNI1o.mjs";
+import { t as ScaffoldService } from "./ScaffoldService-BNuN00Fm.mjs";
+import { t as TemplateService } from "./TemplateService-Cg5QV29n.mjs";
+import { t as VariableReplacementService } from "./VariableReplacementService-DHIINRnJ.mjs";
 import * as path$1 from "node:path";
 import path from "node:path";
-import { jsonSchemaToZod } from "@composio/json-schema-to-zod";
-import * as fs$1 from "fs-extra";
-import fs from "fs-extra";
+import { ProjectConfigResolver, copy, ensureDir, log, pathExists, pathExistsSync, readFile, readFileSync, readJson, readdir, stat, statSync, writeFile } from "@agiflowai/aicode-utils";
 import * as yaml$1 from "js-yaml";
 import yaml from "js-yaml";
+import { readdirSync } from "node:fs";
+import { jsonSchemaToZod } from "@composio/json-schema-to-zod";
 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 { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
 import express from "express";
 import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
+//#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 ensureDir(templatePath);
+		const scaffoldYamlPath = path$1.join(templatePath, "scaffold.yaml");
+		let scaffoldConfig = {};
+		if (await pathExists(scaffoldYamlPath)) {
+			const yamlContent = await readFile(scaffoldYamlPath, "utf-8");
+			scaffoldConfig = yaml$1.load(yamlContent);
+		}
+		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);
+		await writeFile(scaffoldYamlPath, this.dumpYamlWithLiteralBlocks(scaffoldConfig), "utf-8");
+		return {
+			success: true,
+			message: `Boilerplate '${boilerplateName}' added to ${scaffoldYamlPath}`,
+			templatePath,
+			scaffoldYamlPath
+		};
+	}
+	/**
+	* List all templates (directories in templates folder)
+	*/
+	async listTemplates() {
+		return (await readdir(this.templatesPath, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+	}
+	/**
+	* Check if a template exists
+	*/
+	async templateExists(templateName) {
+		return pathExists(path$1.join(this.templatesPath, templateName));
+	}
+	/**
+	* 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 pathExists(templatePath)) return {
+			success: false,
+			message: `Template directory '${templateName}' does not exist at ${templatePath}`
+		};
+		let fileContent = content || "";
+		if (sourceFile) {
+			if (!await pathExists(sourceFile)) return {
+				success: false,
+				message: `Source file '${sourceFile}' does not exist`
+			};
+			fileContent = await 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 ensureDir(path$1.dirname(fullPath));
+		let finalContent = fileContent;
+		if (header) finalContent = `${header}\n\n${fileContent}`;
+		await writeFile(fullPath, finalContent, "utf-8");
+		return {
+			success: true,
+			message: "Template file created successfully",
+			filePath: templateFilePath,
+			fullPath
+		};
+	}
+};
+
+//#endregion
 //#region src/utils/pagination.ts
 var PaginationHelper = class PaginationHelper {
 	/**
@@ -71,28 +229,28 @@ var PaginationHelper = class PaginationHelper {
 //#region src/services/FileSystemService.ts
 var FileSystemService = class {
 	async pathExists(path$2) {
-		return fs.pathExists(path$2);
+		return pathExists(path$2);
 	}
 	async readFile(path$2, encoding = "utf8") {
-		return fs.readFile(path$2, encoding);
+		return readFile(path$2, encoding);
 	}
 	async readJson(path$2) {
-		return fs.readJson(path$2);
+		return readJson(path$2);
 	}
 	async writeFile(path$2, content, encoding = "utf8") {
-		return fs.writeFile(path$2, content, encoding);
+		return writeFile(path$2, content, encoding);
 	}
 	async ensureDir(path$2) {
-		return fs.ensureDir(path$2);
+		return ensureDir(path$2);
 	}
 	async copy(src, dest) {
-		return fs.copy(src, dest);
+		return copy(src, dest);
 	}
 	async readdir(path$2) {
-		return fs.readdir(path$2);
+		return readdir(path$2);
 	}
 	async stat(path$2) {
-		return fs.stat(path$2);
+		return stat(path$2);
 	}
 };
 
@@ -118,8 +276,8 @@ var BoilerplateService = class {
 		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");
+			if (pathExistsSync(scaffoldYamlPath)) try {
+				const scaffoldContent = readFileSync(scaffoldYamlPath, "utf8");
 				const scaffoldConfig = yaml$1.load(scaffoldContent);
 				if (scaffoldConfig.boilerplate) for (const boilerplate of scaffoldConfig.boilerplate) {
 					if (!boilerplate.targetFolder) {
@@ -154,14 +312,14 @@ var BoilerplateService = class {
 	async discoverTemplateDirectories() {
 		const templateDirs = [];
 		const findTemplates = (dir, baseDir = "") => {
-			if (!fs$1.existsSync(dir)) return;
-			const items = fs$1.readdirSync(dir);
+			if (!pathExistsSync(dir)) return;
+			const items = 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);
+				if (statSync(itemPath).isDirectory() && !item.startsWith(".") && item !== "node_modules") findTemplates(itemPath, baseDir ? path$1.join(baseDir, item) : item);
 			}
 		};
 		findTemplates(this.templatesPath);
@@ -295,11 +453,11 @@ var BoilerplateService = class {
 };
 
 //#endregion
-//#region src/services/BoilerplateGeneratorService.ts
+//#region src/services/ScaffoldGeneratorService.ts
 /**
-* Service for generating boilerplate configurations in scaffold.yaml files
+* Service for generating feature scaffold configurations in scaffold.yaml files
 */
-var BoilerplateGeneratorService = class {
+var ScaffoldGeneratorService = class {
 	templatesPath;
 	constructor(templatesPath) {
 		this.templatesPath = templatesPath;
@@ -357,27 +515,26 @@ var BoilerplateGeneratorService = class {
 		return text.trim();
 	}
 	/**
-	* Generate or update a boilerplate configuration in scaffold.yaml
+	* Generate or update a feature configuration in scaffold.yaml
 	*/
-	async generateBoilerplate(options) {
-		const { templateName, boilerplateName, description, instruction, targetFolder, variables, includes = [] } = options;
+	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);
+		await 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 (await pathExists(scaffoldYamlPath)) {
+			const yamlContent = await readFile(scaffoldYamlPath, "utf-8");
+			scaffoldConfig = yaml$1.load(yamlContent);
 		}
-		if (!scaffoldConfig.boilerplate) scaffoldConfig.boilerplate = [];
-		if (scaffoldConfig.boilerplate.findIndex((b) => b.name === boilerplateName) !== -1) return {
+		if (!scaffoldConfig.features) scaffoldConfig.features = [];
+		if (scaffoldConfig.features.findIndex((f) => f.name === featureName) !== -1) return {
 			success: false,
-			message: `Boilerplate '${boilerplateName}' already exists in ${scaffoldYamlPath}`
+			message: `Feature '${featureName}' already exists in ${scaffoldYamlPath}`
 		};
 		const requiredVars = variables.filter((v) => v.required).map((v) => v.name);
-		const boilerplateDefinition = {
-			name: boilerplateName,
-			targetFolder,
+		const featureDefinition = {
+			name: featureName,
 			description,
 			variables_schema: {
 				type: "object",
@@ -394,13 +551,13 @@ var BoilerplateGeneratorService = class {
 			},
 			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");
+		if (instruction) featureDefinition.instruction = instruction;
+		if (patterns && patterns.length > 0) featureDefinition.patterns = patterns;
+		scaffoldConfig.features.push(featureDefinition);
+		await writeFile(scaffoldYamlPath, this.dumpYamlWithLiteralBlocks(scaffoldConfig), "utf-8");
 		return {
 			success: true,
-			message: `Boilerplate '${boilerplateName}' added to ${scaffoldYamlPath}`,
+			message: `Feature '${featureName}' added to ${scaffoldYamlPath}`,
 			templatePath,
 			scaffoldYamlPath
 		};
@@ -409,91 +566,228 @@ var BoilerplateGeneratorService = class {
 	* 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);
+		return (await 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
-		};
+		return pathExists(path$1.join(this.templatesPath, templateName));
 	}
 };
 
 //#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;
-	isMonolith;
-	constructor(templatesPath, isMonolith = false) {
-		this.boilerplateGeneratorService = new BoilerplateGeneratorService(templatesPath);
-		this.isMonolith = isMonolith;
+//#region src/services/ScaffoldingMethodsService.ts
+var ScaffoldingMethodsService = class {
+	templateService;
+	constructor(fileSystem, templatesRootPath) {
+		this.fileSystem = fileSystem;
+		this.templatesRootPath = templatesRootPath;
+		this.templateService = new TemplateService();
 	}
-	/**
-	* Get the tool definition for MCP
-	*/
-	getDefinition() {
-		const properties = {};
-		if (!this.isMonolith) properties.templateName = {
-			type: "string",
-			description: "Name of the template folder (must already exist)"
-		};
-		Object.assign(properties, {
-			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:
+	async listScaffoldingMethods(projectPath, cursor) {
+		const absoluteProjectPath = path.resolve(projectPath);
+		const sourceTemplate = (await ProjectConfigResolver.resolveProjectConfig(absoluteProjectPath)).sourceTemplate;
+		return this.listScaffoldingMethodsByTemplate(sourceTemplate, cursor);
+	}
+	async listScaffoldingMethodsByTemplate(templateName, cursor) {
+		const templatePath = await this.findTemplatePath(templateName);
+		if (!templatePath) throw new Error(`Template not found for sourceTemplate: ${templateName}`);
+		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) => {
+			const featureName = feature.name || `scaffold-${templateName}`;
+			methods.push({
+				name: featureName,
+				description: feature.description || "",
+				instruction: feature.instruction || "",
+				variables_schema: feature.variables_schema || {
+					type: "object",
+					properties: {},
+					required: [],
+					additionalProperties: false
+				},
+				generator: feature.generator
+			});
+		});
+		const paginatedResult = PaginationHelper.paginate(methods, cursor);
+		return {
+			sourceTemplate: templateName,
+			templatePath,
+			methods: paginatedResult.items,
+			nextCursor: paginatedResult.nextCursor,
+			_meta: paginatedResult._meta
+		};
+	}
+	/**
+	* Gets scaffolding methods with instructions rendered using provided variables
+	*/
+	async listScaffoldingMethodsWithVariables(projectPath, variables, cursor) {
+		const result = await this.listScaffoldingMethods(projectPath, cursor);
+		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;
+	}
+	/**
+	* Resolves the project path, handling both monorepo and monolith cases
+	* Uses ProjectConfigResolver to find the correct workspace/project root
+	*/
+	async resolveProjectPath(projectPath) {
+		const absolutePath = path.resolve(projectPath);
+		return (await ProjectConfigResolver.resolveProjectConfig(absolutePath)).workspaceRoot || absolutePath;
+	}
+	/**
+	* 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 absoluteProjectPath = await this.resolveProjectPath(projectPath);
+		const scaffoldingMethods = await this.listScaffoldingMethods(absoluteProjectPath);
+		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-BNdfC21Z.mjs")).ScaffoldService;
+		const ScaffoldConfigLoader$1 = (await import("./ScaffoldConfigLoader-SHk-KEje.mjs")).ScaffoldConfigLoader;
+		const VariableReplacementService$1 = (await import("./VariableReplacementService-BWCd-z7X.mjs")).VariableReplacementService;
+		const TemplateService$1 = (await import("./TemplateService-BRfzfaZs.mjs")).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 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 ? this.processScaffoldInstruction(method.instruction, variables) : ""}.
+-> Create or update the plan based on the instruction.
+`,
+			warnings: result.warnings,
+			createdFiles: result.createdFiles,
+			existingFiles: result.existingFiles
+		};
+	}
+};
+
+//#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;
+	isMonolith;
+	constructor(templatesPath, isMonolith = false) {
+		this.boilerplateGeneratorService = new BoilerplateGeneratorService(templatesPath);
+		this.isMonolith = isMonolith;
+	}
+	/**
+	* Get the tool definition for MCP
+	*/
+	getDefinition() {
+		const properties = {};
+		if (!this.isMonolith) properties.templateName = {
+			type: "string",
+			description: "Name of the template folder (must already exist)"
+		};
+		Object.assign(properties, {
+			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:
@@ -912,132 +1206,6 @@ Use this to add custom boilerplate configurations for frameworks not yet support
 	}
 };
 
-//#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
 /**
@@ -1318,179 +1486,6 @@ var ListBoilerplatesTool = class ListBoilerplatesTool {
 //#region src/instructions/tools/list-scaffolding-methods/description.md?raw
 var description_default$1 = "Lists all available scaffolding methods (features) that can be added to an existing project{% if not isMonolith %} or for a specific template{% endif %}.\n\nThis tool:\n{% if isMonolith %}\n- Reads your project's sourceTemplate from toolkit.yaml at workspace root\n{% else %}\n- Reads the project's sourceTemplate from project.json (monorepo) or toolkit.yaml (monolith), OR\n- Directly uses the provided templateName to list available features\n{% endif %}\n- Returns available features for that template type\n- Provides variable schemas for each scaffolding method\n- Shows descriptions of what each method creates\n\nUse this FIRST when adding features to understand:\n- What scaffolding methods are available\n- What variables each method requires\n- What files/features will be generated\n\nExample methods might include:\n- Adding new React routes (for React apps)\n- Creating API endpoints (for backend projects)\n- Adding new components (for frontend projects)\n- Setting up database models (for API projects)\n";
 
-//#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, cursor) {
-		const absoluteProjectPath = path.resolve(projectPath);
-		const sourceTemplate = (await ProjectConfigResolver.resolveProjectConfig(absoluteProjectPath)).sourceTemplate;
-		return this.listScaffoldingMethodsByTemplate(sourceTemplate, cursor);
-	}
-	async listScaffoldingMethodsByTemplate(templateName, cursor) {
-		const templatePath = await this.findTemplatePath(templateName);
-		if (!templatePath) throw new Error(`Template not found for sourceTemplate: ${templateName}`);
-		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) => {
-			const featureName = feature.name || `scaffold-${templateName}`;
-			methods.push({
-				name: featureName,
-				description: feature.description || "",
-				instruction: feature.instruction || "",
-				variables_schema: feature.variables_schema || {
-					type: "object",
-					properties: {},
-					required: [],
-					additionalProperties: false
-				},
-				generator: feature.generator
-			});
-		});
-		const paginatedResult = PaginationHelper.paginate(methods, cursor);
-		return {
-			sourceTemplate: templateName,
-			templatePath,
-			methods: paginatedResult.items,
-			nextCursor: paginatedResult.nextCursor,
-			_meta: paginatedResult._meta
-		};
-	}
-	/**
-	* Gets scaffolding methods with instructions rendered using provided variables
-	*/
-	async listScaffoldingMethodsWithVariables(projectPath, variables, cursor) {
-		const result = await this.listScaffoldingMethods(projectPath, cursor);
-		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;
-	}
-	/**
-	* Resolves the project path, handling both monorepo and monolith cases
-	* Uses ProjectConfigResolver to find the correct workspace/project root
-	*/
-	async resolveProjectPath(projectPath) {
-		const absolutePath = path.resolve(projectPath);
-		return (await ProjectConfigResolver.resolveProjectConfig(absolutePath)).workspaceRoot || absolutePath;
-	}
-	/**
-	* 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 absoluteProjectPath = await this.resolveProjectPath(projectPath);
-		const scaffoldingMethods = await this.listScaffoldingMethods(absoluteProjectPath);
-		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-CJ3vNmAj.js")).ScaffoldService;
-		const ScaffoldConfigLoader$1 = (await import("./ScaffoldConfigLoader-DhthV6xq.js")).ScaffoldConfigLoader;
-		const VariableReplacementService$1 = (await import("./VariableReplacementService-BAwTGv_R.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 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 ? this.processScaffoldInstruction(method.instruction, variables) : ""}.
--> 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 {
@@ -2140,4 +2135,4 @@ var StdioTransportHandler = class {
 };
 
 //#endregion
-export { BoilerplateGeneratorService, BoilerplateService, FileSystemService, GenerateBoilerplateFileTool, GenerateBoilerplateTool, GenerateFeatureScaffoldTool, HttpTransportHandler, ListBoilerplatesTool, ListScaffoldingMethodsTool, ScaffoldGeneratorService, ScaffoldingMethodsService, SseTransportHandler, StdioTransportHandler, UseBoilerplateTool, UseScaffoldMethodTool, WriteToFileTool };
+export { UseScaffoldMethodTool as a, ListBoilerplatesTool as c, GenerateBoilerplateFileTool as d, ScaffoldingMethodsService as f, BoilerplateGeneratorService as g, FileSystemService as h, WriteToFileTool as i, GenerateFeatureScaffoldTool as l, BoilerplateService as m, SseTransportHandler as n, UseBoilerplateTool as o, ScaffoldGeneratorService as p, HttpTransportHandler as r, ListScaffoldingMethodsTool as s, StdioTransportHandler as t, GenerateBoilerplateTool as u };