@agiflowai/scaffold-mcp 0.2.0 → 0.3.1

package/README.md

@@ -154,15 +154,32 @@ Use scaffold-mcp as a standalone CLI tool for template management and scaffoldin
 #### Template Management
 
 ```bash
-# Initialize templates folder
+# Initialize templates folder and auto-download official templates
 scaffold-mcp init
-scaffold-mcp init --path /path/to/templates
 
-# Add templates from repositories
+# 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 my-scaffold --url https://github.com/user/scaffold --type scaffold
+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
+
 #### Boilerplate Commands
 
 ```bash
@@ -205,24 +222,50 @@ scaffold-mcp scaffold add scaffold-nextjs-page \
 
 ### 1. Initialize Templates
 
+The `init` command sets up your templates folder and **automatically downloads official templates** from the AgiFlow repository:
+
 ```bash
-# Initialize templates folder in your project
+# Initialize templates folder and download official templates
 scaffold-mcp 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
 ```
 
-### 2. Add Templates
+**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...
 
-```bash
-# Add a boilerplate template from a repository
-scaffold-mcp add --name nextjs-15 --url https://github.com/yourorg/nextjs-15-template
+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:
 
-# Add a scaffold template
-scaffold-mcp add --name react-component --url https://github.com/yourorg/react-component-scaffold --type scaffold
+```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
 ```
 
+**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`
+
 ### 3. Create a New Project
 
 ```bash

package/dist/ScaffoldConfigLoader-CnVkzUxL.js

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

package/dist/{ScaffoldConfigLoader-CI0T6zdG.js → ScaffoldConfigLoader-yDhzLQpC.js}

@@ -1,42 +1,46 @@
-import path from "node:path";
-import yaml from "js-yaml";
-import { z } from "zod";
+const require_chunk = require('./chunk-nOFOJqeH.js');
+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");
+zod = require_chunk.__toESM(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 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 = z.object({
-	name: z.string(),
-	description: z.string().optional(),
-	instruction: z.string().optional(),
-	targetFolder: z.string().optional(),
+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: z.array(z.string()),
-	generator: z.string().optional(),
-	patterns: z.array(z.string()).optional()
+	includes: zod.z.array(zod.z.string()),
+	generator: zod.z.string().optional(),
+	patterns: zod.z.array(zod.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)]));
+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 = path.join(templatePath, "scaffold.yaml");
+		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 = yaml.load(content);
+			const rawConfig = js_yaml.default.load(content);
 			return ScaffoldYamlSchema.parse(rawConfig);
 		} catch (error) {
-			if (error instanceof z.ZodError) {
+			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}`);
 			}
@@ -124,7 +128,7 @@ var ScaffoldConfigLoader = class {
 		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 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);
@@ -139,4 +143,9 @@ var ScaffoldConfigLoader = class {
 };
 
 //#endregion
-export { ScaffoldConfigLoader };
+Object.defineProperty(exports, 'ScaffoldConfigLoader', {
+  enumerable: true,
+  get: function () {
+    return ScaffoldConfigLoader;
+  }
+});

package/dist/{ScaffoldService-CnJ1nj1v.js → ScaffoldService-B8-dPa7L.js}

@@ -1,12 +1,11 @@
-import { createRequire } from "node:module";
-import path from "node:path";
-import * as fs$1 from "fs-extra";
-import { fileURLToPath } from "node:url";
+const require_chunk = require('./chunk-nOFOJqeH.js');
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let fs_extra = require("fs-extra");
+fs_extra = require_chunk.__toESM(fs_extra);
+let node_url = require("node:url");
+node_url = require_chunk.__toESM(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
@@ -43,7 +42,7 @@ var ScaffoldProcessingService = class {
 	* Automatically handles .liquid template files by stripping the extension
 	*/
 	async copyAndProcess(sourcePath, targetPath, variables, createdFiles, existingFiles) {
-		await this.fileSystem.ensureDir(path.dirname(targetPath));
+		await this.fileSystem.ensureDir(node_path.default.dirname(targetPath));
 		if (await this.fileSystem.pathExists(targetPath) && existingFiles) {
 			await this.trackExistingFiles(targetPath, existingFiles);
 			return;
@@ -71,7 +70,7 @@ var ScaffoldProcessingService = class {
 		}
 		for (const item of items) {
 			if (!item) continue;
-			const itemPath = path.join(dirPath, item);
+			const itemPath = node_path.default.join(dirPath, item);
 			try {
 				const stat = await this.fileSystem.stat(itemPath);
 				if (stat.isDirectory()) await this.trackCreatedFilesRecursive(itemPath, createdFiles);
@@ -94,7 +93,7 @@ var ScaffoldProcessingService = class {
 		}
 		for (const item of items) {
 			if (!item) continue;
-			const itemPath = path.join(dirPath, item);
+			const itemPath = node_path.default.join(dirPath, item);
 			try {
 				const stat = await this.fileSystem.stat(itemPath);
 				if (stat.isDirectory()) await this.trackExistingFilesRecursive(itemPath, existingFiles);
@@ -129,32 +128,32 @@ var TemplatesManager = class TemplatesManager {
 	*/
 	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 toolkitConfigPath = node_path.default.join(workspaceRoot, TemplatesManager.TOOLKIT_CONFIG_FILE);
+		if (await fs_extra.pathExists(toolkitConfigPath)) {
 			const yaml = await import("js-yaml");
-			const content = await fs$1.readFile(toolkitConfigPath, "utf-8");
+			const content = await fs_extra.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;
+				const templatesPath$1 = node_path.default.isAbsolute(config.templatesPath) ? config.templatesPath : node_path.default.join(workspaceRoot, config.templatesPath);
+				if (await fs_extra.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;
+		const templatesPath = node_path.default.join(workspaceRoot, TemplatesManager.TEMPLATES_FOLDER);
+		if (await fs_extra.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;
+		let currentPath = node_path.default.resolve(startPath);
+		const rootPath = node_path.default.parse(currentPath).root;
 		while (true) {
-			const gitPath = path.join(currentPath, ".git");
-			if (await fs$1.pathExists(gitPath)) return currentPath;
+			const gitPath = node_path.default.join(currentPath, ".git");
+			if (await fs_extra.pathExists(gitPath)) return currentPath;
 			if (currentPath === rootPath) return process.cwd();
-			currentPath = path.dirname(currentPath);
+			currentPath = node_path.default.dirname(currentPath);
 		}
 	}
 	/**
@@ -167,32 +166,32 @@ var TemplatesManager = class TemplatesManager {
 	*/
 	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 toolkitConfigPath = node_path.default.join(workspaceRoot, TemplatesManager.TOOLKIT_CONFIG_FILE);
+		if (fs_extra.pathExistsSync(toolkitConfigPath)) {
+			const yaml = require("js-yaml");
+			const content = fs_extra.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;
+				const templatesPath$1 = node_path.default.isAbsolute(config.templatesPath) ? config.templatesPath : node_path.default.join(workspaceRoot, config.templatesPath);
+				if (fs_extra.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;
+		const templatesPath = node_path.default.join(workspaceRoot, TemplatesManager.TEMPLATES_FOLDER);
+		if (fs_extra.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;
+		let currentPath = node_path.default.resolve(startPath);
+		const rootPath = node_path.default.parse(currentPath).root;
 		while (true) {
-			const gitPath = path.join(currentPath, ".git");
-			if (fs$1.pathExistsSync(gitPath)) return currentPath;
+			const gitPath = node_path.default.join(currentPath, ".git");
+			if (fs_extra.pathExistsSync(gitPath)) return currentPath;
 			if (currentPath === rootPath) return process.cwd();
-			currentPath = path.dirname(currentPath);
+			currentPath = node_path.default.dirname(currentPath);
 		}
 	}
 	/**
@@ -202,8 +201,8 @@ var TemplatesManager = class TemplatesManager {
 	* @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();
+		if (!await fs_extra.pathExists(templatesPath)) return false;
+		return (await fs_extra.stat(templatesPath)).isDirectory();
 	}
 	/**
 	* Get the scaffold config file name
@@ -237,8 +236,8 @@ var ScaffoldService = class {
 	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 targetPath = node_path.default.isAbsolute(targetFolder) ? node_path.default.join(targetFolder, projectName) : node_path.default.join(process.cwd(), targetFolder, projectName);
+			const templatePath = node_path.default.join(this.templatesRootPath, templateFolder);
 			const validationResult = await this.scaffoldConfigLoader.validateTemplate(templatePath, "boilerplate");
 			if (!validationResult.isValid) return {
 				success: false,
@@ -287,9 +286,9 @@ var ScaffoldService = class {
 	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 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,
@@ -343,7 +342,7 @@ var ScaffoldService = class {
 		if (config.generator) {
 			console.log("Using custom generator:", config.generator);
 			try {
-				const generator = (await import(path.join(templatePath, "generators", config.generator))).default;
+				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`
@@ -358,12 +357,12 @@ var ScaffoldService = class {
 					variableReplacer: this.variableReplacer,
 					ScaffoldProcessingService: this.processingService.constructor,
 					getRootPath: () => {
-						const __dirname = path.dirname(fileURLToPath(import.meta.url));
-						return path.join(__dirname, "../../../../..");
+						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 = path.dirname(fileURLToPath(import.meta.url));
-						const rootPath = path.join(__dirname, "../../../../..");
+						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("/", "");
 					}
 				});
@@ -380,15 +379,15 @@ var ScaffoldService = class {
 			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);
+			const targetFilePath = node_path.default.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);
+			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}`;
@@ -405,4 +404,15 @@ var ScaffoldService = class {
 };
 
 //#endregion
-export { ScaffoldService, TemplatesManager };
+Object.defineProperty(exports, 'ScaffoldService', {
+  enumerable: true,
+  get: function () {
+    return ScaffoldService;
+  }
+});
+Object.defineProperty(exports, 'TemplatesManager', {
+  enumerable: true,
+  get: function () {
+    return TemplatesManager;
+  }
+});

package/dist/ScaffoldService-BXKXXg4M.js

@@ -0,0 +1,3 @@
+const require_ScaffoldService = require('./ScaffoldService-B8-dPa7L.js');
+
+exports.ScaffoldService = require_ScaffoldService.ScaffoldService;

package/dist/TemplateService-B0ns4TR_.js

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

package/dist/{TemplateService-CnxvhRVW.js → TemplateService-DvKjDjQE.js}

@@ -1,10 +1,12 @@
-import { Liquid } from "liquidjs";
+const require_chunk = require('./chunk-nOFOJqeH.js');
+let liquidjs = require("liquidjs");
+liquidjs = require_chunk.__toESM(liquidjs);
 
 //#region src/services/TemplateService.ts
 var TemplateService = class {
 	liquid;
 	constructor() {
-		this.liquid = new Liquid({
+		this.liquid = new liquidjs.Liquid({
 			strictFilters: false,
 			strictVariables: false
 		});
@@ -61,4 +63,9 @@ var TemplateService = class {
 };
 
 //#endregion
-export { TemplateService };
+Object.defineProperty(exports, 'TemplateService', {
+  enumerable: true,
+  get: function () {
+    return TemplateService;
+  }
+});

package/dist/{VariableReplacementService-Bq0GDhTo.js → VariableReplacementService-DJqXiBC2.js}

@@ -1,4 +1,6 @@
-import path from "node:path";
+const require_chunk = require('./chunk-nOFOJqeH.js');
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
 
 //#region src/services/VariableReplacementService.ts
 var VariableReplacementService = class {
@@ -35,7 +37,7 @@ var VariableReplacementService = class {
 		}
 		for (const item of items) {
 			if (!item) continue;
-			const itemPath = path.join(dirPath, item);
+			const itemPath = node_path.default.join(dirPath, item);
 			try {
 				const stat = await this.fileSystem.stat(itemPath);
 				if (stat.isDirectory()) await this.processFilesForVariableReplacement(itemPath, variables);
@@ -56,10 +58,15 @@ var VariableReplacementService = class {
 		}
 	}
 	isBinaryFile(filePath) {
-		const ext = path.extname(filePath).toLowerCase();
+		const ext = node_path.default.extname(filePath).toLowerCase();
 		return this.binaryExtensions.includes(ext);
 	}
 };
 
 //#endregion
-export { VariableReplacementService };
+Object.defineProperty(exports, 'VariableReplacementService', {
+  enumerable: true,
+  get: function () {
+    return VariableReplacementService;
+  }
+});

package/dist/VariableReplacementService-_GgLG4Im.js

@@ -0,0 +1,3 @@
+const require_VariableReplacementService = require('./VariableReplacementService-DJqXiBC2.js');
+
+exports.VariableReplacementService = require_VariableReplacementService.VariableReplacementService;

package/dist/chunk-nOFOJqeH.js

@@ -0,0 +1,30 @@
+//#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
+
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});