@agiflowai/scaffold-mcp 1.0.12 → 1.0.14

package/dist/ListScaffoldingMethodsTool-D7S3xpJE.cjs

@@ -1,1082 +0,0 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") {
-		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-			key = keys[i];
-			if (!__hasOwnProp.call(to, key) && key !== except) {
-				__defProp(to, key, {
-					get: ((k) => from[k]).bind(null, key),
-					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-				});
-			}
-		}
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-let node_path = require("node:path");
-node_path = __toESM(node_path);
-let __agiflowai_aicode_utils = require("@agiflowai/aicode-utils");
-let js_yaml = require("js-yaml");
-js_yaml = __toESM(js_yaml);
-let zod = require("zod");
-let node_url = require("node:url");
-let liquidjs = require("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$5) {
-		return (0, __agiflowai_aicode_utils.pathExists)(path$5);
-	}
-	async readFile(path$5, encoding = "utf8") {
-		return (0, __agiflowai_aicode_utils.readFile)(path$5, encoding);
-	}
-	async readJson(path$5) {
-		return (0, __agiflowai_aicode_utils.readJson)(path$5);
-	}
-	async writeFile(path$5, content, encoding = "utf8") {
-		return (0, __agiflowai_aicode_utils.writeFile)(path$5, content, encoding);
-	}
-	async ensureDir(path$5) {
-		return (0, __agiflowai_aicode_utils.ensureDir)(path$5);
-	}
-	async copy(src, dest) {
-		return (0, __agiflowai_aicode_utils.copy)(src, dest);
-	}
-	async readdir(path$5) {
-		return (0, __agiflowai_aicode_utils.readdir)(path$5);
-	}
-	async stat(path$5) {
-		return (0, __agiflowai_aicode_utils.stat)(path$5);
-	}
-};
-
-//#endregion
-//#region src/services/ScaffoldConfigLoader.ts
-const VariablesSchemaSchema = zod.z.object({
-	type: zod.z.literal("object"),
-	properties: zod.z.record(zod.z.any()),
-	required: zod.z.array(zod.z.string()),
-	additionalProperties: zod.z.boolean()
-});
-const ScaffoldConfigEntrySchema = zod.z.object({
-	name: zod.z.string(),
-	description: zod.z.string().optional(),
-	instruction: zod.z.string().optional(),
-	targetFolder: zod.z.string().optional(),
-	variables_schema: VariablesSchemaSchema,
-	includes: zod.z.array(zod.z.string()),
-	generator: zod.z.string().optional(),
-	patterns: zod.z.array(zod.z.string()).optional()
-});
-const ScaffoldYamlSchema = zod.z.object({
-	boilerplate: zod.z.union([ScaffoldConfigEntrySchema, zod.z.array(ScaffoldConfigEntrySchema)]).optional(),
-	features: zod.z.union([ScaffoldConfigEntrySchema, zod.z.array(ScaffoldConfigEntrySchema)]).optional()
-}).catchall(zod.z.union([ScaffoldConfigEntrySchema, zod.z.array(ScaffoldConfigEntrySchema)]));
-var ScaffoldConfigLoader = class {
-	constructor(fileSystem, templateService) {
-		this.fileSystem = fileSystem;
-		this.templateService = templateService;
-	}
-	async parseArchitectConfig(templatePath) {
-		const architectPath = node_path.default.join(templatePath, "scaffold.yaml");
-		if (!await this.fileSystem.pathExists(architectPath)) return null;
-		try {
-			const content = await this.fileSystem.readFile(architectPath, "utf8");
-			const rawConfig = js_yaml.default.load(content);
-			return ScaffoldYamlSchema.parse(rawConfig);
-		} catch (error) {
-			if (error instanceof zod.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 = node_path.default.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(node_path.default.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) {
-			__agiflowai_aicode_utils.log.warn(`Cannot read directory ${dirPath}: ${error}`);
-			return;
-		}
-		const itemPaths = items.filter((item) => item).map((item) => node_path.default.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) {
-				__agiflowai_aicode_utils.log.warn(`Cannot stat ${itemPath}: ${error}`);
-				return {
-					itemPath,
-					stat: null,
-					error
-				};
-			}
-		}));
-		const directories = [];
-		for (const { itemPath, stat } of statResults) {
-			if (!stat) continue;
-			if (stat.isDirectory()) directories.push(itemPath);
-			else if (stat.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) {
-			__agiflowai_aicode_utils.log.warn(`Cannot read directory ${dirPath}: ${error}`);
-			return;
-		}
-		const itemPaths = items.filter((item) => item).map((item) => node_path.default.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) {
-				__agiflowai_aicode_utils.log.warn(`Cannot stat ${itemPath}: ${error}`);
-				return {
-					itemPath,
-					stat: null,
-					error
-				};
-			}
-		}));
-		const directories = [];
-		for (const { itemPath, stat } of statResults) {
-			if (!stat) continue;
-			if (stat.isDirectory()) directories.push(itemPath);
-			else if (stat.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 || __agiflowai_aicode_utils.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 = node_path.default.isAbsolute(targetFolder) ? projectName ? node_path.default.join(targetFolder, projectName) : targetFolder : projectName ? node_path.default.join(process.cwd(), targetFolder, projectName) : node_path.default.join(process.cwd(), targetFolder);
-			const templatePath = node_path.default.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 = node_path.default.resolve(projectPath);
-			const templatePath = node_path.default.join(this.templatesRootPath, templateFolder);
-			const projectName = node_path.default.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;
-		__agiflowai_aicode_utils.log.debug("Config generator:", config.generator);
-		__agiflowai_aicode_utils.log.debug("Config:", JSON.stringify(config, null, 2));
-		if (config.generator) {
-			__agiflowai_aicode_utils.log.info("Using custom generator:", config.generator);
-			try {
-				const generator = (await import(node_path.default.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$1 = node_path.default.dirname((0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
-						return node_path.default.join(__dirname$1, "../../../../..");
-					},
-					getProjectPath: (projectPath) => {
-						const __dirname$1 = node_path.default.dirname((0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
-						const rootPath = node_path.default.join(__dirname$1, "../../../../..");
-						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 = node_path.default.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 = node_path.default.join(templatePath, parsed.sourcePath);
-			const targetFilePath = node_path.default.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 liquidjs.Liquid({
-			strictFilters: false,
-			strictVariables: false
-		});
-		this.setupCustomFilters();
-		__agiflowai_aicode_utils.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 {
-			__agiflowai_aicode_utils.log.debug("Rendering template", {
-				variables,
-				templatePreview: template.substring(0, 100)
-			});
-			const result = this.liquid.parseAndRenderSync(template, variables);
-			__agiflowai_aicode_utils.log.debug("Rendered template", { resultPreview: result.substring(0, 100) });
-			return result;
-		} catch (error) {
-			__agiflowai_aicode_utils.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) {
-			__agiflowai_aicode_utils.log.warn(`Skipping directory ${dirPath}: ${error}`);
-			return;
-		}
-		const itemPaths = items.filter((item) => item).map((item) => node_path.default.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) {
-				__agiflowai_aicode_utils.log.warn(`Skipping item ${itemPath}: ${error}`);
-				return {
-					itemPath,
-					stat: null,
-					error
-				};
-			}
-		}));
-		const directories = [];
-		const files = [];
-		for (const { itemPath, stat } of statResults) {
-			if (!stat) continue;
-			if (stat.isDirectory()) directories.push(itemPath);
-			else if (stat.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) {
-			__agiflowai_aicode_utils.log.warn(`Skipping file ${filePath}: ${error}`);
-		}
-	}
-	isBinaryFile(filePath) {
-		const ext = node_path.default.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 = 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 itemPaths = (await this.fileSystem.readdir(this.templatesRootPath)).map((item) => ({
-				item,
-				itemPath: node_path.default.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 = node_path.default.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 = node_path.default.join(itemPath, subItem);
-						try {
-							if (!(await this.fileSystem.stat(subItemPath)).isDirectory()) return null;
-							const subScaffoldYamlPath = node_path.default.join(subItemPath, "scaffold.yaml");
-							if (await this.fileSystem.pathExists(subScaffoldYamlPath)) return node_path.default.join(item, subItem);
-						} catch {
-							return null;
-						}
-						return null;
-					}));
-					for (const relativePath of subResults) if (relativePath) found.push(relativePath);
-				} catch (error) {
-					__agiflowai_aicode_utils.log.warn(`Failed to read subdirectories in ${itemPath}:`, error);
-				}
-				return found;
-			}));
-			for (const dirs of nestedResults) templateDirs.push(...dirs);
-		} 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, 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 = 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);
-		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) {
-			__agiflowai_aicode_utils.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 __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
-Object.defineProperty(exports, 'FileSystemService', {
-  enumerable: true,
-  get: function () {
-    return FileSystemService;
-  }
-});
-Object.defineProperty(exports, 'ListScaffoldingMethodsTool', {
-  enumerable: true,
-  get: function () {
-    return ListScaffoldingMethodsTool;
-  }
-});
-Object.defineProperty(exports, 'PaginationHelper', {
-  enumerable: true,
-  get: function () {
-    return PaginationHelper;
-  }
-});
-Object.defineProperty(exports, 'ScaffoldConfigLoader', {
-  enumerable: true,
-  get: function () {
-    return ScaffoldConfigLoader;
-  }
-});
-Object.defineProperty(exports, 'ScaffoldProcessingService', {
-  enumerable: true,
-  get: function () {
-    return ScaffoldProcessingService;
-  }
-});
-Object.defineProperty(exports, 'ScaffoldService', {
-  enumerable: true,
-  get: function () {
-    return ScaffoldService;
-  }
-});
-Object.defineProperty(exports, 'ScaffoldingMethodsService', {
-  enumerable: true,
-  get: function () {
-    return ScaffoldingMethodsService;
-  }
-});
-Object.defineProperty(exports, 'TemplateService', {
-  enumerable: true,
-  get: function () {
-    return TemplateService;
-  }
-});
-Object.defineProperty(exports, 'VariableReplacementService', {
-  enumerable: true,
-  get: function () {
-    return VariableReplacementService;
-  }
-});
-Object.defineProperty(exports, '__toESM', {
-  enumerable: true,
-  get: function () {
-    return __toESM;
-  }
-});