@agiflowai/scaffold-mcp 1.0.10 → 1.0.12

package/dist/ListScaffoldingMethodsTool-DuYGFDwJ.cjs

@@ -1,376 +0,0 @@
-const require_chunk = require('./chunk-CbDLau6x.cjs');
-const require_TemplateService = require('./TemplateService-7QcWREot.cjs');
-let node_path = require("node:path");
-node_path = require_chunk.__toESM(node_path);
-let __agiflowai_aicode_utils = require("@agiflowai/aicode-utils");
-let js_yaml = require("js-yaml");
-js_yaml = require_chunk.__toESM(js_yaml);
-
-//#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 (0, __agiflowai_aicode_utils.pathExists)(path$1);
-	}
-	async readFile(path$1, encoding = "utf8") {
-		return (0, __agiflowai_aicode_utils.readFile)(path$1, encoding);
-	}
-	async readJson(path$1) {
-		return (0, __agiflowai_aicode_utils.readJson)(path$1);
-	}
-	async writeFile(path$1, content, encoding = "utf8") {
-		return (0, __agiflowai_aicode_utils.writeFile)(path$1, content, encoding);
-	}
-	async ensureDir(path$1) {
-		return (0, __agiflowai_aicode_utils.ensureDir)(path$1);
-	}
-	async copy(src, dest) {
-		return (0, __agiflowai_aicode_utils.copy)(src, dest);
-	}
-	async readdir(path$1) {
-		return (0, __agiflowai_aicode_utils.readdir)(path$1);
-	}
-	async stat(path$1) {
-		return (0, __agiflowai_aicode_utils.stat)(path$1);
-	}
-};
-
-//#endregion
-//#region src/services/ScaffoldingMethodsService.ts
-var ScaffoldingMethodsService = class {
-	templateService;
-	constructor(fileSystem, templatesRootPath) {
-		this.fileSystem = fileSystem;
-		this.templatesRootPath = templatesRootPath;
-		this.templateService = new require_TemplateService.TemplateService();
-	}
-	async listScaffoldingMethods(projectPath, cursor) {
-		const absoluteProjectPath = node_path.default.resolve(projectPath);
-		const sourceTemplate = (await __agiflowai_aicode_utils.ProjectConfigResolver.resolveProjectConfig(absoluteProjectPath)).sourceTemplate;
-		return this.listScaffoldingMethodsByTemplate(sourceTemplate, cursor);
-	}
-	async listScaffoldingMethodsByTemplate(templateName, cursor) {
-		const templatePath = await this.findTemplatePath(templateName);
-		if (!templatePath) throw new Error(`Template not found for sourceTemplate: ${templateName}`);
-		const fullTemplatePath = node_path.default.join(this.templatesRootPath, templatePath);
-		const scaffoldYamlPath = node_path.default.join(fullTemplatePath, "scaffold.yaml");
-		if (!await this.fileSystem.pathExists(scaffoldYamlPath)) throw new Error(`scaffold.yaml not found at ${scaffoldYamlPath}`);
-		const scaffoldContent = await this.fileSystem.readFile(scaffoldYamlPath, "utf8");
-		const architectConfig = js_yaml.default.load(scaffoldContent);
-		const methods = [];
-		if (architectConfig.features && Array.isArray(architectConfig.features)) architectConfig.features.forEach((feature) => {
-			const featureName = feature.name || `scaffold-${templateName}`;
-			methods.push({
-				name: featureName,
-				description: feature.description || "",
-				instruction: feature.instruction || "",
-				variables_schema: feature.variables_schema || {
-					type: "object",
-					properties: {},
-					required: [],
-					additionalProperties: false
-				},
-				generator: feature.generator
-			});
-		});
-		const paginatedResult = PaginationHelper.paginate(methods, cursor);
-		return {
-			sourceTemplate: templateName,
-			templatePath,
-			methods: paginatedResult.items,
-			nextCursor: paginatedResult.nextCursor,
-			_meta: paginatedResult._meta
-		};
-	}
-	/**
-	* Gets scaffolding methods with instructions rendered using provided variables
-	*/
-	async listScaffoldingMethodsWithVariables(projectPath, variables, cursor) {
-		const result = await this.listScaffoldingMethods(projectPath, cursor);
-		const processedMethods = result.methods.map((method) => ({
-			...method,
-			instruction: method.instruction ? this.processScaffoldInstruction(method.instruction, variables) : void 0
-		}));
-		return {
-			...result,
-			methods: processedMethods
-		};
-	}
-	/**
-	* Processes scaffold instruction with template service
-	*/
-	processScaffoldInstruction(instruction, variables) {
-		if (this.templateService.containsTemplateVariables(instruction)) return this.templateService.renderString(instruction, variables);
-		return instruction;
-	}
-	async findTemplatePath(sourceTemplate) {
-		const templateDirs = await this.discoverTemplateDirs();
-		if (templateDirs.includes(sourceTemplate)) return sourceTemplate;
-		for (const templateDir of templateDirs) {
-			const templatePath = node_path.default.join(this.templatesRootPath, templateDir);
-			const scaffoldYamlPath = node_path.default.join(templatePath, "scaffold.yaml");
-			if (await this.fileSystem.pathExists(scaffoldYamlPath)) try {
-				const scaffoldContent = await this.fileSystem.readFile(scaffoldYamlPath, "utf8");
-				const architectConfig = js_yaml.default.load(scaffoldContent);
-				if (architectConfig.boilerplate && Array.isArray(architectConfig.boilerplate)) {
-					for (const boilerplate of architectConfig.boilerplate) if (boilerplate.name?.includes(sourceTemplate)) return templateDir;
-				}
-			} catch (error) {
-				__agiflowai_aicode_utils.log.warn(`Failed to read scaffold.yaml at ${scaffoldYamlPath}:`, error);
-			}
-		}
-		return null;
-	}
-	/**
-	* Resolves the project path, handling both monorepo and monolith cases
-	* Uses ProjectConfigResolver to find the correct workspace/project root
-	*/
-	async resolveProjectPath(projectPath) {
-		const absolutePath = node_path.default.resolve(projectPath);
-		return (await __agiflowai_aicode_utils.ProjectConfigResolver.resolveProjectConfig(absolutePath)).workspaceRoot || absolutePath;
-	}
-	/**
-	* Dynamically discovers all template directories
-	* Supports both flat structure (templates/nextjs-15) and nested structure (templates/apps/nextjs-15)
-	**/
-	async discoverTemplateDirs() {
-		const templateDirs = [];
-		try {
-			const items = await this.fileSystem.readdir(this.templatesRootPath);
-			for (const item of items) {
-				const itemPath = node_path.default.join(this.templatesRootPath, item);
-				if (!(await this.fileSystem.stat(itemPath)).isDirectory()) continue;
-				const scaffoldYamlPath = node_path.default.join(itemPath, "scaffold.yaml");
-				if (await this.fileSystem.pathExists(scaffoldYamlPath)) {
-					templateDirs.push(item);
-					continue;
-				}
-				try {
-					const subItems = await this.fileSystem.readdir(itemPath);
-					for (const subItem of subItems) {
-						const subItemPath = node_path.default.join(itemPath, subItem);
-						if (!(await this.fileSystem.stat(subItemPath)).isDirectory()) continue;
-						const subScaffoldYamlPath = node_path.default.join(subItemPath, "scaffold.yaml");
-						if (await this.fileSystem.pathExists(subScaffoldYamlPath)) {
-							const relativePath = node_path.default.join(item, subItem);
-							templateDirs.push(relativePath);
-						}
-					}
-				} catch (error) {
-					__agiflowai_aicode_utils.log.warn(`Failed to read subdirectories in ${itemPath}:`, error);
-				}
-			}
-		} catch (error) {
-			__agiflowai_aicode_utils.log.warn(`Failed to read templates root directory ${this.templatesRootPath}:`, error);
-		}
-		return templateDirs;
-	}
-	async useScaffoldMethod(request) {
-		const { projectPath, scaffold_feature_name, variables, 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 ScaffoldService = (await Promise.resolve().then(() => require("./ScaffoldService-DfXjmrNT.cjs"))).ScaffoldService;
-		const ScaffoldConfigLoader = (await Promise.resolve().then(() => require("./ScaffoldConfigLoader-HutEtfaH.cjs"))).ScaffoldConfigLoader;
-		const VariableReplacementService = (await Promise.resolve().then(() => require("./VariableReplacementService-wuYKgeui.cjs"))).VariableReplacementService;
-		const TemplateService$1 = (await Promise.resolve().then(() => require("./TemplateService-DUbdBOFs.cjs"))).TemplateService;
-		const templateService = new TemplateService$1();
-		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 require_TemplateService.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, 'ScaffoldingMethodsService', {
-  enumerable: true,
-  get: function () {
-    return ScaffoldingMethodsService;
-  }
-});

package/dist/ScaffoldConfigLoader-8YI7v2GJ.mjs

@@ -1,142 +0,0 @@
-import path from "node:path";
-import yaml from "js-yaml";
-import { z } from "zod";
-
-//#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
-export { ScaffoldConfigLoader as t };

package/dist/ScaffoldConfigLoader-BWpNpMx-.cjs

@@ -1,150 +0,0 @@
-const require_chunk = require('./chunk-CbDLau6x.cjs');
-let node_path = require("node:path");
-node_path = require_chunk.__toESM(node_path);
-let js_yaml = require("js-yaml");
-js_yaml = require_chunk.__toESM(js_yaml);
-let zod = require("zod");
-
-//#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
-Object.defineProperty(exports, 'ScaffoldConfigLoader', {
-  enumerable: true,
-  get: function () {
-    return ScaffoldConfigLoader;
-  }
-});

package/dist/ScaffoldConfigLoader-DKJtnrWT.mjs

@@ -1,3 +0,0 @@
-import { t as ScaffoldConfigLoader } from "./ScaffoldConfigLoader-8YI7v2GJ.mjs";
-
-export { ScaffoldConfigLoader };

package/dist/ScaffoldConfigLoader-HutEtfaH.cjs

@@ -1,3 +0,0 @@
-const require_ScaffoldConfigLoader = require('./ScaffoldConfigLoader-BWpNpMx-.cjs');
-
-exports.ScaffoldConfigLoader = require_ScaffoldConfigLoader.ScaffoldConfigLoader;