@agiflowai/scaffold-mcp 1.0.11 → 1.0.12

package/dist/ListScaffoldingMethodsTool-D3ecmSLf.mjs

@@ -0,0 +1,994 @@
+import path from "node:path";
+import { ProjectConfigResolver, TemplatesManagerService, copy, ensureDir, log, pathExists, readFile, readJson, readdir, stat, writeFile } from "@agiflowai/aicode-utils";
+import yaml from "js-yaml";
+import { z } from "zod";
+import { fileURLToPath } from "node:url";
+import { Liquid } from "liquidjs";
+
+//#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$1) {
+		return pathExists(path$1);
+	}
+	async readFile(path$1, encoding = "utf8") {
+		return readFile(path$1, encoding);
+	}
+	async readJson(path$1) {
+		return readJson(path$1);
+	}
+	async writeFile(path$1, content, encoding = "utf8") {
+		return writeFile(path$1, content, encoding);
+	}
+	async ensureDir(path$1) {
+		return ensureDir(path$1);
+	}
+	async copy(src, dest) {
+		return copy(src, dest);
+	}
+	async readdir(path$1) {
+		return readdir(path$1);
+	}
+	async stat(path$1) {
+		return stat(path$1);
+	}
+};
+
+//#endregion
+//#region src/services/ScaffoldConfigLoader.ts
+const VariablesSchemaSchema = z.object({
+	type: z.literal("object"),
+	properties: z.record(z.any()),
+	required: z.array(z.string()),
+	additionalProperties: z.boolean()
+});
+const ScaffoldConfigEntrySchema = z.object({
+	name: z.string(),
+	description: z.string().optional(),
+	instruction: z.string().optional(),
+	targetFolder: z.string().optional(),
+	variables_schema: VariablesSchemaSchema,
+	includes: z.array(z.string()),
+	generator: z.string().optional(),
+	patterns: z.array(z.string()).optional()
+});
+const ScaffoldYamlSchema = z.object({
+	boilerplate: z.union([ScaffoldConfigEntrySchema, z.array(ScaffoldConfigEntrySchema)]).optional(),
+	features: z.union([ScaffoldConfigEntrySchema, z.array(ScaffoldConfigEntrySchema)]).optional()
+}).catchall(z.union([ScaffoldConfigEntrySchema, z.array(ScaffoldConfigEntrySchema)]));
+var ScaffoldConfigLoader = class {
+	constructor(fileSystem, templateService) {
+		this.fileSystem = fileSystem;
+		this.templateService = templateService;
+	}
+	async parseArchitectConfig(templatePath) {
+		const architectPath = path.join(templatePath, "scaffold.yaml");
+		if (!await this.fileSystem.pathExists(architectPath)) return null;
+		try {
+			const content = await this.fileSystem.readFile(architectPath, "utf8");
+			const rawConfig = yaml.load(content);
+			return ScaffoldYamlSchema.parse(rawConfig);
+		} catch (error) {
+			if (error instanceof z.ZodError) {
+				const errorMessages = error.errors.map((err) => `${err.path.join(".")}: ${err.message}`).join("; ");
+				throw new Error(`scaffold.yaml validation failed: ${errorMessages}`);
+			}
+			throw new Error(`Failed to parse scaffold.yaml: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	parseIncludeEntry(includeEntry, variables) {
+		const [pathPart, conditionsPart] = includeEntry.split("?");
+		const conditions = {};
+		if (conditionsPart) {
+			const conditionPairs = conditionsPart.split("&");
+			for (const pair of conditionPairs) {
+				const [key, value] = pair.split("=");
+				if (key && value) conditions[key.trim()] = value.trim();
+			}
+		}
+		if (pathPart.includes("->")) {
+			const [sourcePath, targetPath] = pathPart.split("->").map((p) => p.trim());
+			return {
+				sourcePath,
+				targetPath: this.replaceVariablesInPath(targetPath, variables),
+				conditions
+			};
+		}
+		const processedPath = this.replaceVariablesInPath(pathPart.trim(), variables);
+		return {
+			sourcePath: pathPart.trim(),
+			targetPath: processedPath,
+			conditions
+		};
+	}
+	replaceVariablesInPath(pathStr, variables) {
+		return this.templateService.renderString(pathStr, variables);
+	}
+	shouldIncludeFile(conditions, variables) {
+		if (!conditions || Object.keys(conditions).length === 0) return true;
+		for (const [conditionKey, conditionValue] of Object.entries(conditions)) {
+			const variableValue = variables[conditionKey];
+			if (conditionValue === "true" || conditionValue === "false") {
+				const expectedBoolean = conditionValue === "true";
+				if (Boolean(variableValue) !== expectedBoolean) return false;
+			} else if (String(variableValue) !== conditionValue) return false;
+		}
+		return true;
+	}
+	async validateTemplate(templatePath, scaffoldType) {
+		const errors = [];
+		const missingFiles = [];
+		if (!await this.fileSystem.pathExists(templatePath)) {
+			errors.push(`Template directory ${templatePath} does not exist`);
+			return {
+				isValid: false,
+				errors,
+				missingFiles
+			};
+		}
+		let architectConfig;
+		try {
+			architectConfig = await this.parseArchitectConfig(templatePath);
+		} catch (error) {
+			errors.push(`Failed to parse scaffold.yaml: ${error instanceof Error ? error.message : String(error)}`);
+			return {
+				isValid: false,
+				errors,
+				missingFiles
+			};
+		}
+		if (!architectConfig) {
+			errors.push("scaffold.yaml not found in template directory");
+			return {
+				isValid: false,
+				errors,
+				missingFiles
+			};
+		}
+		if (!architectConfig[scaffoldType]) {
+			const availableTypes = Object.keys(architectConfig).join(", ");
+			errors.push(`Scaffold type '${scaffoldType}' not found in scaffold.yaml. Available types: ${availableTypes}`);
+			return {
+				isValid: false,
+				errors,
+				missingFiles
+			};
+		}
+		const config = architectConfig[scaffoldType];
+		if (config.includes && Array.isArray(config.includes)) for (const includeFile of config.includes) {
+			const parsed = this.parseIncludeEntry(includeFile, {});
+			const sourcePath = path.join(templatePath, parsed.sourcePath);
+			const liquidSourcePath = `${sourcePath}.liquid`;
+			const sourceExists = await this.fileSystem.pathExists(sourcePath);
+			const liquidExists = await this.fileSystem.pathExists(liquidSourcePath);
+			if (!sourceExists && !liquidExists) missingFiles.push(includeFile);
+		}
+		return {
+			isValid: errors.length === 0 && missingFiles.length === 0,
+			errors,
+			missingFiles
+		};
+	}
+};
+
+//#endregion
+//#region src/services/ScaffoldProcessingService.ts
+/**
+* Shared service for common scaffolding operations like processing templates and tracking files
+*/
+var ScaffoldProcessingService = class {
+	constructor(fileSystem, variableReplacer) {
+		this.fileSystem = fileSystem;
+		this.variableReplacer = variableReplacer;
+	}
+	/**
+	* Process a target path for variable replacement, handling both files and directories
+	*/
+	async processTargetForVariableReplacement(targetPath, variables) {
+		if ((await this.fileSystem.stat(targetPath)).isDirectory()) await this.variableReplacer.processFilesForVariableReplacement(targetPath, variables);
+		else await this.variableReplacer.replaceVariablesInFile(targetPath, variables);
+	}
+	/**
+	* Track all created files, handling both single files and directories
+	*/
+	async trackCreatedFiles(targetPath, createdFiles) {
+		if ((await this.fileSystem.stat(targetPath)).isDirectory()) await this.trackCreatedFilesRecursive(targetPath, createdFiles);
+		else createdFiles.push(targetPath);
+	}
+	/**
+	* Track all existing files, handling both single files and directories
+	*/
+	async trackExistingFiles(targetPath, existingFiles) {
+		if ((await this.fileSystem.stat(targetPath)).isDirectory()) await this.trackExistingFilesRecursive(targetPath, existingFiles);
+		else existingFiles.push(targetPath);
+	}
+	/**
+	* Copy source to target, then process templates and track files
+	* Now supports tracking existing files separately from created files
+	* Automatically handles .liquid template files by stripping the extension
+	*/
+	async copyAndProcess(sourcePath, targetPath, variables, createdFiles, existingFiles) {
+		await this.fileSystem.ensureDir(path.dirname(targetPath));
+		if (await this.fileSystem.pathExists(targetPath) && existingFiles) {
+			await this.trackExistingFiles(targetPath, existingFiles);
+			return;
+		}
+		let actualSourcePath = sourcePath;
+		if (!await this.fileSystem.pathExists(sourcePath)) {
+			const liquidSourcePath = `${sourcePath}.liquid`;
+			if (await this.fileSystem.pathExists(liquidSourcePath)) actualSourcePath = liquidSourcePath;
+			else throw new Error(`Source file not found: ${sourcePath} (also tried ${liquidSourcePath})`);
+		}
+		await this.fileSystem.copy(actualSourcePath, targetPath);
+		await this.processTargetForVariableReplacement(targetPath, variables);
+		await this.trackCreatedFiles(targetPath, createdFiles);
+	}
+	/**
+	* Recursively collect all file paths in a directory for created files
+	*/
+	async trackCreatedFilesRecursive(dirPath, createdFiles) {
+		let items = [];
+		try {
+			items = await this.fileSystem.readdir(dirPath);
+		} catch (error) {
+			log.warn(`Cannot read directory ${dirPath}: ${error}`);
+			return;
+		}
+		const itemPaths = items.filter((item) => item).map((item) => path.join(dirPath, item));
+		const statResults = await Promise.all(itemPaths.map(async (itemPath) => {
+			try {
+				return {
+					itemPath,
+					stat: await this.fileSystem.stat(itemPath),
+					error: null
+				};
+			} catch (error) {
+				log.warn(`Cannot stat ${itemPath}: ${error}`);
+				return {
+					itemPath,
+					stat: null,
+					error
+				};
+			}
+		}));
+		const directories = [];
+		for (const { itemPath, stat: stat$1 } of statResults) {
+			if (!stat$1) continue;
+			if (stat$1.isDirectory()) directories.push(itemPath);
+			else if (stat$1.isFile()) createdFiles.push(itemPath);
+		}
+		await Promise.all(directories.map((dir) => this.trackCreatedFilesRecursive(dir, createdFiles)));
+	}
+	/**
+	* Recursively collect all file paths in a directory for existing files
+	*/
+	async trackExistingFilesRecursive(dirPath, existingFiles) {
+		let items = [];
+		try {
+			items = await this.fileSystem.readdir(dirPath);
+		} catch (error) {
+			log.warn(`Cannot read directory ${dirPath}: ${error}`);
+			return;
+		}
+		const itemPaths = items.filter((item) => item).map((item) => path.join(dirPath, item));
+		const statResults = await Promise.all(itemPaths.map(async (itemPath) => {
+			try {
+				return {
+					itemPath,
+					stat: await this.fileSystem.stat(itemPath),
+					error: null
+				};
+			} catch (error) {
+				log.warn(`Cannot stat ${itemPath}: ${error}`);
+				return {
+					itemPath,
+					stat: null,
+					error
+				};
+			}
+		}));
+		const directories = [];
+		for (const { itemPath, stat: stat$1 } of statResults) {
+			if (!stat$1) continue;
+			if (stat$1.isDirectory()) directories.push(itemPath);
+			else if (stat$1.isFile()) existingFiles.push(itemPath);
+		}
+		await Promise.all(directories.map((dir) => this.trackExistingFilesRecursive(dir, existingFiles)));
+	}
+};
+
+//#endregion
+//#region src/services/ScaffoldService.ts
+var ScaffoldService = class {
+	templatesRootPath;
+	processingService;
+	constructor(fileSystem, scaffoldConfigLoader, variableReplacer, templatesRootPath) {
+		this.fileSystem = fileSystem;
+		this.scaffoldConfigLoader = scaffoldConfigLoader;
+		this.variableReplacer = variableReplacer;
+		const resolvedPath = templatesRootPath || TemplatesManagerService.findTemplatesPathSync();
+		if (!resolvedPath) throw new Error("Templates folder not found. Please create a \"templates\" folder in your workspace root, or specify \"templatesPath\" in toolkit.yaml to point to your templates directory.");
+		this.templatesRootPath = resolvedPath;
+		this.processingService = new ScaffoldProcessingService(fileSystem, variableReplacer);
+	}
+	/**
+	* Scaffold a new project from a boilerplate template
+	*/
+	async useBoilerplate(options) {
+		try {
+			const { projectName, packageName, targetFolder, templateFolder, boilerplateName, variables = {} } = options;
+			const targetPath = path.isAbsolute(targetFolder) ? projectName ? path.join(targetFolder, projectName) : targetFolder : projectName ? path.join(process.cwd(), targetFolder, projectName) : path.join(process.cwd(), targetFolder);
+			const templatePath = path.join(this.templatesRootPath, templateFolder);
+			const validationResult = await this.scaffoldConfigLoader.validateTemplate(templatePath, "boilerplate");
+			if (!validationResult.isValid) return {
+				success: false,
+				message: `Template validation failed: ${[...validationResult.errors, ...validationResult.missingFiles.map((f) => `Template file not found: ${f}`)].join("; ")}`
+			};
+			if (projectName) {
+				if (await this.fileSystem.pathExists(targetPath)) return {
+					success: false,
+					message: `Directory ${targetPath} already exists`
+				};
+			}
+			const architectConfig = await this.scaffoldConfigLoader.parseArchitectConfig(templatePath);
+			if (!architectConfig || !architectConfig.boilerplate) return {
+				success: false,
+				message: `Invalid architect configuration: missing 'boilerplate' section in scaffold.yaml`
+			};
+			const boilerplateArray = architectConfig.boilerplate;
+			let config;
+			if (Array.isArray(boilerplateArray)) {
+				config = boilerplateArray.find((b) => b.name === boilerplateName);
+				if (!config) return {
+					success: false,
+					message: `Boilerplate '${boilerplateName}' not found in scaffold configuration`
+				};
+			} else config = architectConfig.boilerplate;
+			const effectiveProjectName = projectName || (packageName.includes("/") ? packageName.split("/")[1] : packageName);
+			const allVariables = {
+				...variables,
+				projectName: effectiveProjectName,
+				packageName
+			};
+			return await this.processScaffold({
+				config,
+				targetPath,
+				templatePath,
+				allVariables,
+				scaffoldType: "boilerplate"
+			});
+		} catch (error) {
+			return {
+				success: false,
+				message: `Error scaffolding boilerplate: ${error instanceof Error ? error.message : String(error)}`
+			};
+		}
+	}
+	/**
+	* Scaffold a new feature into an existing project
+	*/
+	async useFeature(options) {
+		try {
+			const { projectPath, templateFolder, featureName, variables = {} } = options;
+			const targetPath = path.resolve(projectPath);
+			const templatePath = path.join(this.templatesRootPath, templateFolder);
+			const projectName = path.basename(targetPath);
+			const validationResult = await this.scaffoldConfigLoader.validateTemplate(templatePath, "features");
+			if (!validationResult.isValid) return {
+				success: false,
+				message: `Template validation failed: ${[...validationResult.errors, ...validationResult.missingFiles.map((f) => `Template file not found: ${f}`)].join("; ")}`
+			};
+			if (!await this.fileSystem.pathExists(targetPath)) return {
+				success: false,
+				message: `Target directory ${targetPath} does not exist. Please create the parent directory first.`
+			};
+			const architectConfig = await this.scaffoldConfigLoader.parseArchitectConfig(templatePath);
+			if (!architectConfig || !architectConfig.features) return {
+				success: false,
+				message: `Invalid architect configuration: missing 'features' section in scaffold.yaml`
+			};
+			const featureArray = architectConfig.features;
+			let config;
+			if (Array.isArray(featureArray)) {
+				config = featureArray.find((f) => f.name === featureName);
+				if (!config) return {
+					success: false,
+					message: `Feature '${featureName}' not found in scaffold configuration`
+				};
+			} else config = architectConfig.features;
+			const allVariables = {
+				...variables,
+				projectName,
+				appPath: targetPath,
+				appName: projectName
+			};
+			return await this.processScaffold({
+				config,
+				targetPath,
+				templatePath,
+				allVariables,
+				scaffoldType: "feature"
+			});
+		} catch (error) {
+			return {
+				success: false,
+				message: `Error scaffolding feature: ${error instanceof Error ? error.message : String(error)}`
+			};
+		}
+	}
+	/**
+	* Common scaffolding processing logic shared by both useBoilerplate and useFeature
+	*/
+	async processScaffold(params) {
+		const { config, targetPath, templatePath, allVariables, scaffoldType } = params;
+		log.debug("Config generator:", config.generator);
+		log.debug("Config:", JSON.stringify(config, null, 2));
+		if (config.generator) {
+			log.info("Using custom generator:", config.generator);
+			try {
+				const generator = (await import(path.join(templatePath, "generators", config.generator))).default;
+				if (typeof generator !== "function") return {
+					success: false,
+					message: `Invalid generator: ${config.generator} does not export a default function`
+				};
+				return await generator({
+					variables: allVariables,
+					config,
+					targetPath,
+					templatePath,
+					fileSystem: this.fileSystem,
+					scaffoldConfigLoader: this.scaffoldConfigLoader,
+					variableReplacer: this.variableReplacer,
+					ScaffoldProcessingService: this.processingService.constructor,
+					getRootPath: () => {
+						const __dirname = path.dirname(fileURLToPath(import.meta.url));
+						return path.join(__dirname, "../../../../..");
+					},
+					getProjectPath: (projectPath) => {
+						const __dirname = path.dirname(fileURLToPath(import.meta.url));
+						const rootPath = path.join(__dirname, "../../../../..");
+						return projectPath.replace(rootPath, "").replace("/", "");
+					}
+				});
+			} catch (error) {
+				return {
+					success: false,
+					message: `Error loading or executing generator ${config.generator}: ${error instanceof Error ? error.message : String(error)}`
+				};
+			}
+		}
+		const parsedIncludes = [];
+		const warnings = [];
+		if (config.includes && Array.isArray(config.includes)) {
+			const filteredIncludes = config.includes.map((includeEntry) => this.scaffoldConfigLoader.parseIncludeEntry(includeEntry, allVariables)).filter((parsed) => this.scaffoldConfigLoader.shouldIncludeFile(parsed.conditions, allVariables));
+			const existsResults = await Promise.all(filteredIncludes.map(async (parsed) => {
+				const targetFilePath = path.join(targetPath, parsed.targetPath);
+				return {
+					parsed,
+					exists: await this.fileSystem.pathExists(targetFilePath)
+				};
+			}));
+			for (const { parsed, exists } of existsResults) {
+				parsedIncludes.push(parsed);
+				if (exists) warnings.push(`File/folder ${parsed.targetPath} already exists and will be preserved`);
+			}
+		}
+		await this.fileSystem.ensureDir(targetPath);
+		const createdFiles = [];
+		const existingFiles = [];
+		await Promise.all(parsedIncludes.map(async (parsed) => {
+			const sourcePath = path.join(templatePath, parsed.sourcePath);
+			const targetFilePath = path.join(targetPath, parsed.targetPath);
+			await this.processingService.copyAndProcess(sourcePath, targetFilePath, allVariables, createdFiles, existingFiles);
+		}));
+		let message = `Successfully scaffolded ${scaffoldType} at ${targetPath}`;
+		if (existingFiles.length > 0) message += `. ${existingFiles.length} existing file(s) were preserved`;
+		message += ". Run 'pnpm install' to install dependencies.";
+		return {
+			success: true,
+			message,
+			warnings: warnings.length > 0 ? warnings : void 0,
+			createdFiles: createdFiles.length > 0 ? createdFiles : void 0,
+			existingFiles: existingFiles.length > 0 ? existingFiles : void 0
+		};
+	}
+};
+
+//#endregion
+//#region src/services/TemplateService.ts
+var TemplateService = class {
+	liquid;
+	constructor() {
+		this.liquid = new Liquid({
+			strictFilters: false,
+			strictVariables: false
+		});
+		this.setupCustomFilters();
+		log.info("TemplateService initialized");
+	}
+	toPascalCase(str) {
+		const camelCase = str.replace(/[-_\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : "");
+		return camelCase.charAt(0).toUpperCase() + camelCase.slice(1);
+	}
+	setupCustomFilters() {
+		this.liquid.registerFilter("camelCase", (str) => {
+			return str.replace(/[-_\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : "");
+		});
+		this.liquid.registerFilter("pascalCase", (str) => {
+			return this.toPascalCase(str);
+		});
+		this.liquid.registerFilter("titleCase", (str) => {
+			return this.toPascalCase(str);
+		});
+		this.liquid.registerFilter("kebabCase", (str) => {
+			return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+		});
+		this.liquid.registerFilter("snakeCase", (str) => {
+			return str.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").toLowerCase();
+		});
+		this.liquid.registerFilter("upperCase", (str) => {
+			return str.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").toUpperCase();
+		});
+		this.liquid.registerFilter("lower", (str) => str.toLowerCase());
+		this.liquid.registerFilter("upper", (str) => str.toUpperCase());
+		this.liquid.registerFilter("pluralize", (str) => {
+			if (str.endsWith("y")) return `${str.slice(0, -1)}ies`;
+			else if (str.endsWith("s") || str.endsWith("sh") || str.endsWith("ch") || str.endsWith("x") || str.endsWith("z")) return `${str}es`;
+			else return `${str}s`;
+		});
+		this.liquid.registerFilter("singularize", (str) => {
+			if (str.endsWith("ies")) return `${str.slice(0, -3)}y`;
+			else if (str.endsWith("es")) return str.slice(0, -2);
+			else if (str.endsWith("s") && !str.endsWith("ss")) return str.slice(0, -1);
+			else return str;
+		});
+		this.liquid.registerFilter("strip", (str) => {
+			return str.trim();
+		});
+	}
+	renderString(template, variables) {
+		try {
+			log.debug("Rendering template", {
+				variables,
+				templatePreview: template.substring(0, 100)
+			});
+			const result = this.liquid.parseAndRenderSync(template, variables);
+			log.debug("Rendered template", { resultPreview: result.substring(0, 100) });
+			return result;
+		} catch (error) {
+			log.error("LiquidJS rendering error", {
+				error: error instanceof Error ? error.message : String(error),
+				templatePreview: template.substring(0, 200),
+				variables
+			});
+			return template;
+		}
+	}
+	containsTemplateVariables(content) {
+		return [/\{\{.*?\}\}/, /\{%.*?%\}/].some((pattern) => pattern.test(content));
+	}
+};
+
+//#endregion
+//#region src/services/VariableReplacementService.ts
+var VariableReplacementService = class {
+	binaryExtensions = [
+		".png",
+		".jpg",
+		".jpeg",
+		".gif",
+		".ico",
+		".woff",
+		".woff2",
+		".ttf",
+		".eot",
+		".pdf",
+		".zip",
+		".tar",
+		".gz",
+		".exe",
+		".dll",
+		".so",
+		".dylib"
+	];
+	constructor(fileSystem, templateService) {
+		this.fileSystem = fileSystem;
+		this.templateService = templateService;
+	}
+	async processFilesForVariableReplacement(dirPath, variables) {
+		let items = [];
+		try {
+			items = await this.fileSystem.readdir(dirPath);
+		} catch (error) {
+			log.warn(`Skipping directory ${dirPath}: ${error}`);
+			return;
+		}
+		const itemPaths = items.filter((item) => item).map((item) => path.join(dirPath, item));
+		const statResults = await Promise.all(itemPaths.map(async (itemPath) => {
+			try {
+				return {
+					itemPath,
+					stat: await this.fileSystem.stat(itemPath),
+					error: null
+				};
+			} catch (error) {
+				log.warn(`Skipping item ${itemPath}: ${error}`);
+				return {
+					itemPath,
+					stat: null,
+					error
+				};
+			}
+		}));
+		const directories = [];
+		const files = [];
+		for (const { itemPath, stat: stat$1 } of statResults) {
+			if (!stat$1) continue;
+			if (stat$1.isDirectory()) directories.push(itemPath);
+			else if (stat$1.isFile()) files.push(itemPath);
+		}
+		await Promise.all([...files.map((file) => this.replaceVariablesInFile(file, variables)), ...directories.map((dir) => this.processFilesForVariableReplacement(dir, variables))]);
+	}
+	async replaceVariablesInFile(filePath, variables) {
+		try {
+			if (this.isBinaryFile(filePath)) return;
+			const content = await this.fileSystem.readFile(filePath, "utf8");
+			const renderedContent = this.templateService.renderString(content, variables);
+			await this.fileSystem.writeFile(filePath, renderedContent, "utf8");
+		} catch (error) {
+			log.warn(`Skipping file ${filePath}: ${error}`);
+		}
+	}
+	isBinaryFile(filePath) {
+		const ext = path.extname(filePath).toLowerCase();
+		return this.binaryExtensions.includes(ext);
+	}
+};
+
+//#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 itemPaths = (await this.fileSystem.readdir(this.templatesRootPath)).map((item) => ({
+				item,
+				itemPath: path.join(this.templatesRootPath, item)
+			}));
+			const itemResults = await Promise.all(itemPaths.map(async ({ item, itemPath }) => {
+				try {
+					if (!(await this.fileSystem.stat(itemPath)).isDirectory()) return {
+						item,
+						itemPath,
+						isDir: false,
+						hasScaffold: false
+					};
+					const scaffoldYamlPath = path.join(itemPath, "scaffold.yaml");
+					return {
+						item,
+						itemPath,
+						isDir: true,
+						hasScaffold: await this.fileSystem.pathExists(scaffoldYamlPath)
+					};
+				} catch {
+					return {
+						item,
+						itemPath,
+						isDir: false,
+						hasScaffold: false
+					};
+				}
+			}));
+			const categoryDirs = [];
+			for (const result of itemResults) {
+				if (!result.isDir) continue;
+				if (result.hasScaffold) templateDirs.push(result.item);
+				else categoryDirs.push({
+					item: result.item,
+					itemPath: result.itemPath
+				});
+			}
+			const nestedResults = await Promise.all(categoryDirs.map(async ({ item, itemPath }) => {
+				const found = [];
+				try {
+					const subItems = await this.fileSystem.readdir(itemPath);
+					const subResults = await Promise.all(subItems.map(async (subItem) => {
+						const subItemPath = path.join(itemPath, subItem);
+						try {
+							if (!(await this.fileSystem.stat(subItemPath)).isDirectory()) return null;
+							const subScaffoldYamlPath = path.join(subItemPath, "scaffold.yaml");
+							if (await this.fileSystem.pathExists(subScaffoldYamlPath)) return path.join(item, subItem);
+						} catch {
+							return null;
+						}
+						return null;
+					}));
+					for (const relativePath of subResults) if (relativePath) found.push(relativePath);
+				} catch (error) {
+					log.warn(`Failed to read subdirectories in ${itemPath}:`, error);
+				}
+				return found;
+			}));
+			for (const dirs of nestedResults) templateDirs.push(...dirs);
+		} catch (error) {
+			log.warn(`Failed to read templates root directory ${this.templatesRootPath}:`, error);
+		}
+		return templateDirs;
+	}
+	async useScaffoldMethod(request) {
+		const { projectPath, scaffold_feature_name, variables, sessionId } = 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 templateService = new TemplateService();
+		const scaffoldConfigLoader = new ScaffoldConfigLoader(this.fileSystem, templateService);
+		const variableReplacer = new VariableReplacementService(this.fileSystem, templateService);
+		const scaffoldService = new ScaffoldService(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);
+		if (sessionId && result.createdFiles && result.createdFiles.length > 0) try {
+			const { ExecutionLogService, DECISION_ALLOW } = await import("@agiflowai/hooks-adapter");
+			await new ExecutionLogService(sessionId).logExecution({
+				filePath: absoluteProjectPath,
+				operation: "scaffold",
+				decision: DECISION_ALLOW,
+				generatedFiles: result.createdFiles
+			});
+		} catch (error) {
+			log.warn("Failed to log scaffold execution:", error);
+		}
+		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/instructions/tools/list-scaffolding-methods/description.md?raw
+var description_default = "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, { 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
+export { ScaffoldService as a, FileSystemService as c, TemplateService as i, PaginationHelper as l, ScaffoldingMethodsService as n, ScaffoldProcessingService as o, VariableReplacementService as r, ScaffoldConfigLoader as s, ListScaffoldingMethodsTool as t };