@agiflowai/scaffold-mcp 0.5.0 → 1.0.0

package/README.md

@@ -10,7 +10,6 @@ A Model Context Protocol (MCP) server for scaffolding applications with boilerpl
 - **Liquid templating**: Use powerful templating engine for dynamic file generation
 - **Variable replacement**: Customize generated code with context-aware variable substitution
 - **Dynamic template discovery**: Automatically finds templates in your workspace
-- **Template management**: Initialize templates folder and add templates from remote repositories
 - **Multiple frameworks**: Support for Next.js, Vite React, and custom boilerplates
 - **Multiple modes**: MCP server mode (stdio/HTTP/SSE) and standalone CLI mode
 - **MCP integration**: Seamlessly works with Claude Code and other MCP-compatible clients
@@ -149,36 +148,9 @@ Or if installed globally:
 
 ### 2. CLI Commands
 
-Use scaffold-mcp as a standalone CLI tool for template management and scaffolding.
+Use scaffold-mcp as a standalone CLI tool for scaffolding projects and adding features.
 
-#### Template Management
-
-```bash
-# Initialize templates folder and auto-download official templates
-scaffold-mcp init
-
-# Initialize at custom path
-scaffold-mcp init --path ./custom-templates
-
-# Initialize without downloading templates
-scaffold-mcp init --no-download
-
-# Add templates from repositories (full or subdirectory)
-scaffold-mcp add --name my-template --url https://github.com/user/template
-scaffold-mcp add --name nextjs-custom --url https://github.com/user/repo/tree/main/templates/nextjs
-```
-
-**What `init` does:**
-1. Creates `templates/` folder in your workspace root
-2. Automatically downloads official templates from [AgiFlow/aicode-toolkit](https://github.com/AgiFlow/aicode-toolkit/tree/main/templates)
-3. Creates a README.md with usage instructions
-4. Skips templates that already exist (safe to re-run)
-
-**What `add` does:**
-1. Parses GitHub URL to detect full repository vs subdirectory
-2. Downloads template using git clone (full repo) or sparse checkout (subdirectory)
-3. Validates template has required configuration files (scaffold.yaml)
-4. Saves template to your templates folder
+**Note:** Template management (init, add) is now handled by the `@agiflowai/aicode-toolkit` CLI. See [aicode-toolkit documentation](../../apps/aicode-toolkit/README.md) for details.
 
 #### Boilerplate Commands
 
@@ -220,53 +192,21 @@ scaffold-mcp scaffold add scaffold-nextjs-page \
 
 ## Quick Start
 
-### 1. Initialize Templates
+### 1. Setup Templates
 
-The `init` command sets up your templates folder and **automatically downloads official templates** from the AgiFlow repository:
+For template management (downloading and managing templates), use the `@agiflowai/aicode-toolkit` CLI:
 
 ```bash
-# Initialize templates folder and download official templates
-scaffold-mcp init
+# Initialize workspace and download templates
+npx @agiflowai/aicode-toolkit init
 
-# Or specify a custom path
-scaffold-mcp init --path ./my-templates
-
-# Skip auto-download if you want to add templates manually
-scaffold-mcp init --no-download
-```
-
-**What gets downloaded:**
-- ✅ `nextjs-15-drizzle` - Next.js 15 with App Router, TypeScript, Tailwind CSS 4, Storybook, and optional Drizzle ORM
-- ✅ More templates coming soon...
-
-All templates from [github.com/AgiFlow/aicode-toolkit/templates](https://github.com/AgiFlow/aicode-toolkit/tree/main/templates) are automatically pulled into your workspace.
-
-### 2. Add Custom Templates
-
-Add additional templates from GitHub repositories or subdirectories:
-
-```bash
-# Add a template from a full repository
-scaffold-mcp add --name my-template --url https://github.com/yourorg/nextjs-template
-
-# Add a template from a repository subdirectory (NEW!)
-scaffold-mcp add \
-  --name nextjs-15-drizzle \
-  --url https://github.com/AgiFlow/aicode-toolkit/tree/main/templates/nextjs-15-drizzle
-
-# Add to a specific type folder
-scaffold-mcp add \
-  --name react-component \
-  --url https://github.com/yourorg/react-component-scaffold \
-  --type scaffold
+# Add custom templates
+npx @agiflowai/aicode-toolkit add --name my-template --url https://github.com/user/template
 ```
 
-**Supported URL formats:**
-- Full repository: `https://github.com/user/repo`
-- Subdirectory: `https://github.com/user/repo/tree/branch/path/to/template`
-- With `.git` extension: `https://github.com/user/repo.git`
+See the [aicode-toolkit documentation](../../apps/aicode-toolkit/README.md) for complete setup instructions.
 
-### 3. Create a New Project
+### 2. Create a New Project
 
 ```bash
 # List available boilerplates
@@ -280,7 +220,7 @@ scaffold-mcp boilerplate create nextjs-15-boilerplate \
   --vars '{"projectName":"my-app","packageName":"@myorg/my-app","appName":"My App"}'
 ```
 
-### 4. Add Features to Existing Projects
+### 3. Add Features to Existing Projects
 
 ```bash
 # List available features for your project

package/dist/ScaffoldConfigLoader-CI0T6zdG.js

@@ -0,0 +1,142 @@
+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 };

package/dist/{ScaffoldConfigLoader-DzcV5a_c.cjs → ScaffoldConfigLoader-DQMCLVGD.cjs}

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

package/dist/ScaffoldConfigLoader-DhthV6xq.js

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

package/dist/{ScaffoldService-BgFWAOLQ.cjs → ScaffoldService-B-L4gwHt.cjs}

@@ -291,6 +291,12 @@ var ScaffoldService = class {
 };
 
 //#endregion
+Object.defineProperty(exports, 'ScaffoldProcessingService', {
+  enumerable: true,
+  get: function () {
+    return ScaffoldProcessingService;
+  }
+});
 Object.defineProperty(exports, 'ScaffoldService', {
   enumerable: true,
   get: function () {

package/dist/ScaffoldService-Cx4ZonaT.cjs

@@ -0,0 +1,3 @@
+const require_ScaffoldService = require('./ScaffoldService-B-L4gwHt.cjs');
+
+exports.ScaffoldService = require_ScaffoldService.ScaffoldService;

package/dist/ScaffoldService-DVsusUh5.js

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

package/dist/ScaffoldService-QgQKHMM-.js

@@ -0,0 +1,290 @@
+import path from "node:path";
+import { TemplatesManagerService, log } from "@agiflowai/aicode-utils";
+import { fileURLToPath } from "node:url";
+
+//#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;
+		}
+		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) {
+				log.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) {
+			log.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) {
+				log.warn(`Cannot stat ${itemPath}: ${error}`);
+			}
+		}
+	}
+};
+
+//#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 || TemplatesManagerService.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;
+		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)) 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 { ScaffoldProcessingService, ScaffoldService };

package/dist/TemplateService-BZRt3NI8.cjs

@@ -0,0 +1,3 @@
+const require_TemplateService = require('./TemplateService-DRubcvS9.cjs');
+
+exports.TemplateService = require_TemplateService.TemplateService;

package/dist/TemplateService-CiZJA06s.js

@@ -0,0 +1,79 @@
+import { log } from "@agiflowai/aicode-utils";
+import { Liquid } from "liquidjs";
+
+//#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
+export { TemplateService };

package/dist/TemplateService-DropYdp8.js

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