@agiflowai/scaffold-mcp 1.0.2 → 1.0.4

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

@@ -1,48 +1,256 @@
-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 {
+	/**
+	* Default page size for pagination
+	*/
+	static DEFAULT_PAGE_SIZE = 10;
+	/**
+	* Decodes a cursor string to extract the start index
+	* @param cursor - String representing the start index (e.g., "10")
+	* @returns Start index or 0 if invalid/undefined
+	*/
+	static decodeCursor(cursor) {
+		if (!cursor) return 0;
+		const index = Number.parseInt(cursor, 10);
+		if (Number.isNaN(index) || index < 0) return 0;
+		return index;
+	}
+	/**
+	* Encodes an index into a cursor string
+	* @param index - Start index to encode
+	* @returns Cursor string (e.g., "10")
+	*/
+	static encodeCursor(index) {
+		return index.toString();
+	}
+	/**
+	* Paginates an array of items
+	* @param items - All items to paginate
+	* @param cursor - Optional cursor representing the start index
+	* @param pageSize - Number of items per page (default: 10)
+	* @param includeMeta - Whether to include metadata in response (default: true)
+	* @returns Paginated result with items and optional nextCursor
+	*/
+	static paginate(items, cursor, pageSize = PaginationHelper.DEFAULT_PAGE_SIZE, includeMeta = true) {
+		const startIndex = PaginationHelper.decodeCursor(cursor);
+		const endIndex = startIndex + pageSize;
+		const result = {
+			items: items.slice(startIndex, endIndex),
+			nextCursor: endIndex < items.length ? PaginationHelper.encodeCursor(endIndex) : void 0
+		};
+		if (includeMeta) result._meta = {
+			total: items.length,
+			offset: startIndex,
+			limit: pageSize
+		};
+		return result;
+	}
+};
+
+//#endregion
 //#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);
 	}
 };
 
@@ -59,15 +267,17 @@ var BoilerplateService = class {
 		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
+	* Scans all scaffold.yaml files and returns available boilerplates with pagination
+	* @param cursor - Optional pagination cursor
+	* @returns Paginated list of boilerplates
 	*/
-	async listBoilerplates() {
+	async listBoilerplates(cursor) {
 		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");
+			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) {
@@ -88,7 +298,12 @@ var BoilerplateService = class {
 				log.warn(`Failed to load scaffold.yaml for ${templatePath}:`, error);
 			}
 		}
-		return { boilerplates };
+		const paginatedResult = PaginationHelper.paginate(boilerplates, cursor);
+		return {
+			boilerplates: paginatedResult.items,
+			nextCursor: paginatedResult.nextCursor,
+			_meta: paginatedResult._meta
+		};
 	}
 	/**
 	* Dynamically discovers template directories by finding all directories
@@ -97,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);
@@ -175,9 +390,12 @@ var BoilerplateService = class {
 				const projectPath = path$1.join(targetFolder, folderName);
 				await ProjectConfigResolver.createProjectJson(projectPath, folderName, boilerplate.template_path);
 			}
+			const processedInstruction = boilerplate.instruction ? this.processBoilerplateInstruction(boilerplate.instruction, variables) : "";
+			let enhancedMessage = result.message;
+			if (processedInstruction) enhancedMessage += `\n\nPlease follow this **instruction**:\n${processedInstruction}`;
 			return {
 				success: result.success,
-				message: result.message,
+				message: enhancedMessage,
 				warnings: result.warnings,
 				createdFiles: result.createdFiles,
 				existingFiles: result.existingFiles
@@ -235,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;
@@ -297,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",
@@ -334,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
 		};
@@ -349,73 +566,210 @@ 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)"
+	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: {
@@ -852,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
 /**
@@ -1223,7 +1451,10 @@ var ListBoilerplatesTool = class ListBoilerplatesTool {
 			description: description.trim(),
 			inputSchema: {
 				type: "object",
-				properties: {},
+				properties: { cursor: {
+					type: "string",
+					description: "Optional pagination cursor to fetch the next page of results. Omit to fetch the first page."
+				} },
 				additionalProperties: false
 			}
 		};
@@ -1231,9 +1462,10 @@ var ListBoilerplatesTool = class ListBoilerplatesTool {
 	/**
 	* Execute the tool
 	*/
-	async execute(_args = {}) {
+	async execute(args = {}) {
 		try {
-			const result = await this.boilerplateService.listBoilerplates();
+			const { cursor } = args;
+			const result = await this.boilerplateService.listBoilerplates(cursor);
 			return { content: [{
 				type: "text",
 				text: JSON.stringify(result, null, 2)
@@ -1254,176 +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) {
-		const absoluteProjectPath = path.resolve(projectPath);
-		const sourceTemplate = (await ProjectConfigResolver.resolveProjectConfig(absoluteProjectPath)).sourceTemplate;
-		return this.listScaffoldingMethodsByTemplate(sourceTemplate);
-	}
-	async listScaffoldingMethodsByTemplate(templateName) {
-		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
-			});
-		});
-		return {
-			sourceTemplate: templateName,
-			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;
-	}
-	/**
-	* 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}.
--> 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 {
@@ -1443,7 +1505,10 @@ var ListScaffoldingMethodsTool = class ListScaffoldingMethodsTool {
 	*/
 	getDefinition() {
 		const description = this.templateService.renderString(description_default$1, { isMonolith: this.isMonolith });
-		const properties = {};
+		const properties = { cursor: {
+			type: "string",
+			description: "Optional pagination cursor to fetch the next page of results. Omit to fetch the first page."
+		} };
 		if (!this.isMonolith) {
 			properties.projectPath = {
 				type: "string",
@@ -1469,18 +1534,18 @@ var ListScaffoldingMethodsTool = class ListScaffoldingMethodsTool {
 	*/
 	async execute(args) {
 		try {
-			const { projectPath, templateName } = args;
+			const { projectPath, templateName, cursor } = args;
 			let result;
 			if (this.isMonolith) try {
 				const resolvedTemplateName = (await ProjectConfigResolver.resolveProjectConfig(process.cwd())).sourceTemplate;
-				result = await this.scaffoldingMethodsService.listScaffoldingMethodsByTemplate(resolvedTemplateName);
+				result = await this.scaffoldingMethodsService.listScaffoldingMethodsByTemplate(resolvedTemplateName, cursor);
 			} catch (error) {
 				throw new Error(`Failed to read template name from configuration: ${error instanceof Error ? error.message : String(error)}`);
 			}
 			else {
 				if (!projectPath && !templateName) throw new Error("Either projectPath or templateName must be provided");
-				if (projectPath) result = await this.scaffoldingMethodsService.listScaffoldingMethods(projectPath);
-				else result = await this.scaffoldingMethodsService.listScaffoldingMethodsByTemplate(templateName);
+				if (projectPath) result = await this.scaffoldingMethodsService.listScaffoldingMethods(projectPath, cursor);
+				else result = await this.scaffoldingMethodsService.listScaffoldingMethodsByTemplate(templateName, cursor);
 			}
 			return { content: [{
 				type: "text",
@@ -2070,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 };