@agiflowai/scaffold-mcp 1.0.2 → 1.0.4

package/dist/{stdio-TGsG8akc.cjs → stdio-BGj_FLky.cjs}

@@ -1,58 +1,258 @@
 const require_chunk = require('./chunk-CUT6urMc.cjs');
-const require_ScaffoldConfigLoader = require('./ScaffoldConfigLoader-BrmvENTo.cjs');
-const require_ScaffoldService = require('./ScaffoldService-BwDmXt83.cjs');
-const require_TemplateService = require('./TemplateService-DRubcvS9.cjs');
-const require_VariableReplacementService = require('./VariableReplacementService-D0QnWKUW.cjs');
-let __agiflowai_aicode_utils = require("@agiflowai/aicode-utils");
-__agiflowai_aicode_utils = require_chunk.__toESM(__agiflowai_aicode_utils);
+const require_ScaffoldConfigLoader = require('./ScaffoldConfigLoader-Y_SBLPg7.cjs');
+const require_ScaffoldService = require('./ScaffoldService-ChzxM0Yc.cjs');
+const require_TemplateService = require('./TemplateService-D3ydJR_R.cjs');
+const require_VariableReplacementService = require('./VariableReplacementService-CAjesAYq.cjs');
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
-let __composio_json_schema_to_zod = require("@composio/json-schema-to-zod");
-__composio_json_schema_to_zod = require_chunk.__toESM(__composio_json_schema_to_zod);
-let fs_extra = require("fs-extra");
-fs_extra = require_chunk.__toESM(fs_extra);
+let __agiflowai_aicode_utils = require("@agiflowai/aicode-utils");
 let js_yaml = require("js-yaml");
 js_yaml = require_chunk.__toESM(js_yaml);
+let node_fs = require("node:fs");
+let __composio_json_schema_to_zod = require("@composio/json-schema-to-zod");
 let zod = require("zod");
-zod = require_chunk.__toESM(zod);
-let __modelcontextprotocol_sdk_types_js = require("@modelcontextprotocol/sdk/types.js");
-__modelcontextprotocol_sdk_types_js = require_chunk.__toESM(__modelcontextprotocol_sdk_types_js);
 let node_crypto = require("node:crypto");
-node_crypto = require_chunk.__toESM(node_crypto);
 let __modelcontextprotocol_sdk_server_streamableHttp_js = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
-__modelcontextprotocol_sdk_server_streamableHttp_js = require_chunk.__toESM(__modelcontextprotocol_sdk_server_streamableHttp_js);
+let __modelcontextprotocol_sdk_types_js = require("@modelcontextprotocol/sdk/types.js");
 let express = require("express");
 express = require_chunk.__toESM(express);
 let __modelcontextprotocol_sdk_server_sse_js = require("@modelcontextprotocol/sdk/server/sse.js");
-__modelcontextprotocol_sdk_server_sse_js = require_chunk.__toESM(__modelcontextprotocol_sdk_server_sse_js);
 let __modelcontextprotocol_sdk_server_stdio_js = require("@modelcontextprotocol/sdk/server/stdio.js");
-__modelcontextprotocol_sdk_server_stdio_js = require_chunk.__toESM(__modelcontextprotocol_sdk_server_stdio_js);
 
+//#region src/services/BoilerplateGeneratorService.ts
+/**
+* Service for generating boilerplate configurations in scaffold.yaml files
+*/
+var BoilerplateGeneratorService = class {
+	templatesPath;
+	constructor(templatesPath) {
+		this.templatesPath = templatesPath;
+	}
+	/**
+	* Custom YAML dumper that forces literal block style (|) for description and instruction fields
+	*/
+	dumpYamlWithLiteralBlocks(config) {
+		const LiteralBlockType = new js_yaml.Type("tag:yaml.org,2002:str", {
+			kind: "scalar",
+			construct: (data) => data,
+			represent: (data) => {
+				return data;
+			},
+			defaultStyle: "|"
+		});
+		const LITERAL_SCHEMA = js_yaml.DEFAULT_SCHEMA.extend([LiteralBlockType]);
+		const processedConfig = this.processConfigForLiteralBlocks(config);
+		return js_yaml.dump(processedConfig, {
+			schema: LITERAL_SCHEMA,
+			indent: 2,
+			lineWidth: -1,
+			noRefs: true,
+			sortKeys: false,
+			styles: { "!!str": "literal" },
+			replacer: (key, value) => {
+				if ((key === "description" || key === "instruction") && typeof value === "string") return value;
+				return value;
+			}
+		});
+	}
+	/**
+	* Process config to ensure description and instruction use literal block style
+	*/
+	processConfigForLiteralBlocks(config) {
+		const processed = JSON.parse(JSON.stringify(config));
+		if (processed.boilerplate) processed.boilerplate = processed.boilerplate.map((bp) => {
+			const newBp = { ...bp };
+			if (newBp.description && typeof newBp.description === "string") newBp.description = this.ensureMultilineFormat(newBp.description);
+			if (newBp.instruction && typeof newBp.instruction === "string") newBp.instruction = this.ensureMultilineFormat(newBp.instruction);
+			return newBp;
+		});
+		if (processed.features) processed.features = processed.features.map((feature) => {
+			const newFeature = { ...feature };
+			if (newFeature.description && typeof newFeature.description === "string") newFeature.description = this.ensureMultilineFormat(newFeature.description);
+			if (newFeature.instruction && typeof newFeature.instruction === "string") newFeature.instruction = this.ensureMultilineFormat(newFeature.instruction);
+			return newFeature;
+		});
+		return processed;
+	}
+	/**
+	* Ensure string is properly formatted for YAML literal blocks
+	*/
+	ensureMultilineFormat(text) {
+		return text.trim();
+	}
+	/**
+	* Generate or update a boilerplate configuration in scaffold.yaml
+	*/
+	async generateBoilerplate(options) {
+		const { templateName, boilerplateName, description, instruction, targetFolder, variables, includes = [] } = options;
+		const templatePath = node_path.join(this.templatesPath, templateName);
+		await (0, __agiflowai_aicode_utils.ensureDir)(templatePath);
+		const scaffoldYamlPath = node_path.join(templatePath, "scaffold.yaml");
+		let scaffoldConfig = {};
+		if (await (0, __agiflowai_aicode_utils.pathExists)(scaffoldYamlPath)) {
+			const yamlContent = await (0, __agiflowai_aicode_utils.readFile)(scaffoldYamlPath, "utf-8");
+			scaffoldConfig = js_yaml.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 (0, __agiflowai_aicode_utils.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 (0, __agiflowai_aicode_utils.readdir)(this.templatesPath, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+	}
+	/**
+	* Check if a template exists
+	*/
+	async templateExists(templateName) {
+		return (0, __agiflowai_aicode_utils.pathExists)(node_path.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 = node_path.join(this.templatesPath, templateName);
+		if (!await (0, __agiflowai_aicode_utils.pathExists)(templatePath)) return {
+			success: false,
+			message: `Template directory '${templateName}' does not exist at ${templatePath}`
+		};
+		let fileContent = content || "";
+		if (sourceFile) {
+			if (!await (0, __agiflowai_aicode_utils.pathExists)(sourceFile)) return {
+				success: false,
+				message: `Source file '${sourceFile}' does not exist`
+			};
+			fileContent = await (0, __agiflowai_aicode_utils.readFile)(sourceFile, "utf-8");
+		}
+		if (!fileContent && !sourceFile) return {
+			success: false,
+			message: "Either content or sourceFile must be provided"
+		};
+		const templateFilePath = filePath.endsWith(".liquid") ? filePath : `${filePath}.liquid`;
+		const fullPath = node_path.join(templatePath, templateFilePath);
+		await (0, __agiflowai_aicode_utils.ensureDir)(node_path.dirname(fullPath));
+		let finalContent = fileContent;
+		if (header) finalContent = `${header}\n\n${fileContent}`;
+		await (0, __agiflowai_aicode_utils.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_extra.default.pathExists(path$2);
+		return (0, __agiflowai_aicode_utils.pathExists)(path$2);
 	}
 	async readFile(path$2, encoding = "utf8") {
-		return fs_extra.default.readFile(path$2, encoding);
+		return (0, __agiflowai_aicode_utils.readFile)(path$2, encoding);
 	}
 	async readJson(path$2) {
-		return fs_extra.default.readJson(path$2);
+		return (0, __agiflowai_aicode_utils.readJson)(path$2);
 	}
 	async writeFile(path$2, content, encoding = "utf8") {
-		return fs_extra.default.writeFile(path$2, content, encoding);
+		return (0, __agiflowai_aicode_utils.writeFile)(path$2, content, encoding);
 	}
 	async ensureDir(path$2) {
-		return fs_extra.default.ensureDir(path$2);
+		return (0, __agiflowai_aicode_utils.ensureDir)(path$2);
 	}
 	async copy(src, dest) {
-		return fs_extra.default.copy(src, dest);
+		return (0, __agiflowai_aicode_utils.copy)(src, dest);
 	}
 	async readdir(path$2) {
-		return fs_extra.default.readdir(path$2);
+		return (0, __agiflowai_aicode_utils.readdir)(path$2);
 	}
 	async stat(path$2) {
-		return fs_extra.default.stat(path$2);
+		return (0, __agiflowai_aicode_utils.stat)(path$2);
 	}
 };
 
@@ -69,15 +269,17 @@ var BoilerplateService = class {
 		this.scaffoldService = new require_ScaffoldService.ScaffoldService(fileSystemService, new require_ScaffoldConfigLoader.ScaffoldConfigLoader(fileSystemService, this.templateService), new require_VariableReplacementService.VariableReplacementService(fileSystemService, this.templateService), templatesPath);
 	}
 	/**
-	* Scans all scaffold.yaml files and returns available boilerplates
+	* 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 = node_path.join(this.templatesPath, templatePath, "scaffold.yaml");
-			if (fs_extra.existsSync(scaffoldYamlPath)) try {
-				const scaffoldContent = fs_extra.readFileSync(scaffoldYamlPath, "utf8");
+			if ((0, __agiflowai_aicode_utils.pathExistsSync)(scaffoldYamlPath)) try {
+				const scaffoldContent = (0, __agiflowai_aicode_utils.readFileSync)(scaffoldYamlPath, "utf8");
 				const scaffoldConfig = js_yaml.load(scaffoldContent);
 				if (scaffoldConfig.boilerplate) for (const boilerplate of scaffoldConfig.boilerplate) {
 					if (!boilerplate.targetFolder) {
@@ -98,7 +300,12 @@ var BoilerplateService = class {
 				__agiflowai_aicode_utils.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
@@ -107,14 +314,14 @@ var BoilerplateService = class {
 	async discoverTemplateDirectories() {
 		const templateDirs = [];
 		const findTemplates = (dir, baseDir = "") => {
-			if (!fs_extra.existsSync(dir)) return;
-			const items = fs_extra.readdirSync(dir);
+			if (!(0, __agiflowai_aicode_utils.pathExistsSync)(dir)) return;
+			const items = (0, node_fs.readdirSync)(dir);
 			const hasPackageJson = items.includes("package.json") || items.includes("package.json.liquid");
 			const hasScaffoldYaml = items.includes("scaffold.yaml");
 			if (hasPackageJson && hasScaffoldYaml) templateDirs.push(baseDir);
 			for (const item of items) {
 				const itemPath = node_path.join(dir, item);
-				if (fs_extra.statSync(itemPath).isDirectory() && !item.startsWith(".") && item !== "node_modules") findTemplates(itemPath, baseDir ? node_path.join(baseDir, item) : item);
+				if ((0, __agiflowai_aicode_utils.statSync)(itemPath).isDirectory() && !item.startsWith(".") && item !== "node_modules") findTemplates(itemPath, baseDir ? node_path.join(baseDir, item) : item);
 			}
 		};
 		findTemplates(this.templatesPath);
@@ -185,9 +392,12 @@ var BoilerplateService = class {
 				const projectPath = node_path.join(targetFolder, folderName);
 				await __agiflowai_aicode_utils.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
@@ -245,11 +455,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;
@@ -307,27 +517,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 = node_path.join(this.templatesPath, templateName);
-		await fs_extra.ensureDir(templatePath);
+		await (0, __agiflowai_aicode_utils.ensureDir)(templatePath);
 		const scaffoldYamlPath = node_path.join(templatePath, "scaffold.yaml");
 		let scaffoldConfig = {};
-		if (await fs_extra.pathExists(scaffoldYamlPath)) {
-			const yamlContent$1 = await fs_extra.readFile(scaffoldYamlPath, "utf-8");
-			scaffoldConfig = js_yaml.load(yamlContent$1);
+		if (await (0, __agiflowai_aicode_utils.pathExists)(scaffoldYamlPath)) {
+			const yamlContent = await (0, __agiflowai_aicode_utils.readFile)(scaffoldYamlPath, "utf-8");
+			scaffoldConfig = js_yaml.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",
@@ -344,13 +553,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_extra.writeFile(scaffoldYamlPath, yamlContent, "utf-8");
+		if (instruction) featureDefinition.instruction = instruction;
+		if (patterns && patterns.length > 0) featureDefinition.patterns = patterns;
+		scaffoldConfig.features.push(featureDefinition);
+		await (0, __agiflowai_aicode_utils.writeFile)(scaffoldYamlPath, this.dumpYamlWithLiteralBlocks(scaffoldConfig), "utf-8");
 		return {
 			success: true,
-			message: `Boilerplate '${boilerplateName}' added to ${scaffoldYamlPath}`,
+			message: `Feature '${featureName}' added to ${scaffoldYamlPath}`,
 			templatePath,
 			scaffoldYamlPath
 		};
@@ -359,71 +568,208 @@ var BoilerplateGeneratorService = class {
 	* List all templates (directories in templates folder)
 	*/
 	async listTemplates() {
-		return (await fs_extra.readdir(this.templatesPath, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+		return (await (0, __agiflowai_aicode_utils.readdir)(this.templatesPath, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
 	}
 	/**
 	* Check if a template exists
 	*/
 	async templateExists(templateName) {
-		const templatePath = node_path.join(this.templatesPath, templateName);
-		return fs_extra.pathExists(templatePath);
-	}
-	/**
-	* Create or update a template file for a boilerplate
-	*/
-	async createTemplateFile(options) {
-		const { templateName, filePath, content, sourceFile, header } = options;
-		const templatePath = node_path.join(this.templatesPath, templateName);
-		if (!await fs_extra.pathExists(templatePath)) return {
-			success: false,
-			message: `Template directory '${templateName}' does not exist at ${templatePath}`
-		};
-		let fileContent = content || "";
-		if (sourceFile) {
-			if (!await fs_extra.pathExists(sourceFile)) return {
-				success: false,
-				message: `Source file '${sourceFile}' does not exist`
-			};
-			fileContent = await fs_extra.readFile(sourceFile, "utf-8");
-		}
-		if (!fileContent && !sourceFile) return {
-			success: false,
-			message: "Either content or sourceFile must be provided"
-		};
-		const templateFilePath = filePath.endsWith(".liquid") ? filePath : `${filePath}.liquid`;
-		const fullPath = node_path.join(templatePath, templateFilePath);
-		await fs_extra.ensureDir(node_path.dirname(fullPath));
-		let finalContent = fileContent;
-		if (header) finalContent = `${header}\n\n${fileContent}`;
-		await fs_extra.writeFile(fullPath, finalContent, "utf-8");
-		return {
-			success: true,
-			message: "Template file created successfully",
-			filePath: templateFilePath,
-			fullPath
-		};
+		return (0, __agiflowai_aicode_utils.pathExists)(node_path.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 require_TemplateService.TemplateService();
 	}
-	/**
-	* Get the tool definition for MCP
-	*/
-	getDefinition() {
-		const properties = {};
-		if (!this.isMonolith) properties.templateName = {
+	async listScaffoldingMethods(projectPath, cursor) {
+		const absoluteProjectPath = node_path.default.resolve(projectPath);
+		const sourceTemplate = (await __agiflowai_aicode_utils.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 = node_path.default.join(this.templatesRootPath, templatePath);
+		const scaffoldYamlPath = node_path.default.join(fullTemplatePath, "scaffold.yaml");
+		if (!await this.fileSystem.pathExists(scaffoldYamlPath)) throw new Error(`scaffold.yaml not found at ${scaffoldYamlPath}`);
+		const scaffoldContent = await this.fileSystem.readFile(scaffoldYamlPath, "utf8");
+		const architectConfig = js_yaml.default.load(scaffoldContent);
+		const methods = [];
+		if (architectConfig.features && Array.isArray(architectConfig.features)) architectConfig.features.forEach((feature) => {
+			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 = node_path.default.join(this.templatesRootPath, templateDir);
+			const scaffoldYamlPath = node_path.default.join(templatePath, "scaffold.yaml");
+			if (await this.fileSystem.pathExists(scaffoldYamlPath)) try {
+				const scaffoldContent = await this.fileSystem.readFile(scaffoldYamlPath, "utf8");
+				const architectConfig = js_yaml.default.load(scaffoldContent);
+				if (architectConfig.boilerplate && Array.isArray(architectConfig.boilerplate)) {
+					for (const boilerplate of architectConfig.boilerplate) if (boilerplate.name?.includes(sourceTemplate)) return templateDir;
+				}
+			} catch (error) {
+				__agiflowai_aicode_utils.log.warn(`Failed to read scaffold.yaml at ${scaffoldYamlPath}:`, error);
+			}
+		}
+		return null;
+	}
+	/**
+	* Resolves the project path, handling both monorepo and monolith cases
+	* Uses ProjectConfigResolver to find the correct workspace/project root
+	*/
+	async resolveProjectPath(projectPath) {
+		const absolutePath = node_path.default.resolve(projectPath);
+		return (await __agiflowai_aicode_utils.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 = node_path.default.join(this.templatesRootPath, item);
+				if (!(await this.fileSystem.stat(itemPath)).isDirectory()) continue;
+				const scaffoldYamlPath = node_path.default.join(itemPath, "scaffold.yaml");
+				if (await this.fileSystem.pathExists(scaffoldYamlPath)) {
+					templateDirs.push(item);
+					continue;
+				}
+				try {
+					const subItems = await this.fileSystem.readdir(itemPath);
+					for (const subItem of subItems) {
+						const subItemPath = node_path.default.join(itemPath, subItem);
+						if (!(await this.fileSystem.stat(subItemPath)).isDirectory()) continue;
+						const subScaffoldYamlPath = node_path.default.join(subItemPath, "scaffold.yaml");
+						if (await this.fileSystem.pathExists(subScaffoldYamlPath)) {
+							const relativePath = node_path.default.join(item, subItem);
+							templateDirs.push(relativePath);
+						}
+					}
+				} catch (error) {
+					__agiflowai_aicode_utils.log.warn(`Failed to read subdirectories in ${itemPath}:`, error);
+				}
+			}
+		} catch (error) {
+			__agiflowai_aicode_utils.log.warn(`Failed to read templates root directory ${this.templatesRootPath}:`, error);
+		}
+		return templateDirs;
+	}
+	async useScaffoldMethod(request) {
+		const { projectPath, scaffold_feature_name, variables } = request;
+		const 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 Promise.resolve().then(() => require("./ScaffoldService-BNOyoqSb.cjs"))).ScaffoldService;
+		const ScaffoldConfigLoader$1 = (await Promise.resolve().then(() => require("./ScaffoldConfigLoader-B-NLy6VP.cjs"))).ScaffoldConfigLoader;
+		const VariableReplacementService$1 = (await Promise.resolve().then(() => require("./VariableReplacementService-DKaF2C9l.cjs"))).VariableReplacementService;
+		const TemplateService$1 = (await Promise.resolve().then(() => require("./TemplateService-DqieT1Tq.cjs"))).TemplateService;
+		const templateService = new TemplateService$1();
+		const scaffoldConfigLoader = new ScaffoldConfigLoader$1(this.fileSystem, templateService);
+		const variableReplacer = new VariableReplacementService$1(this.fileSystem, templateService);
+		const scaffoldService = new ScaffoldService$1(this.fileSystem, scaffoldConfigLoader, variableReplacer, this.templatesRootPath);
+		const projectName = node_path.default.basename(absoluteProjectPath);
+		const result = await scaffoldService.useFeature({
+			projectPath: absoluteProjectPath,
+			templateFolder: scaffoldingMethods.templatePath,
+			featureName: scaffold_feature_name,
+			variables: {
+				...variables,
+				appPath: absoluteProjectPath,
+				appName: projectName
+			}
+		});
+		if (!result.success) throw new Error(result.message);
+		return {
+			success: true,
+			message: `
+Successfully scaffolded ${scaffold_feature_name} in ${projectPath}.
+Please follow this **instruction**: \n ${method.instruction ? 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)"
 		};
@@ -862,132 +1208,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 js_yaml.Type("tag:yaml.org,2002:str", {
-			kind: "scalar",
-			construct: (data) => data,
-			represent: (data) => {
-				return data;
-			},
-			defaultStyle: "|"
-		});
-		const LITERAL_SCHEMA = js_yaml.DEFAULT_SCHEMA.extend([LiteralBlockType]);
-		const processedConfig = this.processConfigForLiteralBlocks(config);
-		return js_yaml.dump(processedConfig, {
-			schema: LITERAL_SCHEMA,
-			indent: 2,
-			lineWidth: -1,
-			noRefs: true,
-			sortKeys: false,
-			styles: { "!!str": "literal" },
-			replacer: (key, value) => {
-				if ((key === "description" || key === "instruction") && typeof value === "string") return value;
-				return value;
-			}
-		});
-	}
-	/**
-	* Process config to ensure description and instruction use literal block style
-	*/
-	processConfigForLiteralBlocks(config) {
-		const processed = JSON.parse(JSON.stringify(config));
-		if (processed.boilerplate) processed.boilerplate = processed.boilerplate.map((bp) => {
-			const newBp = { ...bp };
-			if (newBp.description && typeof newBp.description === "string") newBp.description = this.ensureMultilineFormat(newBp.description);
-			if (newBp.instruction && typeof newBp.instruction === "string") newBp.instruction = this.ensureMultilineFormat(newBp.instruction);
-			return newBp;
-		});
-		if (processed.features) processed.features = processed.features.map((feature) => {
-			const newFeature = { ...feature };
-			if (newFeature.description && typeof newFeature.description === "string") newFeature.description = this.ensureMultilineFormat(newFeature.description);
-			if (newFeature.instruction && typeof newFeature.instruction === "string") newFeature.instruction = this.ensureMultilineFormat(newFeature.instruction);
-			return newFeature;
-		});
-		return processed;
-	}
-	/**
-	* Ensure string is properly formatted for YAML literal blocks
-	*/
-	ensureMultilineFormat(text) {
-		return text.trim();
-	}
-	/**
-	* Generate or update a feature configuration in scaffold.yaml
-	*/
-	async generateFeatureScaffold(options) {
-		const { templateName, featureName, description, instruction, variables, includes = [], patterns = [] } = options;
-		const templatePath = node_path.join(this.templatesPath, templateName);
-		await fs_extra.ensureDir(templatePath);
-		const scaffoldYamlPath = node_path.join(templatePath, "scaffold.yaml");
-		let scaffoldConfig = {};
-		if (await fs_extra.pathExists(scaffoldYamlPath)) {
-			const yamlContent$1 = await fs_extra.readFile(scaffoldYamlPath, "utf-8");
-			scaffoldConfig = js_yaml.load(yamlContent$1);
-		}
-		if (!scaffoldConfig.features) scaffoldConfig.features = [];
-		if (scaffoldConfig.features.findIndex((f) => f.name === featureName) !== -1) return {
-			success: false,
-			message: `Feature '${featureName}' already exists in ${scaffoldYamlPath}`
-		};
-		const requiredVars = variables.filter((v) => v.required).map((v) => v.name);
-		const featureDefinition = {
-			name: featureName,
-			description,
-			variables_schema: {
-				type: "object",
-				properties: variables.reduce((acc, v) => {
-					acc[v.name] = {
-						type: v.type,
-						description: v.description
-					};
-					if (v.default !== void 0) acc[v.name].default = v.default;
-					return acc;
-				}, {}),
-				required: requiredVars,
-				additionalProperties: false
-			},
-			includes: includes.length > 0 ? includes : []
-		};
-		if (instruction) featureDefinition.instruction = instruction;
-		if (patterns && patterns.length > 0) featureDefinition.patterns = patterns;
-		scaffoldConfig.features.push(featureDefinition);
-		const yamlContent = this.dumpYamlWithLiteralBlocks(scaffoldConfig);
-		await fs_extra.writeFile(scaffoldYamlPath, yamlContent, "utf-8");
-		return {
-			success: true,
-			message: `Feature '${featureName}' added to ${scaffoldYamlPath}`,
-			templatePath,
-			scaffoldYamlPath
-		};
-	}
-	/**
-	* List all templates (directories in templates folder)
-	*/
-	async listTemplates() {
-		return (await fs_extra.readdir(this.templatesPath, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-	}
-	/**
-	* Check if a template exists
-	*/
-	async templateExists(templateName) {
-		const templatePath = node_path.join(this.templatesPath, templateName);
-		return fs_extra.pathExists(templatePath);
-	}
-};
-
 //#endregion
 //#region src/tools/GenerateFeatureScaffoldTool.ts
 /**
@@ -1233,7 +1453,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
 			}
 		};
@@ -1241,9 +1464,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)
@@ -1264,176 +1488,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 require_TemplateService.TemplateService();
-	}
-	async listScaffoldingMethods(projectPath) {
-		const absoluteProjectPath = node_path.default.resolve(projectPath);
-		const sourceTemplate = (await __agiflowai_aicode_utils.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 = node_path.default.join(this.templatesRootPath, templatePath);
-		const scaffoldYamlPath = node_path.default.join(fullTemplatePath, "scaffold.yaml");
-		if (!await this.fileSystem.pathExists(scaffoldYamlPath)) throw new Error(`scaffold.yaml not found at ${scaffoldYamlPath}`);
-		const scaffoldContent = await this.fileSystem.readFile(scaffoldYamlPath, "utf8");
-		const architectConfig = js_yaml.default.load(scaffoldContent);
-		const methods = [];
-		if (architectConfig.features && Array.isArray(architectConfig.features)) architectConfig.features.forEach((feature) => {
-			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 = node_path.default.join(this.templatesRootPath, templateDir);
-			const scaffoldYamlPath = node_path.default.join(templatePath, "scaffold.yaml");
-			if (await this.fileSystem.pathExists(scaffoldYamlPath)) try {
-				const scaffoldContent = await this.fileSystem.readFile(scaffoldYamlPath, "utf8");
-				const architectConfig = js_yaml.default.load(scaffoldContent);
-				if (architectConfig.boilerplate && Array.isArray(architectConfig.boilerplate)) {
-					for (const boilerplate of architectConfig.boilerplate) if (boilerplate.name?.includes(sourceTemplate)) return templateDir;
-				}
-			} catch (error) {
-				__agiflowai_aicode_utils.log.warn(`Failed to read scaffold.yaml at ${scaffoldYamlPath}:`, error);
-			}
-		}
-		return null;
-	}
-	/**
-	* Resolves the project path, handling both monorepo and monolith cases
-	* Uses ProjectConfigResolver to find the correct workspace/project root
-	*/
-	async resolveProjectPath(projectPath) {
-		const absolutePath = node_path.default.resolve(projectPath);
-		return (await __agiflowai_aicode_utils.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 = node_path.default.join(this.templatesRootPath, item);
-				if (!(await this.fileSystem.stat(itemPath)).isDirectory()) continue;
-				const scaffoldYamlPath = node_path.default.join(itemPath, "scaffold.yaml");
-				if (await this.fileSystem.pathExists(scaffoldYamlPath)) {
-					templateDirs.push(item);
-					continue;
-				}
-				try {
-					const subItems = await this.fileSystem.readdir(itemPath);
-					for (const subItem of subItems) {
-						const subItemPath = node_path.default.join(itemPath, subItem);
-						if (!(await this.fileSystem.stat(subItemPath)).isDirectory()) continue;
-						const subScaffoldYamlPath = node_path.default.join(subItemPath, "scaffold.yaml");
-						if (await this.fileSystem.pathExists(subScaffoldYamlPath)) {
-							const relativePath = node_path.default.join(item, subItem);
-							templateDirs.push(relativePath);
-						}
-					}
-				} catch (error) {
-					__agiflowai_aicode_utils.log.warn(`Failed to read subdirectories in ${itemPath}:`, error);
-				}
-			}
-		} catch (error) {
-			__agiflowai_aicode_utils.log.warn(`Failed to read templates root directory ${this.templatesRootPath}:`, error);
-		}
-		return templateDirs;
-	}
-	async useScaffoldMethod(request) {
-		const { projectPath, scaffold_feature_name, variables } = request;
-		const 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 Promise.resolve().then(() => require("./ScaffoldService-B3En_m4t.cjs"))).ScaffoldService;
-		const ScaffoldConfigLoader$1 = (await Promise.resolve().then(() => require("./ScaffoldConfigLoader-DQMCLVGD.cjs"))).ScaffoldConfigLoader;
-		const VariableReplacementService$1 = (await Promise.resolve().then(() => require("./VariableReplacementService-CroHkMha.cjs"))).VariableReplacementService;
-		const TemplateService$1 = (await Promise.resolve().then(() => require("./TemplateService-BZRt3NI8.cjs"))).TemplateService;
-		const templateService = new TemplateService$1();
-		const scaffoldConfigLoader = new ScaffoldConfigLoader$1(this.fileSystem, templateService);
-		const variableReplacer = new VariableReplacementService$1(this.fileSystem, templateService);
-		const scaffoldService = new ScaffoldService$1(this.fileSystem, scaffoldConfigLoader, variableReplacer, this.templatesRootPath);
-		const projectName = node_path.default.basename(absoluteProjectPath);
-		const result = await scaffoldService.useFeature({
-			projectPath: absoluteProjectPath,
-			templateFolder: scaffoldingMethods.templatePath,
-			featureName: scaffold_feature_name,
-			variables: {
-				...variables,
-				appPath: absoluteProjectPath,
-				appName: projectName
-			}
-		});
-		if (!result.success) throw new Error(result.message);
-		return {
-			success: true,
-			message: `
-Successfully scaffolded ${scaffold_feature_name} in ${projectPath}.
-Please follow this **instruction**: \n ${method.instruction}.
--> Create or update the plan based on the instruction.
-`,
-			warnings: result.warnings,
-			createdFiles: result.createdFiles,
-			existingFiles: result.existingFiles
-		};
-	}
-};
-
 //#endregion
 //#region src/tools/ListScaffoldingMethodsTool.ts
 var ListScaffoldingMethodsTool = class ListScaffoldingMethodsTool {
@@ -1453,7 +1507,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",
@@ -1479,18 +1536,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 __agiflowai_aicode_utils.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",