@agiflowai/scaffold-mcp 1.0.6 → 1.0.8

package/dist/{stdio-wAlpLC6l.mjs → stdio-DovjJsGY.mjs}

@@ -1,15 +1,17 @@
-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 { i as PaginationHelper, n as ScaffoldingMethodsService, r as FileSystemService } from "./ListScaffoldingMethodsTool-BLTCwsd1.mjs";
+import { t as ScaffoldConfigLoader } from "./ScaffoldConfigLoader-8YI7v2GJ.mjs";
+import { t as ScaffoldService } from "./ScaffoldService-CgYunbKN.mjs";
+import { t as TemplateService } from "./TemplateService-CVDL2uqt.mjs";
+import { t as VariableReplacementService } from "./VariableReplacementService-B9RA8D0a.mjs";
 import * as path$1 from "node:path";
 import path from "node:path";
-import { ProjectConfigResolver, copy, ensureDir, log, pathExists, pathExistsSync, readFile, readFileSync, readJson, readdir, stat, statSync, writeFile } from "@agiflowai/aicode-utils";
+import { ProjectConfigResolver, ensureDir, generateStableId, log, pathExists, pathExistsSync, readFile, readFileSync, readdir, 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 * as fs$1 from "node:fs/promises";
+import * as os$1 from "node:os";
 import { randomUUID } from "node:crypto";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
@@ -175,85 +177,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 pathExists(path$2);
-	}
-	async readFile(path$2, encoding = "utf8") {
-		return readFile(path$2, encoding);
-	}
-	async readJson(path$2) {
-		return readJson(path$2);
-	}
-	async writeFile(path$2, content, encoding = "utf8") {
-		return writeFile(path$2, content, encoding);
-	}
-	async ensureDir(path$2) {
-		return ensureDir(path$2);
-	}
-	async copy(src, dest) {
-		return copy(src, dest);
-	}
-	async readdir(path$2) {
-		return readdir(path$2);
-	}
-	async stat(path$2) {
-		return stat(path$2);
-	}
-};
-
 //#endregion
 //#region src/services/BoilerplateService.ts
 var BoilerplateService = class {
@@ -576,179 +499,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 TemplateService();
-	}
-	async listScaffoldingMethods(projectPath, cursor) {
-		const absoluteProjectPath = path.resolve(projectPath);
-		const sourceTemplate = (await ProjectConfigResolver.resolveProjectConfig(absoluteProjectPath)).sourceTemplate;
-		return this.listScaffoldingMethodsByTemplate(sourceTemplate, cursor);
-	}
-	async listScaffoldingMethodsByTemplate(templateName, cursor) {
-		const templatePath = await this.findTemplatePath(templateName);
-		if (!templatePath) throw new Error(`Template not found for sourceTemplate: ${templateName}`);
-		const fullTemplatePath = path.join(this.templatesRootPath, templatePath);
-		const scaffoldYamlPath = path.join(fullTemplatePath, "scaffold.yaml");
-		if (!await this.fileSystem.pathExists(scaffoldYamlPath)) throw new Error(`scaffold.yaml not found at ${scaffoldYamlPath}`);
-		const scaffoldContent = await this.fileSystem.readFile(scaffoldYamlPath, "utf8");
-		const architectConfig = yaml.load(scaffoldContent);
-		const methods = [];
-		if (architectConfig.features && Array.isArray(architectConfig.features)) architectConfig.features.forEach((feature) => {
-			const featureName = feature.name || `scaffold-${templateName}`;
-			methods.push({
-				name: featureName,
-				description: feature.description || "",
-				instruction: feature.instruction || "",
-				variables_schema: feature.variables_schema || {
-					type: "object",
-					properties: {},
-					required: [],
-					additionalProperties: false
-				},
-				generator: feature.generator
-			});
-		});
-		const paginatedResult = PaginationHelper.paginate(methods, cursor);
-		return {
-			sourceTemplate: templateName,
-			templatePath,
-			methods: paginatedResult.items,
-			nextCursor: paginatedResult.nextCursor,
-			_meta: paginatedResult._meta
-		};
-	}
-	/**
-	* Gets scaffolding methods with instructions rendered using provided variables
-	*/
-	async listScaffoldingMethodsWithVariables(projectPath, variables, cursor) {
-		const result = await this.listScaffoldingMethods(projectPath, cursor);
-		const processedMethods = result.methods.map((method) => ({
-			...method,
-			instruction: method.instruction ? this.processScaffoldInstruction(method.instruction, variables) : void 0
-		}));
-		return {
-			...result,
-			methods: processedMethods
-		};
-	}
-	/**
-	* Processes scaffold instruction with template service
-	*/
-	processScaffoldInstruction(instruction, variables) {
-		if (this.templateService.containsTemplateVariables(instruction)) return this.templateService.renderString(instruction, variables);
-		return instruction;
-	}
-	async findTemplatePath(sourceTemplate) {
-		const templateDirs = await this.discoverTemplateDirs();
-		if (templateDirs.includes(sourceTemplate)) return sourceTemplate;
-		for (const templateDir of templateDirs) {
-			const templatePath = path.join(this.templatesRootPath, templateDir);
-			const scaffoldYamlPath = path.join(templatePath, "scaffold.yaml");
-			if (await this.fileSystem.pathExists(scaffoldYamlPath)) try {
-				const scaffoldContent = await this.fileSystem.readFile(scaffoldYamlPath, "utf8");
-				const architectConfig = yaml.load(scaffoldContent);
-				if (architectConfig.boilerplate && Array.isArray(architectConfig.boilerplate)) {
-					for (const boilerplate of architectConfig.boilerplate) if (boilerplate.name?.includes(sourceTemplate)) return templateDir;
-				}
-			} catch (error) {
-				log.warn(`Failed to read scaffold.yaml at ${scaffoldYamlPath}:`, error);
-			}
-		}
-		return null;
-	}
-	/**
-	* Resolves the project path, handling both monorepo and monolith cases
-	* Uses ProjectConfigResolver to find the correct workspace/project root
-	*/
-	async resolveProjectPath(projectPath) {
-		const absolutePath = path.resolve(projectPath);
-		return (await ProjectConfigResolver.resolveProjectConfig(absolutePath)).workspaceRoot || absolutePath;
-	}
-	/**
-	* Dynamically discovers all template directories
-	* Supports both flat structure (templates/nextjs-15) and nested structure (templates/apps/nextjs-15)
-	**/
-	async discoverTemplateDirs() {
-		const templateDirs = [];
-		try {
-			const items = await this.fileSystem.readdir(this.templatesRootPath);
-			for (const item of items) {
-				const itemPath = path.join(this.templatesRootPath, item);
-				if (!(await this.fileSystem.stat(itemPath)).isDirectory()) continue;
-				const scaffoldYamlPath = path.join(itemPath, "scaffold.yaml");
-				if (await this.fileSystem.pathExists(scaffoldYamlPath)) {
-					templateDirs.push(item);
-					continue;
-				}
-				try {
-					const subItems = await this.fileSystem.readdir(itemPath);
-					for (const subItem of subItems) {
-						const subItemPath = path.join(itemPath, subItem);
-						if (!(await this.fileSystem.stat(subItemPath)).isDirectory()) continue;
-						const subScaffoldYamlPath = path.join(subItemPath, "scaffold.yaml");
-						if (await this.fileSystem.pathExists(subScaffoldYamlPath)) {
-							const relativePath = path.join(item, subItem);
-							templateDirs.push(relativePath);
-						}
-					}
-				} catch (error) {
-					log.warn(`Failed to read subdirectories in ${itemPath}:`, error);
-				}
-			}
-		} catch (error) {
-			log.warn(`Failed to read templates root directory ${this.templatesRootPath}:`, error);
-		}
-		return templateDirs;
-	}
-	async useScaffoldMethod(request) {
-		const { projectPath, scaffold_feature_name, variables } = request;
-		const absoluteProjectPath = await this.resolveProjectPath(projectPath);
-		const scaffoldingMethods = await this.listScaffoldingMethods(absoluteProjectPath);
-		const method = scaffoldingMethods.methods.find((m) => m.name === scaffold_feature_name);
-		if (!method) {
-			const availableMethods = scaffoldingMethods.methods.map((m) => m.name).join(", ");
-			throw new Error(`Scaffold method '${scaffold_feature_name}' not found. Available methods: ${availableMethods}`);
-		}
-		const ScaffoldService$1 = (await import("./ScaffoldService-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
 /**
@@ -1427,7 +1177,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
@@ -1445,7 +1195,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(),
@@ -1482,87 +1232,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 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 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";
@@ -1650,6 +1319,7 @@ 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 = os$1.tmpdir();
 	fileSystemService;
 	scaffoldingMethodsService;
 	isMonolith;
@@ -1659,6 +1329,25 @@ var UseScaffoldMethodTool = class UseScaffoldMethodTool {
 		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 = path$1.join(UseScaffoldMethodTool.TEMP_LOG_DIR, `scaffold-mcp-pending-${scaffoldId}.jsonl`);
+			await fs$1.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() {
@@ -1712,13 +1401,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 = 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
@@ -1728,6 +1420,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 {
@@ -2135,4 +1830,4 @@ var StdioTransportHandler = class {
 };
 
 //#endregion
-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 };
+export { UseScaffoldMethodTool as a, GenerateFeatureScaffoldTool as c, ScaffoldGeneratorService as d, BoilerplateService as f, WriteToFileTool as i, GenerateBoilerplateTool as l, SseTransportHandler as n, UseBoilerplateTool as o, BoilerplateGeneratorService as p, HttpTransportHandler as r, ListBoilerplatesTool as s, StdioTransportHandler as t, GenerateBoilerplateFileTool as u };