@agiflowai/scaffold-mcp 1.0.6 → 1.0.7

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

@@ -1,8 +1,9 @@
 const require_chunk = require('./chunk-CUT6urMc.cjs');
-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');
+const require_ListScaffoldingMethodsTool = require('./ListScaffoldingMethodsTool-BuxKRbwi.cjs');
+const require_ScaffoldConfigLoader = require('./ScaffoldConfigLoader-CQlXVksz.cjs');
+const require_ScaffoldService = require('./ScaffoldService-BPyiY_0B.cjs');
+const require_TemplateService = require('./TemplateService-CAD8jkoO.cjs');
+const require_VariableReplacementService = require('./VariableReplacementService-DDG5KZpb.cjs');
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
 let __agiflowai_aicode_utils = require("@agiflowai/aicode-utils");
@@ -11,6 +12,10 @@ 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");
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_chunk.__toESM(node_fs_promises);
+let node_os = require("node:os");
+node_os = require_chunk.__toESM(node_os);
 let node_crypto = require("node:crypto");
 let __modelcontextprotocol_sdk_server_streamableHttp_js = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
 let __modelcontextprotocol_sdk_types_js = require("@modelcontextprotocol/sdk/types.js");
@@ -177,85 +182,6 @@ var BoilerplateGeneratorService = class {
 	}
 };
 
-//#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 (0, __agiflowai_aicode_utils.pathExists)(path$2);
-	}
-	async readFile(path$2, encoding = "utf8") {
-		return (0, __agiflowai_aicode_utils.readFile)(path$2, encoding);
-	}
-	async readJson(path$2) {
-		return (0, __agiflowai_aicode_utils.readJson)(path$2);
-	}
-	async writeFile(path$2, content, encoding = "utf8") {
-		return (0, __agiflowai_aicode_utils.writeFile)(path$2, content, encoding);
-	}
-	async ensureDir(path$2) {
-		return (0, __agiflowai_aicode_utils.ensureDir)(path$2);
-	}
-	async copy(src, dest) {
-		return (0, __agiflowai_aicode_utils.copy)(src, dest);
-	}
-	async readdir(path$2) {
-		return (0, __agiflowai_aicode_utils.readdir)(path$2);
-	}
-	async stat(path$2) {
-		return (0, __agiflowai_aicode_utils.stat)(path$2);
-	}
-};
-
 //#endregion
 //#region src/services/BoilerplateService.ts
 var BoilerplateService = class {
@@ -265,7 +191,7 @@ var BoilerplateService = class {
 	constructor(templatesPath) {
 		this.templatesPath = templatesPath;
 		this.templateService = new require_TemplateService.TemplateService();
-		const fileSystemService = new FileSystemService();
+		const fileSystemService = new require_ListScaffoldingMethodsTool.FileSystemService();
 		this.scaffoldService = new require_ScaffoldService.ScaffoldService(fileSystemService, new require_ScaffoldConfigLoader.ScaffoldConfigLoader(fileSystemService, this.templateService), new require_VariableReplacementService.VariableReplacementService(fileSystemService, this.templateService), templatesPath);
 	}
 	/**
@@ -300,7 +226,7 @@ var BoilerplateService = class {
 				__agiflowai_aicode_utils.log.warn(`Failed to load scaffold.yaml for ${templatePath}:`, error);
 			}
 		}
-		const paginatedResult = PaginationHelper.paginate(boilerplates, cursor);
+		const paginatedResult = require_ListScaffoldingMethodsTool.PaginationHelper.paginate(boilerplates, cursor);
 		return {
 			boilerplates: paginatedResult.items,
 			nextCursor: paginatedResult.nextCursor,
@@ -578,179 +504,6 @@ var ScaffoldGeneratorService = class {
 	}
 };
 
-//#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, 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
 /**
@@ -1429,7 +1182,7 @@ Use this to add custom feature scaffolds (pages, components, services, etc.) for
 
 //#endregion
 //#region src/instructions/tools/list-boilerplates/description.md?raw
-var description_default$2 = "{% if isMonolith %}\nNot available for monolith projects. Monolith uses a single template defined in `toolkit.yaml`.\n\nUse `list-scaffolding-methods` for available features instead.\n{% else %}\nLists all available project boilerplates for creating new applications, APIs, or packages in the monorepo.\n\nEach boilerplate includes:\n- Complete project template with starter files\n- Variable schema for customization\n- Target directory information (e.g., apps/, packages/)\n- Required and optional configuration options\n\nUse this FIRST when creating new projects to understand available templates and their requirements.\n{% endif %}\n";
+var description_default$1 = "{% if isMonolith %}\nNot available for monolith projects. Monolith uses a single template defined in `toolkit.yaml`.\n\nUse `list-scaffolding-methods` for available features instead.\n{% else %}\nLists all available project boilerplates for creating new applications, APIs, or packages in the monorepo.\n\nEach boilerplate includes:\n- Complete project template with starter files\n- Variable schema for customization\n- Target directory information (e.g., apps/, packages/)\n- Required and optional configuration options\n\nUse this FIRST when creating new projects to understand available templates and their requirements.\n{% endif %}\n";
 
 //#endregion
 //#region src/tools/ListBoilerplatesTool.ts
@@ -1447,7 +1200,7 @@ var ListBoilerplatesTool = class ListBoilerplatesTool {
 	* Get the tool definition for MCP
 	*/
 	getDefinition() {
-		const description = this.templateService.renderString(description_default$2, { isMonolith: this.isMonolith });
+		const description = this.templateService.renderString(description_default$1, { isMonolith: this.isMonolith });
 		return {
 			name: ListBoilerplatesTool.TOOL_NAME,
 			description: description.trim(),
@@ -1484,87 +1237,6 @@ var ListBoilerplatesTool = class ListBoilerplatesTool {
 	}
 };
 
-//#endregion
-//#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/tools/ListScaffoldingMethodsTool.ts
-var ListScaffoldingMethodsTool = class ListScaffoldingMethodsTool {
-	static TOOL_NAME = "list-scaffolding-methods";
-	fileSystemService;
-	scaffoldingMethodsService;
-	templateService;
-	isMonolith;
-	constructor(templatesPath, isMonolith = false) {
-		this.fileSystemService = new FileSystemService();
-		this.scaffoldingMethodsService = new ScaffoldingMethodsService(this.fileSystemService, templatesPath);
-		this.templateService = new require_TemplateService.TemplateService();
-		this.isMonolith = isMonolith;
-	}
-	/**
-	* Get the tool definition for MCP
-	*/
-	getDefinition() {
-		const description = this.templateService.renderString(description_default$1, { isMonolith: this.isMonolith });
-		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",
-				description: "Absolute path to the project directory (for monorepo: containing project.json; for monolith: workspace root with toolkit.yaml). Either projectPath or templateName is required."
-			};
-			properties.templateName = {
-				type: "string",
-				description: "Name of the template to list scaffolding methods for (e.g., \"nextjs-15\", \"typescript-mcp-package\"). Either projectPath or templateName is required."
-			};
-		}
-		return {
-			name: ListScaffoldingMethodsTool.TOOL_NAME,
-			description: description.trim(),
-			inputSchema: {
-				type: "object",
-				properties,
-				additionalProperties: false
-			}
-		};
-	}
-	/**
-	* Execute the tool
-	*/
-	async execute(args) {
-		try {
-			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, 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, cursor);
-				else result = await this.scaffoldingMethodsService.listScaffoldingMethodsByTemplate(templateName, cursor);
-			}
-			return { content: [{
-				type: "text",
-				text: JSON.stringify(result, null, 2)
-			}] };
-		} catch (error) {
-			return {
-				content: [{
-					type: "text",
-					text: `Error listing scaffolding methods: ${error instanceof Error ? error.message : String(error)}`
-				}],
-				isError: true
-			};
-		}
-	}
-};
-
 //#endregion
 //#region src/instructions/tools/use-boilerplate/description.md?raw
 var description_default = "{% if isMonolith %}\nThis tool is not available for monolith projects.\n\nMonolith projects use a single template specified in `toolkit.yaml` (sourceTemplate field). The template cannot be changed through this tool - it's determined by the workspace configuration.\n\nUse `list-scaffolding-methods` and `use-scaffold-method` to add features to your monolith project instead.\n{% else %}\nCreates a new project from a boilerplate template with the specified variables.\n\n**For Monorepo Projects Only:**\nThis tool creates new sub-projects (apps, packages) in your monorepo. Each project can use a different template.\n\nThis tool will:\n- Generate all necessary files from the selected boilerplate template\n- Replace template variables with provided values\n- Create the project in targetFolder/projectName (e.g., apps/my-new-app)\n- Set up initial configuration files (package.json, tsconfig.json, etc.)\n- Create project.json with sourceTemplate reference\n\nIMPORTANT:\n- Always call `list-boilerplates` first to get the exact variable schema\n- Follow the schema exactly - required fields must be provided\n- Use kebab-case for project names (e.g., \"my-new-app\", not \"MyNewApp\")\n- The tool will validate all variables against the schema before proceeding\n- Each new project can use a different boilerplate template\n{% endif %}\n";
@@ -1652,15 +1324,35 @@ The boilerplate provides a starting point - you may need to add features or cust
 //#region src/tools/UseScaffoldMethodTool.ts
 var UseScaffoldMethodTool = class UseScaffoldMethodTool {
 	static TOOL_NAME = "use-scaffold-method";
+	static TEMP_LOG_DIR = node_os.tmpdir();
 	fileSystemService;
 	scaffoldingMethodsService;
 	isMonolith;
 	constructor(templatesPath, isMonolith = false) {
-		this.fileSystemService = new FileSystemService();
-		this.scaffoldingMethodsService = new ScaffoldingMethodsService(this.fileSystemService, templatesPath);
+		this.fileSystemService = new require_ListScaffoldingMethodsTool.FileSystemService();
+		this.scaffoldingMethodsService = new require_ListScaffoldingMethodsTool.ScaffoldingMethodsService(this.fileSystemService, templatesPath);
 		this.isMonolith = isMonolith;
 	}
 	/**
+	* Write scaffold execution info to temp log file for hook processing
+	*/
+	async writePendingScaffoldLog(scaffoldId, projectPath, featureName, generatedFiles) {
+		try {
+			const logEntry = {
+				timestamp: Date.now(),
+				scaffoldId,
+				projectPath,
+				featureName,
+				generatedFiles,
+				operation: "scaffold"
+			};
+			const tempLogFile = node_path.join(UseScaffoldMethodTool.TEMP_LOG_DIR, `scaffold-mcp-pending-${scaffoldId}.jsonl`);
+			await node_fs_promises.appendFile(tempLogFile, `${JSON.stringify(logEntry)}\n`, "utf-8");
+		} catch (error) {
+			console.error("Failed to write pending scaffold log:", error);
+		}
+	}
+	/**
 	* Get the tool definition for MCP
 	*/
 	getDefinition() {
@@ -1714,13 +1406,16 @@ IMPORTANT:
 		try {
 			const { projectPath, scaffold_feature_name, variables } = args;
 			const resolvedProjectPath = this.isMonolith ? process.cwd() : projectPath;
+			const result = await this.scaffoldingMethodsService.useScaffoldMethod({
+				projectPath: resolvedProjectPath,
+				scaffold_feature_name,
+				variables
+			});
+			const scaffoldId = (0, __agiflowai_aicode_utils.generateStableId)(6);
+			if (result.createdFiles && result.createdFiles.length > 0) await this.writePendingScaffoldLog(scaffoldId, resolvedProjectPath, scaffold_feature_name, result.createdFiles);
 			return { content: [{
 				type: "text",
-				text: `${(await this.scaffoldingMethodsService.useScaffoldMethod({
-					projectPath: resolvedProjectPath,
-					scaffold_feature_name,
-					variables
-				})).message}
+				text: `${result.message}
 
 IMPORTANT - Next Steps:
 1. READ the generated files to understand their structure and template placeholders
@@ -1730,6 +1425,9 @@ IMPORTANT - Next Steps:
 5. Only after completing the implementation should you move to other tasks
 
 Do not skip the implementation step - the scaffolded files contain templates that need actual code.`
+			}, {
+				type: "text",
+				text: `SCAFFOLD_ID:${scaffoldId}`
 			}] };
 		} catch (error) {
 			return {
@@ -1749,7 +1447,7 @@ var WriteToFileTool = class WriteToFileTool {
 	static TOOL_NAME = "write-to-file";
 	fileSystemService;
 	constructor() {
-		this.fileSystemService = new FileSystemService();
+		this.fileSystemService = new require_ListScaffoldingMethodsTool.FileSystemService();
 	}
 	/**
 	* Get the tool definition for MCP
@@ -2149,12 +1847,6 @@ Object.defineProperty(exports, 'BoilerplateService', {
     return BoilerplateService;
   }
 });
-Object.defineProperty(exports, 'FileSystemService', {
-  enumerable: true,
-  get: function () {
-    return FileSystemService;
-  }
-});
 Object.defineProperty(exports, 'GenerateBoilerplateFileTool', {
   enumerable: true,
   get: function () {
@@ -2185,24 +1877,12 @@ Object.defineProperty(exports, 'ListBoilerplatesTool', {
     return ListBoilerplatesTool;
   }
 });
-Object.defineProperty(exports, 'ListScaffoldingMethodsTool', {
-  enumerable: true,
-  get: function () {
-    return ListScaffoldingMethodsTool;
-  }
-});
 Object.defineProperty(exports, 'ScaffoldGeneratorService', {
   enumerable: true,
   get: function () {
     return ScaffoldGeneratorService;
   }
 });
-Object.defineProperty(exports, 'ScaffoldingMethodsService', {
-  enumerable: true,
-  get: function () {
-    return ScaffoldingMethodsService;
-  }
-});
 Object.defineProperty(exports, 'SseTransportHandler', {
   enumerable: true,
   get: function () {