@agiflowai/scaffold-mcp 0.0.0

package/dist/ScaffoldService-CnJ1nj1v.js

@@ -0,0 +1,408 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import * as fs$1 from "fs-extra";
+import { fileURLToPath } from "node:url";
+
+//#region rolldown:runtime
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#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) {
+			console.warn(`Cannot read directory ${dirPath}: ${error}`);
+			return;
+		}
+		for (const item of items) {
+			if (!item) continue;
+			const itemPath = path.join(dirPath, item);
+			try {
+				const stat = await this.fileSystem.stat(itemPath);
+				if (stat.isDirectory()) await this.trackCreatedFilesRecursive(itemPath, createdFiles);
+				else if (stat.isFile()) createdFiles.push(itemPath);
+			} catch (error) {
+				console.warn(`Cannot stat ${itemPath}: ${error}`);
+			}
+		}
+	}
+	/**
+	* 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) {
+			console.warn(`Cannot read directory ${dirPath}: ${error}`);
+			return;
+		}
+		for (const item of items) {
+			if (!item) continue;
+			const itemPath = path.join(dirPath, item);
+			try {
+				const stat = await this.fileSystem.stat(itemPath);
+				if (stat.isDirectory()) await this.trackExistingFilesRecursive(itemPath, existingFiles);
+				else if (stat.isFile()) existingFiles.push(itemPath);
+			} catch (error) {
+				console.warn(`Cannot stat ${itemPath}: ${error}`);
+			}
+		}
+	}
+};
+
+//#endregion
+//#region src/services/TemplatesManager.ts
+var TemplatesManager = class TemplatesManager {
+	static SCAFFOLD_CONFIG_FILE = "scaffold.yaml";
+	static TEMPLATES_FOLDER = "templates";
+	static TOOLKIT_CONFIG_FILE = "toolkit.yaml";
+	/**
+	* Find the templates directory by searching upwards from the starting path.
+	*
+	* Algorithm:
+	* 1. Start from the provided path (default: current working directory)
+	* 2. Search upwards to find the workspace root (where .git exists or filesystem root)
+	* 3. Check if toolkit.yaml exists at workspace root
+	*    - If yes, read templatesPath from toolkit.yaml
+	*    - If no, default to 'templates' folder in workspace root
+	* 4. Verify the templates directory exists
+	*
+	* @param startPath - The path to start searching from (defaults to process.cwd())
+	* @returns The absolute path to the templates directory
+	* @throws Error if templates directory is not found
+	*/
+	static async findTemplatesPath(startPath = process.cwd()) {
+		const workspaceRoot = await TemplatesManager.findWorkspaceRoot(startPath);
+		const toolkitConfigPath = path.join(workspaceRoot, TemplatesManager.TOOLKIT_CONFIG_FILE);
+		if (await fs$1.pathExists(toolkitConfigPath)) {
+			const yaml = await import("js-yaml");
+			const content = await fs$1.readFile(toolkitConfigPath, "utf-8");
+			const config = yaml.load(content);
+			if (config?.templatesPath) {
+				const templatesPath$1 = path.isAbsolute(config.templatesPath) ? config.templatesPath : path.join(workspaceRoot, config.templatesPath);
+				if (await fs$1.pathExists(templatesPath$1)) return templatesPath$1;
+				else throw new Error(`Templates path specified in toolkit.yaml does not exist: ${templatesPath$1}`);
+			}
+		}
+		const templatesPath = path.join(workspaceRoot, TemplatesManager.TEMPLATES_FOLDER);
+		if (await fs$1.pathExists(templatesPath)) return templatesPath;
+		throw new Error(`Templates folder not found at ${templatesPath}.\nEither create a 'templates' folder or specify templatesPath in toolkit.yaml`);
+	}
+	/**
+	* Find the workspace root by searching upwards for .git folder
+	*/
+	static async findWorkspaceRoot(startPath) {
+		let currentPath = path.resolve(startPath);
+		const rootPath = path.parse(currentPath).root;
+		while (true) {
+			const gitPath = path.join(currentPath, ".git");
+			if (await fs$1.pathExists(gitPath)) return currentPath;
+			if (currentPath === rootPath) return process.cwd();
+			currentPath = path.dirname(currentPath);
+		}
+	}
+	/**
+	* Get the templates path synchronously.
+	* Use this when you need immediate access and are sure templates exist.
+	*
+	* @param startPath - The path to start searching from (defaults to process.cwd())
+	* @returns The absolute path to the templates directory
+	* @throws Error if templates directory is not found
+	*/
+	static findTemplatesPathSync(startPath = process.cwd()) {
+		const workspaceRoot = TemplatesManager.findWorkspaceRootSync(startPath);
+		const toolkitConfigPath = path.join(workspaceRoot, TemplatesManager.TOOLKIT_CONFIG_FILE);
+		if (fs$1.pathExistsSync(toolkitConfigPath)) {
+			const yaml = __require("js-yaml");
+			const content = fs$1.readFileSync(toolkitConfigPath, "utf-8");
+			const config = yaml.load(content);
+			if (config?.templatesPath) {
+				const templatesPath$1 = path.isAbsolute(config.templatesPath) ? config.templatesPath : path.join(workspaceRoot, config.templatesPath);
+				if (fs$1.pathExistsSync(templatesPath$1)) return templatesPath$1;
+				else throw new Error(`Templates path specified in toolkit.yaml does not exist: ${templatesPath$1}`);
+			}
+		}
+		const templatesPath = path.join(workspaceRoot, TemplatesManager.TEMPLATES_FOLDER);
+		if (fs$1.pathExistsSync(templatesPath)) return templatesPath;
+		throw new Error(`Templates folder not found at ${templatesPath}.\nEither create a 'templates' folder or specify templatesPath in toolkit.yaml`);
+	}
+	/**
+	* Find the workspace root synchronously by searching upwards for .git folder
+	*/
+	static findWorkspaceRootSync(startPath) {
+		let currentPath = path.resolve(startPath);
+		const rootPath = path.parse(currentPath).root;
+		while (true) {
+			const gitPath = path.join(currentPath, ".git");
+			if (fs$1.pathExistsSync(gitPath)) return currentPath;
+			if (currentPath === rootPath) return process.cwd();
+			currentPath = path.dirname(currentPath);
+		}
+	}
+	/**
+	* Check if templates are initialized at the given path
+	*
+	* @param templatesPath - Path to check for templates
+	* @returns true if templates folder exists and is a directory
+	*/
+	static async isInitialized(templatesPath) {
+		if (!await fs$1.pathExists(templatesPath)) return false;
+		return (await fs$1.stat(templatesPath)).isDirectory();
+	}
+	/**
+	* Get the scaffold config file name
+	*/
+	static getConfigFileName() {
+		return TemplatesManager.SCAFFOLD_CONFIG_FILE;
+	}
+	/**
+	* Get the templates folder name
+	*/
+	static getTemplatesFolderName() {
+		return TemplatesManager.TEMPLATES_FOLDER;
+	}
+};
+
+//#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;
+		this.templatesRootPath = templatesRootPath || TemplatesManager.findTemplatesPathSync();
+		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) ? path.join(targetFolder, projectName) : path.join(process.cwd(), targetFolder, projectName);
+			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 (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 allVariables = {
+				...variables,
+				projectName,
+				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;
+		console.log("Config generator:", config.generator);
+		console.log("Config:", JSON.stringify(config, null, 2));
+		if (config.generator) {
+			console.log("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)) for (const includeEntry of config.includes) {
+			const parsed = this.scaffoldConfigLoader.parseIncludeEntry(includeEntry, allVariables);
+			if (!this.scaffoldConfigLoader.shouldIncludeFile(parsed.conditions, allVariables)) continue;
+			parsedIncludes.push(parsed);
+			const targetFilePath = path.join(targetPath, parsed.targetPath);
+			if (await this.fileSystem.pathExists(targetFilePath)) warnings.push(`File/folder ${parsed.targetPath} already exists and will be preserved`);
+		}
+		await this.fileSystem.ensureDir(targetPath);
+		const createdFiles = [];
+		const existingFiles = [];
+		for (const parsed of parsedIncludes) {
+			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
+export { ScaffoldService, TemplatesManager };

package/dist/TemplateService-CnxvhRVW.js

@@ -0,0 +1,64 @@
+import { Liquid } from "liquidjs";
+
+//#region src/services/TemplateService.ts
+var TemplateService = class {
+	liquid;
+	constructor() {
+		this.liquid = new Liquid({
+			strictFilters: false,
+			strictVariables: false
+		});
+		this.setupCustomFilters();
+	}
+	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;
+		});
+	}
+	renderString(template, variables) {
+		try {
+			return this.liquid.parseAndRenderSync(template, variables);
+		} catch (error) {
+			console.warn(`LiquidJS rendering error: ${error}`);
+			return template;
+		}
+	}
+	containsTemplateVariables(content) {
+		return [/\{\{.*?\}\}/, /\{%.*?%\}/].some((pattern) => pattern.test(content));
+	}
+};
+
+//#endregion
+export { TemplateService };

package/dist/TemplateService-PmTU3_On.js

@@ -0,0 +1,3 @@
+import { TemplateService } from "./TemplateService-CnxvhRVW.js";
+
+export { TemplateService };

package/dist/VariableReplacementService-Bq0GDhTo.js

@@ -0,0 +1,65 @@
+import path from "node:path";
+
+//#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) {
+			console.warn(`Skipping directory ${dirPath}: ${error}`);
+			return;
+		}
+		for (const item of items) {
+			if (!item) continue;
+			const itemPath = path.join(dirPath, item);
+			try {
+				const stat = await this.fileSystem.stat(itemPath);
+				if (stat.isDirectory()) await this.processFilesForVariableReplacement(itemPath, variables);
+				else if (stat.isFile()) await this.replaceVariablesInFile(itemPath, variables);
+			} catch (error) {
+				console.warn(`Skipping item ${itemPath}: ${error}`);
+			}
+		}
+	}
+	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) {
+			console.warn(`Skipping file ${filePath}: ${error}`);
+		}
+	}
+	isBinaryFile(filePath) {
+		const ext = path.extname(filePath).toLowerCase();
+		return this.binaryExtensions.includes(ext);
+	}
+};
+
+//#endregion
+export { VariableReplacementService };

package/dist/VariableReplacementService-CrxFJrqU.js

@@ -0,0 +1,3 @@
+import { VariableReplacementService } from "./VariableReplacementService-Bq0GDhTo.js";
+
+export { VariableReplacementService };