@agiflowai/scaffold-mcp 0.3.1 → 0.3.3

package/dist/{ScaffoldConfigLoader-CnVkzUxL.js → ScaffoldConfigLoader-BhrrsLya.js}

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

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

@@ -1,4 +1,5 @@
 const require_chunk = require('./chunk-nOFOJqeH.js');
+const require_logger = require('./logger-qztMS7ET.js');
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
 let fs_extra = require("fs-extra");
@@ -65,7 +66,7 @@ var ScaffoldProcessingService = class {
 		try {
 			items = await this.fileSystem.readdir(dirPath);
 		} catch (error) {
-			console.warn(`Cannot read directory ${dirPath}: ${error}`);
+			require_logger.log.warn(`Cannot read directory ${dirPath}: ${error}`);
 			return;
 		}
 		for (const item of items) {
@@ -76,7 +77,7 @@ var ScaffoldProcessingService = class {
 				if (stat.isDirectory()) await this.trackCreatedFilesRecursive(itemPath, createdFiles);
 				else if (stat.isFile()) createdFiles.push(itemPath);
 			} catch (error) {
-				console.warn(`Cannot stat ${itemPath}: ${error}`);
+				require_logger.log.warn(`Cannot stat ${itemPath}: ${error}`);
 			}
 		}
 	}
@@ -88,7 +89,7 @@ var ScaffoldProcessingService = class {
 		try {
 			items = await this.fileSystem.readdir(dirPath);
 		} catch (error) {
-			console.warn(`Cannot read directory ${dirPath}: ${error}`);
+			require_logger.log.warn(`Cannot read directory ${dirPath}: ${error}`);
 			return;
 		}
 		for (const item of items) {
@@ -99,7 +100,7 @@ var ScaffoldProcessingService = class {
 				if (stat.isDirectory()) await this.trackExistingFilesRecursive(itemPath, existingFiles);
 				else if (stat.isFile()) existingFiles.push(itemPath);
 			} catch (error) {
-				console.warn(`Cannot stat ${itemPath}: ${error}`);
+				require_logger.log.warn(`Cannot stat ${itemPath}: ${error}`);
 			}
 		}
 	}
@@ -337,10 +338,10 @@ var ScaffoldService = class {
 	*/
 	async processScaffold(params) {
 		const { config, targetPath, templatePath, allVariables, scaffoldType } = params;
-		console.log("Config generator:", config.generator);
-		console.log("Config:", JSON.stringify(config, null, 2));
+		require_logger.log.debug("Config generator:", config.generator);
+		require_logger.log.debug("Config:", JSON.stringify(config, null, 2));
 		if (config.generator) {
-			console.log("Using custom generator:", config.generator);
+			require_logger.log.info("Using custom generator:", config.generator);
 			try {
 				const generator = (await import(node_path.default.join(templatePath, "generators", config.generator))).default;
 				if (typeof generator !== "function") return {

package/dist/ScaffoldService-Dp9yhqVI.js

@@ -0,0 +1,4 @@
+require('./logger-qztMS7ET.js');
+const require_ScaffoldService = require('./ScaffoldService-B5ZpIjsn.js');
+
+exports.ScaffoldService = require_ScaffoldService.ScaffoldService;

package/dist/TemplateService-lGQxhofk.js

@@ -0,0 +1,4 @@
+require('./logger-qztMS7ET.js');
+const require_TemplateService = require('./TemplateService-wsvfwvRN.js');
+
+exports.TemplateService = require_TemplateService.TemplateService;

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

@@ -1,4 +1,5 @@
 const require_chunk = require('./chunk-nOFOJqeH.js');
+const require_logger = require('./logger-qztMS7ET.js');
 let liquidjs = require("liquidjs");
 liquidjs = require_chunk.__toESM(liquidjs);
 
@@ -11,6 +12,7 @@ var TemplateService = class {
 			strictVariables: false
 		});
 		this.setupCustomFilters();
+		require_logger.log.info("TemplateService initialized");
 	}
 	toPascalCase(str) {
 		const camelCase = str.replace(/[-_\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : "");
@@ -48,12 +50,25 @@ var TemplateService = class {
 			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 {
-			return this.liquid.parseAndRenderSync(template, variables);
+			require_logger.log.debug("Rendering template", {
+				variables,
+				templatePreview: template.substring(0, 100)
+			});
+			const result = this.liquid.parseAndRenderSync(template, variables);
+			require_logger.log.debug("Rendered template", { resultPreview: result.substring(0, 100) });
+			return result;
 		} catch (error) {
-			console.warn(`LiquidJS rendering error: ${error}`);
+			require_logger.log.error("LiquidJS rendering error", {
+				error: error instanceof Error ? error.message : String(error),
+				templatePreview: template.substring(0, 200),
+				variables
+			});
 			return template;
 		}
 	}

package/dist/{VariableReplacementService-_GgLG4Im.js → VariableReplacementService-C0BdOUm6.js}

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

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

@@ -1,4 +1,5 @@
 const require_chunk = require('./chunk-nOFOJqeH.js');
+const require_logger = require('./logger-qztMS7ET.js');
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
 
@@ -32,7 +33,7 @@ var VariableReplacementService = class {
 		try {
 			items = await this.fileSystem.readdir(dirPath);
 		} catch (error) {
-			console.warn(`Skipping directory ${dirPath}: ${error}`);
+			require_logger.log.warn(`Skipping directory ${dirPath}: ${error}`);
 			return;
 		}
 		for (const item of items) {
@@ -43,7 +44,7 @@ var VariableReplacementService = class {
 				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}`);
+				require_logger.log.warn(`Skipping item ${itemPath}: ${error}`);
 			}
 		}
 	}
@@ -54,7 +55,7 @@ var VariableReplacementService = class {
 			const renderedContent = this.templateService.renderString(content, variables);
 			await this.fileSystem.writeFile(filePath, renderedContent, "utf8");
 		} catch (error) {
-			console.warn(`Skipping file ${filePath}: ${error}`);
+			require_logger.log.warn(`Skipping file ${filePath}: ${error}`);
 		}
 	}
 	isBinaryFile(filePath) {

package/dist/index.js

@@ -1,21 +1,22 @@
 #!/usr/bin/env node
 const require_chunk = require('./chunk-nOFOJqeH.js');
-const require_ScaffoldConfigLoader = require('./ScaffoldConfigLoader-yDhzLQpC.js');
-const require_ScaffoldService = require('./ScaffoldService-B8-dPa7L.js');
-const require_TemplateService = require('./TemplateService-DvKjDjQE.js');
-const require_VariableReplacementService = require('./VariableReplacementService-DJqXiBC2.js');
+const require_logger = require('./logger-qztMS7ET.js');
+const require_ScaffoldConfigLoader = require('./ScaffoldConfigLoader-CvIJEFcI.js');
+const require_ScaffoldService = require('./ScaffoldService-B5ZpIjsn.js');
+const require_TemplateService = require('./TemplateService-wsvfwvRN.js');
+const require_VariableReplacementService = require('./VariableReplacementService-UjRQY5JS.js');
 let commander = require("commander");
 commander = require_chunk.__toESM(commander);
 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 chalk = require("chalk");
-chalk = require_chunk.__toESM(chalk);
 let node_child_process = require("node:child_process");
 node_child_process = require_chunk.__toESM(node_child_process);
 let node_util = require("node:util");
 node_util = require_chunk.__toESM(node_util);
+let chalk = require("chalk");
+chalk = require_chunk.__toESM(chalk);
 let __composio_json_schema_to_zod = require("@composio/json-schema-to-zod");
 __composio_json_schema_to_zod = require_chunk.__toESM(__composio_json_schema_to_zod);
 let js_yaml = require("js-yaml");
@@ -37,11 +38,95 @@ __modelcontextprotocol_sdk_server_sse_js = require_chunk.__toESM(__modelcontextp
 let __modelcontextprotocol_sdk_server_stdio_js = require("@modelcontextprotocol/sdk/server/stdio.js");
 __modelcontextprotocol_sdk_server_stdio_js = require_chunk.__toESM(__modelcontextprotocol_sdk_server_stdio_js);
 
-//#region src/utils/console.ts
+//#region src/utils/git.ts
+const execAsync = (0, node_util.promisify)(node_child_process.exec);
+/**
+* Parse GitHub URL to detect if it's a subdirectory
+* Supports formats:
+* - https://github.com/user/repo
+* - https://github.com/user/repo/tree/branch/path/to/dir
+* - https://github.com/user/repo/tree/main/path/to/dir
+*/
+function parseGitHubUrl(url) {
+	const treeMatch = url.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)\/(.+)$/);
+	const blobMatch = url.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/blob\/([^/]+)\/(.+)$/);
+	const rootMatch = url.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?$/);
+	if (treeMatch || blobMatch) {
+		const match = treeMatch || blobMatch;
+		return {
+			owner: match[1],
+			repo: match[2],
+			repoUrl: `https://github.com/${match[1]}/${match[2]}.git`,
+			branch: match[3],
+			subdirectory: match[4],
+			isSubdirectory: true
+		};
+	}
+	if (rootMatch) return {
+		owner: rootMatch[1],
+		repo: rootMatch[2],
+		repoUrl: `https://github.com/${rootMatch[1]}/${rootMatch[2]}.git`,
+		isSubdirectory: false
+	};
+	return {
+		repoUrl: url,
+		isSubdirectory: false
+	};
+}
+/**
+* Clone a subdirectory from a git repository using sparse checkout
+*/
+async function cloneSubdirectory(repoUrl, branch, subdirectory, targetFolder) {
+	const tempFolder = `${targetFolder}.tmp`;
+	try {
+		await execAsync(`git init "${tempFolder}"`);
+		await execAsync(`git -C "${tempFolder}" remote add origin ${repoUrl}`);
+		await execAsync(`git -C "${tempFolder}" config core.sparseCheckout true`);
+		const sparseCheckoutFile = node_path.default.join(tempFolder, ".git", "info", "sparse-checkout");
+		await fs_extra.writeFile(sparseCheckoutFile, `${subdirectory}\n`);
+		await execAsync(`git -C "${tempFolder}" pull --depth=1 origin ${branch}`);
+		const sourceDir = node_path.default.join(tempFolder, subdirectory);
+		if (!await fs_extra.pathExists(sourceDir)) throw new Error(`Subdirectory '${subdirectory}' not found in repository at branch '${branch}'`);
+		await fs_extra.move(sourceDir, targetFolder);
+		await fs_extra.remove(tempFolder);
+	} catch (error) {
+		if (await fs_extra.pathExists(tempFolder)) await fs_extra.remove(tempFolder);
+		throw error;
+	}
+}
+/**
+* Clone entire repository
+*/
+async function cloneRepository(repoUrl, targetFolder) {
+	await execAsync(`git clone ${repoUrl} "${targetFolder}"`);
+	const gitFolder = node_path.default.join(targetFolder, ".git");
+	if (await fs_extra.pathExists(gitFolder)) await fs_extra.remove(gitFolder);
+}
+/**
+* Fetch directory listing from GitHub API
+*/
+async function fetchGitHubDirectoryContents(owner, repo, path$6, branch = "main") {
+	const url = `https://api.github.com/repos/${owner}/${repo}/contents/${path$6}?ref=${branch}`;
+	const response = await fetch(url, { headers: {
+		Accept: "application/vnd.github.v3+json",
+		"User-Agent": "scaffold-mcp"
+	} });
+	if (!response.ok) throw new Error(`Failed to fetch directory contents: ${response.statusText}`);
+	const data = await response.json();
+	if (!Array.isArray(data)) throw new Error("Expected directory but got file");
+	return data.map((item) => ({
+		name: item.name,
+		type: item.type,
+		path: item.path
+	}));
+}
+
+//#endregion
+//#region src/utils/print.ts
 /**
 * Themed console utilities for consistent CLI output
 */
-const logger = {
+const print = {
 	info: (message) => {
 		console.log(chalk.default.cyan(message));
 	},
@@ -103,22 +188,22 @@ const icons = {
 */
 const messages = {
 	info: (message) => {
-		logger.info(`${icons.info} ${message}`);
+		print.info(`${icons.info} ${message}`);
 	},
 	success: (message) => {
-		logger.success(`${icons.check} ${message}`);
+		print.success(`${icons.check} ${message}`);
 	},
 	error: (message, error) => {
-		logger.error(`${icons.cross} ${message}`, error);
+		print.error(`${icons.cross} ${message}`, error);
 	},
 	warning: (message) => {
-		logger.warning(`${icons.warning} ${message}`);
+		print.warning(`${icons.warning} ${message}`);
 	},
 	hint: (message) => {
-		logger.warning(`${icons.bulb} ${message}`);
+		print.warning(`${icons.bulb} ${message}`);
 	},
 	loading: (message) => {
-		logger.info(`${icons.rocket} ${message}`);
+		print.info(`${icons.rocket} ${message}`);
 	}
 };
 /**
@@ -126,113 +211,29 @@ const messages = {
 */
 const sections = {
 	header: (title) => {
-		logger.newline();
-		logger.header(`${title}`);
-		logger.newline();
+		print.newline();
+		print.header(`${title}`);
+		print.newline();
 	},
 	list: (title, items) => {
-		logger.header(`\n${title}\n`);
-		items.forEach((item) => logger.item(item));
+		print.header(`\n${title}\n`);
+		items.forEach((item) => print.item(item));
 	},
 	nextSteps: (steps) => {
-		logger.header(`\n${icons.clipboard} Next steps:`);
-		steps.forEach((step) => logger.indent(step));
+		print.header(`\n${icons.clipboard} Next steps:`);
+		steps.forEach((step) => print.indent(step));
 	},
 	createdFiles: (files, maxShow = 10) => {
-		logger.header(`\n${icons.folder} Created files:`);
-		files.slice(0, maxShow).forEach((file) => logger.item(file));
-		if (files.length > maxShow) logger.indent(`... and ${files.length - maxShow} more files`);
+		print.header(`\n${icons.folder} Created files:`);
+		files.slice(0, maxShow).forEach((file) => print.item(file));
+		if (files.length > maxShow) print.indent(`... and ${files.length - maxShow} more files`);
 	},
 	warnings: (warnings) => {
-		logger.warning(`\n${icons.warning} Warnings:`);
-		warnings.forEach((warning) => logger.item(warning));
+		print.warning(`\n${icons.warning} Warnings:`);
+		warnings.forEach((warning) => print.item(warning));
 	}
 };
 
-//#endregion
-//#region src/utils/git.ts
-const execAsync = (0, node_util.promisify)(node_child_process.exec);
-/**
-* Parse GitHub URL to detect if it's a subdirectory
-* Supports formats:
-* - https://github.com/user/repo
-* - https://github.com/user/repo/tree/branch/path/to/dir
-* - https://github.com/user/repo/tree/main/path/to/dir
-*/
-function parseGitHubUrl(url) {
-	const treeMatch = url.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)\/(.+)$/);
-	const blobMatch = url.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/blob\/([^/]+)\/(.+)$/);
-	const rootMatch = url.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?$/);
-	if (treeMatch || blobMatch) {
-		const match = treeMatch || blobMatch;
-		return {
-			owner: match[1],
-			repo: match[2],
-			repoUrl: `https://github.com/${match[1]}/${match[2]}.git`,
-			branch: match[3],
-			subdirectory: match[4],
-			isSubdirectory: true
-		};
-	}
-	if (rootMatch) return {
-		owner: rootMatch[1],
-		repo: rootMatch[2],
-		repoUrl: `https://github.com/${rootMatch[1]}/${rootMatch[2]}.git`,
-		isSubdirectory: false
-	};
-	return {
-		repoUrl: url,
-		isSubdirectory: false
-	};
-}
-/**
-* Clone a subdirectory from a git repository using sparse checkout
-*/
-async function cloneSubdirectory(repoUrl, branch, subdirectory, targetFolder) {
-	const tempFolder = `${targetFolder}.tmp`;
-	try {
-		await execAsync(`git init "${tempFolder}"`);
-		await execAsync(`git -C "${tempFolder}" remote add origin ${repoUrl}`);
-		await execAsync(`git -C "${tempFolder}" config core.sparseCheckout true`);
-		const sparseCheckoutFile = node_path.default.join(tempFolder, ".git", "info", "sparse-checkout");
-		await fs_extra.writeFile(sparseCheckoutFile, `${subdirectory}\n`);
-		await execAsync(`git -C "${tempFolder}" pull --depth=1 origin ${branch}`);
-		const sourceDir = node_path.default.join(tempFolder, subdirectory);
-		if (!await fs_extra.pathExists(sourceDir)) throw new Error(`Subdirectory '${subdirectory}' not found in repository at branch '${branch}'`);
-		await fs_extra.move(sourceDir, targetFolder);
-		await fs_extra.remove(tempFolder);
-	} catch (error) {
-		if (await fs_extra.pathExists(tempFolder)) await fs_extra.remove(tempFolder);
-		throw error;
-	}
-}
-/**
-* Clone entire repository
-*/
-async function cloneRepository(repoUrl, targetFolder) {
-	await execAsync(`git clone ${repoUrl} "${targetFolder}"`);
-	const gitFolder = node_path.default.join(targetFolder, ".git");
-	if (await fs_extra.pathExists(gitFolder)) await fs_extra.remove(gitFolder);
-}
-/**
-* Fetch directory listing from GitHub API
-*/
-async function fetchGitHubDirectoryContents(owner, repo, path$6, branch = "main") {
-	const url = `https://api.github.com/repos/${owner}/${repo}/contents/${path$6}?ref=${branch}`;
-	const response = await fetch(url, { headers: {
-		Accept: "application/vnd.github.v3+json",
-		"User-Agent": "scaffold-mcp"
-	} });
-	if (!response.ok) throw new Error(`Failed to fetch directory contents: ${response.statusText}`);
-	const data = await response.json();
-	if (!Array.isArray(data)) throw new Error("Expected directory but got file");
-	return data.map((item) => ({
-		name: item.name,
-		type: item.type,
-		path: item.path
-	}));
-}
-
 //#endregion
 //#region src/cli/add.ts
 /**
@@ -253,28 +254,28 @@ const addCommand = new commander.Command("add").description("Add a template to t
 			messages.error(`Template '${templateName}' already exists at ${targetFolder}`);
 			process.exit(1);
 		}
-		logger.info(`${icons.download} Downloading template '${templateName}' from ${templateUrl}...`);
+		print.info(`${icons.download} Downloading template '${templateName}' from ${templateUrl}...`);
 		await fs_extra.ensureDir(node_path.default.dirname(targetFolder));
 		const parsedUrl = parseGitHubUrl(templateUrl);
 		try {
 			if (parsedUrl.isSubdirectory && parsedUrl.branch && parsedUrl.subdirectory) {
-				logger.info(`${icons.folder} Detected subdirectory: ${parsedUrl.subdirectory} (branch: ${parsedUrl.branch})`);
+				print.info(`${icons.folder} Detected subdirectory: ${parsedUrl.subdirectory} (branch: ${parsedUrl.branch})`);
 				await cloneSubdirectory(parsedUrl.repoUrl, parsedUrl.branch, parsedUrl.subdirectory, targetFolder);
 			} else await cloneRepository(parsedUrl.repoUrl, targetFolder);
 			messages.success(`Template '${templateName}' added successfully!`);
-			logger.header(`\n${icons.folder} Template location:`);
-			logger.indent(targetFolder);
+			print.header(`\n${icons.folder} Template location:`);
+			print.indent(targetFolder);
 			const configFiles = [node_path.default.join(targetFolder, "boilerplate.yaml"), node_path.default.join(targetFolder, "scaffold.yaml")];
 			let hasConfig = false;
 			for (const configFile of configFiles) if (await fs_extra.pathExists(configFile)) {
-				logger.header(`\n${icons.config} Configuration file found:`);
-				logger.indent(node_path.default.basename(configFile));
+				print.header(`\n${icons.config} Configuration file found:`);
+				print.indent(node_path.default.basename(configFile));
 				hasConfig = true;
 				break;
 			}
 			if (!hasConfig) {
 				messages.warning("Warning: No configuration file found (boilerplate.yaml or scaffold.yaml)");
-				logger.indent("You may need to create one manually.");
+				print.indent("You may need to create one manually.");
 			}
 			sections.nextSteps([`Review the template in ${targetFolder}`, `Test it with: scaffold-mcp ${templateType} list`]);
 		} catch (error) {
@@ -329,9 +330,7 @@ var BoilerplateService = class {
 		this.templatesPath = templatesPath;
 		this.templateService = new require_TemplateService.TemplateService();
 		const fileSystemService = new FileSystemService();
-		const scaffoldConfigLoader = new require_ScaffoldConfigLoader.ScaffoldConfigLoader(fileSystemService, this.templateService);
-		const variableReplacementService = new require_VariableReplacementService.VariableReplacementService(fileSystemService, this.templateService);
-		this.scaffoldService = new require_ScaffoldService.ScaffoldService(fileSystemService, scaffoldConfigLoader, variableReplacementService, templatesPath);
+		this.scaffoldService = new require_ScaffoldService.ScaffoldService(fileSystemService, new require_ScaffoldConfigLoader.ScaffoldConfigLoader(fileSystemService, this.templateService), new require_VariableReplacementService.VariableReplacementService(fileSystemService, this.templateService), templatesPath);
 	}
 	/**
 	* Scans all scaffold.yaml files and returns available boilerplates
@@ -346,7 +345,7 @@ var BoilerplateService = class {
 				const scaffoldConfig = js_yaml.load(scaffoldContent);
 				if (scaffoldConfig.boilerplate) for (const boilerplate of scaffoldConfig.boilerplate) {
 					if (!boilerplate.targetFolder) {
-						console.warn(`Skipping boilerplate '${boilerplate.name}' in ${templatePath}: targetFolder is required in scaffold.yaml`);
+						require_logger.log.warn(`Skipping boilerplate '${boilerplate.name}' in ${templatePath}: targetFolder is required in scaffold.yaml`);
 						continue;
 					}
 					boilerplates.push({
@@ -360,7 +359,7 @@ var BoilerplateService = class {
 					});
 				}
 			} catch (error) {
-				console.warn(`Failed to load scaffold.yaml for ${templatePath}:`, error);
+				require_logger.log.warn(`Failed to load scaffold.yaml for ${templatePath}:`, error);
 			}
 		}
 		return { boilerplates };
@@ -379,10 +378,7 @@ var BoilerplateService = class {
 			if (hasPackageJson && hasScaffoldYaml) templateDirs.push(baseDir);
 			for (const item of items) {
 				const itemPath = node_path.join(dir, item);
-				if (fs_extra.statSync(itemPath).isDirectory() && !item.startsWith(".") && item !== "node_modules") {
-					const newBaseDir = baseDir ? node_path.join(baseDir, item) : item;
-					findTemplates(itemPath, newBaseDir);
-				}
+				if (fs_extra.statSync(itemPath).isDirectory() && !item.startsWith(".") && item !== "node_modules") findTemplates(itemPath, baseDir ? node_path.join(baseDir, item) : item);
 			}
 		};
 		findTemplates(this.templatesPath);
@@ -503,7 +499,7 @@ var BoilerplateService = class {
 			projectJson.sourceTemplate = sourceTemplate;
 			fs_extra.writeFileSync(projectJsonPath, `${JSON.stringify(projectJson, null, 2)}\n`, "utf8");
 		} catch (error) {
-			console.warn(`Failed to update project.json with sourceTemplate: ${error}`);
+			require_logger.log.warn(`Failed to update project.json with sourceTemplate: ${error}`);
 		}
 	}
 };
@@ -516,20 +512,19 @@ var BoilerplateService = class {
 const boilerplateCommand = new commander.Command("boilerplate").description("Manage boilerplate templates");
 boilerplateCommand.command("list").description("List all available boilerplate templates").action(async () => {
 	try {
-		const templatesDir = await require_ScaffoldService.TemplatesManager.findTemplatesPath();
-		const { boilerplates } = await new BoilerplateService(templatesDir).listBoilerplates();
+		const { boilerplates } = await new BoilerplateService(await require_ScaffoldService.TemplatesManager.findTemplatesPath()).listBoilerplates();
 		if (boilerplates.length === 0) {
 			messages.warning("No boilerplate templates found.");
 			return;
 		}
-		logger.header(`\n${icons.package} Available Boilerplate Templates:\n`);
+		print.header(`\n${icons.package} Available Boilerplate Templates:\n`);
 		for (const bp of boilerplates) {
-			logger.highlight(`  ${bp.name}`);
-			logger.debug(`    ${bp.description}`);
-			logger.debug(`    Target: ${bp.target_folder}`);
+			print.highlight(`  ${bp.name}`);
+			print.debug(`    ${bp.description}`);
+			print.debug(`    Target: ${bp.target_folder}`);
 			const required = typeof bp.variables_schema === "object" && bp.variables_schema !== null && "required" in bp.variables_schema ? bp.variables_schema.required : [];
-			if (required && required.length > 0) logger.debug(`    Required: ${required.join(", ")}`);
-			logger.newline();
+			if (required && required.length > 0) print.debug(`    Required: ${required.join(", ")}`);
+			print.newline();
 		}
 	} catch (error) {
 		messages.error("Error listing boilerplates:", error);
@@ -538,8 +533,7 @@ boilerplateCommand.command("list").description("List all available boilerplate t
 });
 boilerplateCommand.command("create <boilerplateName>").description("Create a new project from a boilerplate template").option("-v, --vars <json>", "JSON string containing variables for the boilerplate").option("--verbose", "Enable verbose logging").action(async (boilerplateName, options) => {
 	try {
-		const templatesDir = await require_ScaffoldService.TemplatesManager.findTemplatesPath();
-		const boilerplateService = new BoilerplateService(templatesDir);
+		const boilerplateService = new BoilerplateService(await require_ScaffoldService.TemplatesManager.findTemplatesPath());
 		let variables = {};
 		if (options.vars) try {
 			variables = JSON.parse(options.vars);
@@ -552,7 +546,7 @@ boilerplateCommand.command("create <boilerplateName>").description("Create a new
 		if (!boilerplate) {
 			const { boilerplates } = await boilerplateService.listBoilerplates();
 			messages.error(`Boilerplate '${boilerplateName}' not found.`);
-			logger.warning(`Available boilerplates: ${boilerplates.map((b) => b.name).join(", ")}`);
+			print.warning(`Available boilerplates: ${boilerplates.map((b) => b.name).join(", ")}`);
 			process.exit(1);
 		}
 		const required = typeof boilerplate.variables_schema === "object" && boilerplate.variables_schema !== null && "required" in boilerplate.variables_schema ? boilerplate.variables_schema.required : [];
@@ -564,12 +558,12 @@ boilerplateCommand.command("create <boilerplateName>").description("Create a new
 			for (const key of required) if (key === "appName" || key === "packageName") exampleVars[key] = "my-app";
 			else if (key === "description") exampleVars[key] = "My application description";
 			else exampleVars[key] = `<${key}>`;
-			logger.debug(`Example: scaffold-mcp boilerplate create ${boilerplateName} --vars '${JSON.stringify(exampleVars)}'`);
+			print.debug(`Example: scaffold-mcp boilerplate create ${boilerplateName} --vars '${JSON.stringify(exampleVars)}'`);
 			process.exit(1);
 		}
 		if (options.verbose) {
-			logger.info(`${icons.wrench} Boilerplate: ${boilerplateName}`);
-			logger.info(`${icons.chart} Variables: ${JSON.stringify(variables, null, 2)}`);
+			print.info(`${icons.wrench} Boilerplate: ${boilerplateName}`);
+			print.info(`${icons.chart} Variables: ${JSON.stringify(variables, null, 2)}`);
 		}
 		messages.loading(`Creating project from boilerplate '${boilerplateName}'...`);
 		const result = await boilerplateService.useBoilerplate({
@@ -578,7 +572,7 @@ boilerplateCommand.command("create <boilerplateName>").description("Create a new
 		});
 		if (result.success) {
 			messages.success("Project created successfully!");
-			logger.info(result.message);
+			print.info(result.message);
 			if (result.createdFiles && result.createdFiles.length > 0) sections.createdFiles(result.createdFiles);
 			const projectName = variables.appName || variables.packageName;
 			if (projectName) sections.nextSteps([
@@ -598,17 +592,16 @@ boilerplateCommand.command("create <boilerplateName>").description("Create a new
 });
 boilerplateCommand.command("info <boilerplateName>").description("Show detailed information about a boilerplate template").action(async (boilerplateName) => {
 	try {
-		const templatesDir = await require_ScaffoldService.TemplatesManager.findTemplatesPath();
-		const bp = await new BoilerplateService(templatesDir).getBoilerplate(boilerplateName);
+		const bp = await new BoilerplateService(await require_ScaffoldService.TemplatesManager.findTemplatesPath()).getBoilerplate(boilerplateName);
 		if (!bp) {
 			messages.error(`Boilerplate '${boilerplateName}' not found.`);
 			process.exit(1);
 		}
-		logger.header(`\n${icons.package} Boilerplate: ${bp.name}\n`);
-		logger.debug(`Description: ${bp.description}`);
-		logger.debug(`Template Path: ${bp.template_path}`);
-		logger.debug(`Target Folder: ${bp.target_folder}`);
-		logger.header(`\n${icons.config} Variables Schema:`);
+		print.header(`\n${icons.package} Boilerplate: ${bp.name}\n`);
+		print.debug(`Description: ${bp.description}`);
+		print.debug(`Template Path: ${bp.template_path}`);
+		print.debug(`Target Folder: ${bp.target_folder}`);
+		print.header(`\n${icons.config} Variables Schema:`);
 		console.log(JSON.stringify(bp.variables_schema, null, 2));
 		if (bp.includes && bp.includes.length > 0) sections.list(`${icons.folder} Included Files:`, bp.includes);
 	} catch (error) {
@@ -643,25 +636,24 @@ const DEFAULT_TEMPLATE_REPO = {
 */
 async function downloadTemplates(templatesPath) {
 	try {
-		logger.info(`${icons.download} Fetching templates from ${DEFAULT_TEMPLATE_REPO.owner}/${DEFAULT_TEMPLATE_REPO.repo}...`);
+		print.info(`${icons.download} Fetching templates from ${DEFAULT_TEMPLATE_REPO.owner}/${DEFAULT_TEMPLATE_REPO.repo}...`);
 		const templateDirs = (await fetchGitHubDirectoryContents(DEFAULT_TEMPLATE_REPO.owner, DEFAULT_TEMPLATE_REPO.repo, DEFAULT_TEMPLATE_REPO.path, DEFAULT_TEMPLATE_REPO.branch)).filter((item) => item.type === "dir");
 		if (templateDirs.length === 0) {
 			messages.warning("No templates found in repository");
 			return;
 		}
-		logger.info(`${icons.folder} Found ${templateDirs.length} template(s)`);
+		print.info(`${icons.folder} Found ${templateDirs.length} template(s)`);
 		for (const template of templateDirs) {
 			const targetFolder = node_path.default.join(templatesPath, template.name);
 			if (await fs_extra.pathExists(targetFolder)) {
-				logger.info(`${icons.skip} Skipping ${template.name} (already exists)`);
+				print.info(`${icons.skip} Skipping ${template.name} (already exists)`);
 				continue;
 			}
-			logger.info(`${icons.download} Downloading ${template.name}...`);
-			const repoUrl = `https://github.com/${DEFAULT_TEMPLATE_REPO.owner}/${DEFAULT_TEMPLATE_REPO.repo}.git`;
-			await cloneSubdirectory(repoUrl, DEFAULT_TEMPLATE_REPO.branch, template.path, targetFolder);
-			logger.success(`${icons.check} Downloaded ${template.name}`);
+			print.info(`${icons.download} Downloading ${template.name}...`);
+			await cloneSubdirectory(`https://github.com/${DEFAULT_TEMPLATE_REPO.owner}/${DEFAULT_TEMPLATE_REPO.repo}.git`, DEFAULT_TEMPLATE_REPO.branch, template.path, targetFolder);
+			print.success(`${icons.check} Downloaded ${template.name}`);
 		}
-		logger.success(`\n${icons.check} All templates downloaded successfully!`);
+		print.success(`\n${icons.check} All templates downloaded successfully!`);
 	} catch (error) {
 		throw new Error(`Failed to download templates: ${error.message}`);
 	}
@@ -673,7 +665,7 @@ const initCommand = new commander.Command("init").description("Initialize templa
 	try {
 		const workspaceRoot = await findWorkspaceRoot();
 		const templatesPath = options.path ? node_path.default.join(workspaceRoot, options.path) : node_path.default.join(workspaceRoot, "templates");
-		logger.info(`${icons.rocket} Initializing templates folder at: ${templatesPath}`);
+		print.info(`${icons.rocket} Initializing templates folder at: ${templatesPath}`);
 		await fs_extra.ensureDir(templatesPath);
 		await fs_extra.writeFile(node_path.default.join(templatesPath, "README.md"), `# Templates
 
@@ -709,11 +701,11 @@ Template files use Liquid syntax for variable placeholders: \`{{ variableName }}
 
 See existing templates for examples and documentation for more details.
 `);
-		logger.success(`${icons.check} Templates folder created!`);
+		print.success(`${icons.check} Templates folder created!`);
 		if (options.download !== false) await downloadTemplates(templatesPath);
-		else logger.info(`${icons.skip} Skipping template download (use --download to enable)`);
-		logger.header(`\n${icons.folder} Templates location:`);
-		logger.indent(templatesPath);
+		else print.info(`${icons.skip} Skipping template download (use --download to enable)`);
+		print.header(`\n${icons.folder} Templates location:`);
+		print.indent(templatesPath);
 		const nextSteps = [];
 		if (options.download === false) {
 			nextSteps.push(`Download templates: scaffold-mcp init --download`);
@@ -1025,12 +1017,27 @@ Use the \`use-boilerplate\` tool with:
 - The tool will create the project in the appropriate directory automatically
 - After creation, inform the user where the project was created
 
+## Step 4: Review and Add Features (If Needed)
+After the boilerplate is created, **consider if additional features are needed**:
+1. **READ** the generated project structure to understand what was created
+2. **REVIEW** the user's request to see if they asked for specific features (e.g., "with tool for X", "with prompt for Y")
+3. **If features are needed**:
+   - Use \`list-scaffolding-methods\` with the new project path
+   - Use \`use-scaffold-method\` to add tools, services, prompts, etc.
+   - **IMPLEMENT** the actual logic in the scaffolded feature files
+   - **REGISTER** the features in \`src/server/index.ts\`
+4. **Install dependencies**: Remind user to run \`pnpm install\`
+5. **Report** the complete setup including any features added
+
 ## Example Workflow:
 1. Call \`list-boilerplates\` → See available templates
 2. Ask user which template to use (or infer from request)
 3. Collect required variables based on schema
 4. Call \`use-boilerplate\` with boilerplateName and variables
-5. Report success and next steps to the user`
+5. **Review if user requested specific features (tools, prompts, etc.)**
+6. **If features needed**: Add them using \`list-scaffolding-methods\` and \`use-scaffold-method\`
+7. **READ and IMPLEMENT** the scaffolded feature files with actual logic
+8. Report success and next steps to the user`
 			}
 		}];
 	}
@@ -1140,13 +1147,29 @@ Use the \`use-scaffold-method\` tool with:
 - The tool will create files in the appropriate locations automatically
 - After creation, inform the user what files were created
 
+## Step 5: Review and Implement Generated Files
+After scaffolding completes, **you MUST**:
+1. **READ** all generated files to understand their structure
+2. **IMPLEMENT** the actual business logic:
+   - Replace TODO comments with real code
+   - Replace template placeholders with actual implementation
+   - Add the specific functionality described in the user's request
+3. **REGISTER** the feature in appropriate files:
+   - Import and register tools in \`src/server/index.ts\`
+   - Export new modules from \`index.ts\` files
+   - Update any necessary configuration files
+4. **TEST** to ensure the implementation works correctly
+5. **DO NOT SKIP** this step - scaffolded files are templates that need actual code
+
 ## Example Workflow:
 1. Identify project path (provided or ask user)
 2. Call \`list-scaffolding-methods\` → See available features for this project
 3. Ask user which feature to add (or infer from request)
 4. Collect required variables based on schema
 5. Call \`use-scaffold-method\` with projectPath, scaffold_feature_name, and variables
-6. Report success and list created files`
+6. **READ the generated files and IMPLEMENT the actual logic**
+7. **REGISTER the feature in server/index.ts and other config files**
+8. Report success and list created files with implementation details`
 			}
 		}];
 	}
@@ -1233,24 +1256,23 @@ var BoilerplateGeneratorService = class {
 			message: `Boilerplate '${boilerplateName}' already exists in ${scaffoldYamlPath}`
 		};
 		const requiredVars = variables.filter((v) => v.required).map((v) => v.name);
-		const variablesSchema = {
-			type: "object",
-			properties: variables.reduce((acc, v) => {
-				acc[v.name] = {
-					type: v.type,
-					description: v.description
-				};
-				if (v.default !== void 0) acc[v.name].default = v.default;
-				return acc;
-			}, {}),
-			required: requiredVars,
-			additionalProperties: false
-		};
 		const boilerplateDefinition = {
 			name: boilerplateName,
 			targetFolder,
 			description,
-			variables_schema: variablesSchema,
+			variables_schema: {
+				type: "object",
+				properties: variables.reduce((acc, v) => {
+					acc[v.name] = {
+						type: v.type,
+						description: v.description
+					};
+					if (v.default !== void 0) acc[v.name].default = v.default;
+					return acc;
+				}, {}),
+				required: requiredVars,
+				additionalProperties: false
+			},
 			includes: includes.length > 0 ? includes : []
 		};
 		if (instruction) boilerplateDefinition.instruction = instruction;
@@ -1340,6 +1362,11 @@ This tool:
 - Validates that the template directory exists
 - Works for both boilerplate includes and feature scaffold includes
 
+IMPORTANT - Always add header comments:
+- For code files (*.ts, *.tsx, *.js, *.jsx), ALWAYS include a header parameter with design patterns, coding standards, and things to avoid
+- Headers help AI understand and follow established patterns when working with generated code
+- Use the header parameter to document the architectural decisions and best practices
+
 Use this after generate-boilerplate or generate-feature-scaffold to create the actual template files referenced in the includes array.`,
 			inputSchema: {
 				type: "object",
@@ -1354,7 +1381,55 @@ Use this after generate-boilerplate or generate-feature-scaffold to create the a
 					},
 					content: {
 						type: "string",
-						description: `Content of the template file (use {{ variableName }} for Liquid placeholders).
+						description: `Content of the template file using Liquid template syntax.
+
+LIQUID SYNTAX:
+- Variables: {{ variableName }} - Replaced with actual values
+- Conditionals: {% if condition %}...{% endif %} - Conditional rendering
+- Else: {% if condition %}...{% else %}...{% endif %}
+- Elsif: {% if condition %}...{% elsif other %}...{% endif %}
+- Equality: {% if var == 'value' %}...{% endif %}
+
+AVAILABLE FILTERS:
+You can transform variables using these filters with the pipe (|) syntax:
+
+Case Conversion:
+- {{ name | camelCase }} - Convert to camelCase (myVariableName)
+- {{ name | pascalCase }} - Convert to PascalCase (MyVariableName)
+- {{ name | titleCase }} - Convert to TitleCase (alias for pascalCase)
+- {{ name | kebabCase }} - Convert to kebab-case (my-variable-name)
+- {{ name | snakeCase }} - Convert to snake_case (my_variable_name)
+- {{ name | upperCase }} - Convert to UPPER_CASE (MY_VARIABLE_NAME)
+- {{ name | lower }} or {{ name | downcase }} - Convert to lowercase
+- {{ name | upper }} or {{ name | upcase }} - Convert to UPPERCASE
+
+String Manipulation:
+- {{ name | strip }} - Remove leading/trailing whitespace
+- {{ name | replace: "old", "new" }} - Replace text (e.g., replace: "Tool", "")
+- {{ name | pluralize }} - Add plural suffix (simple: book → books, class → classes)
+- {{ name | singularize }} - Remove plural suffix (simple: books → book)
+
+Chaining Filters:
+- {{ toolName | downcase | replace: "tool", "" | strip }} - Combine multiple filters
+
+Example with variables and conditionals:
+{
+  "name": "{{ packageName }}",{% if withFeature %}
+  "feature": "enabled",{% endif %}
+  "dependencies": {
+    "core": "1.0.0"{% if withOptional %},
+    "optional": "2.0.0"{% endif %}
+  }
+}
+
+Example with filters:
+export class {{ serviceName | pascalCase }} {
+  private {{ serviceName | camelCase }}: string;
+
+  constructor() {
+    this.{{ serviceName | camelCase }} = "{{ serviceName | kebabCase }}";
+  }
+}
 
 IMPORTANT - Keep content minimal and business-agnostic:
 - Focus on structure and patterns, not specific business logic
@@ -1733,23 +1808,22 @@ var ScaffoldGeneratorService = class {
 			message: `Feature '${featureName}' already exists in ${scaffoldYamlPath}`
 		};
 		const requiredVars = variables.filter((v) => v.required).map((v) => v.name);
-		const variablesSchema = {
-			type: "object",
-			properties: variables.reduce((acc, v) => {
-				acc[v.name] = {
-					type: v.type,
-					description: v.description
-				};
-				if (v.default !== void 0) acc[v.name].default = v.default;
-				return acc;
-			}, {}),
-			required: requiredVars,
-			additionalProperties: false
-		};
 		const featureDefinition = {
 			name: featureName,
 			description,
-			variables_schema: variablesSchema,
+			variables_schema: {
+				type: "object",
+				properties: variables.reduce((acc, v) => {
+					acc[v.name] = {
+						type: v.type,
+						description: v.description
+					};
+					if (v.default !== void 0) acc[v.name].default = v.default;
+					return acc;
+				}, {}),
+				required: requiredVars,
+				additionalProperties: false
+			},
 			includes: includes.length > 0 ? includes : []
 		};
 		if (instruction) featureDefinition.instruction = instruction;
@@ -2101,7 +2175,7 @@ var ScaffoldingMethodsService = class {
 					for (const boilerplate of architectConfig.boilerplate) if (boilerplate.name?.includes(sourceTemplate)) return templateDir;
 				}
 			} catch (error) {
-				console.warn(`Failed to read scaffold.yaml at ${scaffoldYamlPath}:`, error);
+				require_logger.log.warn(`Failed to read scaffold.yaml at ${scaffoldYamlPath}:`, error);
 			}
 		}
 		return null;
@@ -2134,11 +2208,11 @@ var ScaffoldingMethodsService = class {
 						}
 					}
 				} catch (error) {
-					console.warn(`Failed to read subdirectories in ${itemPath}:`, error);
+					require_logger.log.warn(`Failed to read subdirectories in ${itemPath}:`, error);
 				}
 			}
 		} catch (error) {
-			console.warn(`Failed to read templates root directory ${this.templatesRootPath}:`, error);
+			require_logger.log.warn(`Failed to read templates root directory ${this.templatesRootPath}:`, error);
 		}
 		return templateDirs;
 	}
@@ -2150,10 +2224,10 @@ var ScaffoldingMethodsService = class {
 			const availableMethods = scaffoldingMethods.methods.map((m) => m.name).join(", ");
 			throw new Error(`Scaffold method '${scaffold_feature_name}' not found. Available methods: ${availableMethods}`);
 		}
-		const ScaffoldService$1 = (await Promise.resolve().then(() => require("./ScaffoldService-BXKXXg4M.js"))).ScaffoldService;
-		const ScaffoldConfigLoader$1 = (await Promise.resolve().then(() => require("./ScaffoldConfigLoader-CnVkzUxL.js"))).ScaffoldConfigLoader;
-		const VariableReplacementService$1 = (await Promise.resolve().then(() => require("./VariableReplacementService-_GgLG4Im.js"))).VariableReplacementService;
-		const TemplateService$1 = (await Promise.resolve().then(() => require("./TemplateService-B0ns4TR_.js"))).TemplateService;
+		const ScaffoldService$1 = (await Promise.resolve().then(() => require("./ScaffoldService-Dp9yhqVI.js"))).ScaffoldService;
+		const ScaffoldConfigLoader$1 = (await Promise.resolve().then(() => require("./ScaffoldConfigLoader-BhrrsLya.js"))).ScaffoldConfigLoader;
+		const VariableReplacementService$1 = (await Promise.resolve().then(() => require("./VariableReplacementService-C0BdOUm6.js"))).VariableReplacementService;
+		const TemplateService$1 = (await Promise.resolve().then(() => require("./TemplateService-lGQxhofk.js"))).TemplateService;
 		const templateService = new TemplateService$1();
 		const scaffoldConfigLoader = new ScaffoldConfigLoader$1(this.fileSystem, templateService);
 		const variableReplacer = new VariableReplacementService$1(this.fileSystem, templateService);
@@ -2312,7 +2386,16 @@ IMPORTANT:
 			};
 			return { content: [{
 				type: "text",
-				text: (await this.boilerplateService.useBoilerplate(request)).message
+				text: `${(await this.boilerplateService.useBoilerplate(request)).message}
+
+IMPORTANT - Next Steps:
+1. READ the generated project files to understand their structure
+2. Review the boilerplate configuration and understand what was created
+3. If the project requires additional features, use list-scaffolding-methods to see available options
+4. Install dependencies (pnpm install) before testing or building
+5. Follow the project's README for setup instructions
+
+The boilerplate provides a starting point - you may need to add features or customize the generated code based on the project requirements.`
 			}] };
 		} catch (error) {
 			return {
@@ -2393,11 +2476,20 @@ IMPORTANT:
 			if (!variables) throw new Error("Missing required parameter: variables");
 			return { content: [{
 				type: "text",
-				text: (await this.scaffoldingMethodsService.useScaffoldMethod({
+				text: `${(await this.scaffoldingMethodsService.useScaffoldMethod({
 					projectPath,
 					scaffold_feature_name,
 					variables
-				})).message
+				})).message}
+
+IMPORTANT - Next Steps:
+1. READ the generated files to understand their structure and template placeholders
+2. IMPLEMENT the actual business logic according to the feature's purpose (replace TODOs and template variables)
+3. REGISTER the feature in the appropriate files (e.g., import and register tools in server/index.ts, export from index.ts)
+4. TEST the implementation to ensure it works correctly
+5. Only after completing the implementation should you move to other tasks
+
+Do not skip the implementation step - the scaffolded files contain templates that need actual code.`
 			}] };
 		} catch (error) {
 			return {
@@ -2563,17 +2655,12 @@ Example workflow for feature:
 		}
 	});
 	server.setRequestHandler(__modelcontextprotocol_sdk_types_js.ListToolsRequestSchema, async () => {
-		const listBoilerplateTool = listBoilerplatesTool.getDefinition();
-		const useBoilerplateToolDef = useBoilerplateTool.getDefinition();
-		const listScaffoldingMethodsToolDef = listScaffoldingMethodsTool.getDefinition();
-		const useScaffoldMethodToolDef = useScaffoldMethodTool.getDefinition();
-		const writeToFileToolDef = writeToFileTool.getDefinition();
 		const tools = [
-			listBoilerplateTool,
-			useBoilerplateToolDef,
-			listScaffoldingMethodsToolDef,
-			useScaffoldMethodToolDef,
-			writeToFileToolDef
+			listBoilerplatesTool.getDefinition(),
+			useBoilerplateTool.getDefinition(),
+			listScaffoldingMethodsTool.getDefinition(),
+			useScaffoldMethodTool.getDefinition(),
+			writeToFileTool.getDefinition()
 		];
 		if (adminEnabled) {
 			if (generateBoilerplateTool) tools.push(generateBoilerplateTool.getDefinition());
@@ -2993,27 +3080,18 @@ const mcpServeCommand = new commander.Command("mcp-serve").description("Start MC
 	try {
 		const transportType = options.type.toLowerCase();
 		const serverOptions = { adminEnabled: options.adminEnable };
-		if (transportType === "stdio") {
-			const server = createServer(serverOptions);
-			const handler = new StdioTransportHandler(server);
-			await startServer(handler);
-		} else if (transportType === "http") {
-			const config = {
-				mode: TransportMode.HTTP,
-				port: options.port || Number(process.env.MCP_PORT) || 3e3,
-				host: options.host || process.env.MCP_HOST || "localhost"
-			};
-			const handler = new HttpTransportHandler(() => createServer(serverOptions), config);
-			await startServer(handler);
-		} else if (transportType === "sse") {
-			const config = {
-				mode: TransportMode.SSE,
-				port: options.port || Number(process.env.MCP_PORT) || 3e3,
-				host: options.host || process.env.MCP_HOST || "localhost"
-			};
-			const handler = new SseTransportHandler(() => createServer(serverOptions), config);
-			await startServer(handler);
-		} else {
+		if (transportType === "stdio") await startServer(new StdioTransportHandler(createServer(serverOptions)));
+		else if (transportType === "http") await startServer(new HttpTransportHandler(() => createServer(serverOptions), {
+			mode: TransportMode.HTTP,
+			port: options.port || Number(process.env.MCP_PORT) || 3e3,
+			host: options.host || process.env.MCP_HOST || "localhost"
+		}));
+		else if (transportType === "sse") await startServer(new SseTransportHandler(() => createServer(serverOptions), {
+			mode: TransportMode.SSE,
+			port: options.port || Number(process.env.MCP_PORT) || 3e3,
+			host: options.host || process.env.MCP_HOST || "localhost"
+		}));
+		else {
 			console.error(`Unknown transport type: ${transportType}. Use: stdio, http, or sse`);
 			process.exit(1);
 		}
@@ -3038,18 +3116,17 @@ scaffoldCommand.command("list <projectPath>").description("List available scaffo
 			process.exit(1);
 		}
 		const templatesDir = await require_ScaffoldService.TemplatesManager.findTemplatesPath();
-		const fileSystemService = new FileSystemService();
-		const methods = (await new ScaffoldingMethodsService(fileSystemService, templatesDir).listScaffoldingMethods(absolutePath)).methods;
+		const methods = (await new ScaffoldingMethodsService(new FileSystemService(), templatesDir).listScaffoldingMethods(absolutePath)).methods;
 		if (methods.length === 0) {
 			messages.warning("No scaffolding methods available for this project.");
 			return;
 		}
-		logger.header(`\n${icons.wrench} Available Scaffolding Methods for ${projectPath}:\n`);
+		print.header(`\n${icons.wrench} Available Scaffolding Methods for ${projectPath}:\n`);
 		for (const method of methods) {
-			logger.highlight(`  ${method.name}`);
-			logger.debug(`    ${method.instruction || method.description || "No description available"}`);
-			if (method.variables_schema.required && method.variables_schema.required.length > 0) logger.debug(`    Required: ${method.variables_schema.required.join(", ")}`);
-			logger.newline();
+			print.highlight(`  ${method.name}`);
+			print.debug(`    ${method.instruction || method.description || "No description available"}`);
+			if (method.variables_schema.required && method.variables_schema.required.length > 0) print.debug(`    Required: ${method.variables_schema.required.join(", ")}`);
+			print.newline();
 		}
 	} catch (error) {
 		messages.error("Error listing scaffolding methods:", error);
@@ -3073,14 +3150,13 @@ scaffoldCommand.command("add <featureName>").description("Add a feature to an ex
 			process.exit(1);
 		}
 		const templatesDir = await require_ScaffoldService.TemplatesManager.findTemplatesPath();
-		const fileSystemService = new FileSystemService();
-		const scaffoldingMethodsService = new ScaffoldingMethodsService(fileSystemService, templatesDir);
+		const scaffoldingMethodsService = new ScaffoldingMethodsService(new FileSystemService(), templatesDir);
 		const methods = (await scaffoldingMethodsService.listScaffoldingMethods(projectPath)).methods;
 		const method = methods.find((m) => m.name === featureName);
 		if (!method) {
 			messages.error(`Scaffold method '${featureName}' not found.`);
-			logger.warning(`Available methods: ${methods.map((m) => m.name).join(", ")}`);
-			logger.debug(`Run 'scaffold-mcp scaffold list ${options.project}' to see all available methods`);
+			print.warning(`Available methods: ${methods.map((m) => m.name).join(", ")}`);
+			print.debug(`Run 'scaffold-mcp scaffold list ${options.project}' to see all available methods`);
 			process.exit(1);
 		}
 		const required = typeof method.variables_schema === "object" && method.variables_schema !== null && "required" in method.variables_schema ? method.variables_schema.required : [];
@@ -3092,15 +3168,15 @@ scaffoldCommand.command("add <featureName>").description("Add a feature to an ex
 			for (const key of required) if (key.includes("Name")) exampleVars[key] = "MyFeature";
 			else if (key === "description") exampleVars[key] = "Feature description";
 			else exampleVars[key] = `<${key}>`;
-			logger.debug(`Example: scaffold-mcp scaffold add ${featureName} --project ${options.project} --vars '${JSON.stringify(exampleVars)}'`);
+			print.debug(`Example: scaffold-mcp scaffold add ${featureName} --project ${options.project} --vars '${JSON.stringify(exampleVars)}'`);
 			process.exit(1);
 		}
 		if (options.verbose) {
-			logger.info(`🔧 Feature: ${featureName}`);
-			logger.info(`📊 Variables: ${JSON.stringify(variables, null, 2)}`);
-			logger.info(`📁 Project Path: ${projectPath}`);
+			print.info(`🔧 Feature: ${featureName}`);
+			print.info(`📊 Variables: ${JSON.stringify(variables, null, 2)}`);
+			print.info(`📁 Project Path: ${projectPath}`);
 		}
-		logger.info(`🚀 Adding '${featureName}' to project...`);
+		print.info(`🚀 Adding '${featureName}' to project...`);
 		const result = await scaffoldingMethodsService.useScaffoldMethod({
 			projectPath,
 			scaffold_feature_name: featureName,
@@ -3110,17 +3186,17 @@ scaffoldCommand.command("add <featureName>").description("Add a feature to an ex
 			messages.success("✅ Feature added successfully!");
 			console.log(result.message);
 			if (result.createdFiles && result.createdFiles.length > 0) {
-				logger.header("\n📁 Created files:");
-				result.createdFiles.forEach((file) => logger.debug(`   - ${file}`));
+				print.header("\n📁 Created files:");
+				result.createdFiles.forEach((file) => print.debug(`   - ${file}`));
 			}
 			if (result.warnings && result.warnings.length > 0) {
 				messages.warning("\n⚠️  Warnings:");
-				result.warnings.forEach((warning) => logger.debug(`   - ${warning}`));
+				result.warnings.forEach((warning) => print.debug(`   - ${warning}`));
 			}
-			logger.header("\n📋 Next steps:");
-			logger.debug("   - Review the generated files");
-			logger.debug("   - Update imports if necessary");
-			logger.debug("   - Run tests to ensure everything works");
+			print.header("\n📋 Next steps:");
+			print.debug("   - Review the generated files");
+			print.debug("   - Update imports if necessary");
+			print.debug("   - Run tests to ensure everything works");
 		} else {
 			messages.error(`❌ Failed to add feature: ${result.message}`);
 			process.exit(1);
@@ -3139,23 +3215,22 @@ scaffoldCommand.command("info <featureName>").description("Show detailed informa
 			process.exit(1);
 		}
 		const templatesDir = await require_ScaffoldService.TemplatesManager.findTemplatesPath();
-		const fileSystemService = new FileSystemService();
-		const method = (await new ScaffoldingMethodsService(fileSystemService, templatesDir).listScaffoldingMethods(projectPath)).methods.find((m) => m.name === featureName);
+		const method = (await new ScaffoldingMethodsService(new FileSystemService(), templatesDir).listScaffoldingMethods(projectPath)).methods.find((m) => m.name === featureName);
 		if (!method) {
 			messages.error(`❌ Scaffold method '${featureName}' not found.`);
 			process.exit(1);
 		}
-		logger.header(`\n🔧 Scaffold Method: ${method.name}\n`);
-		logger.debug(`Description: ${method.description}`);
-		logger.header("\n📝 Variables Schema:");
+		print.header(`\n🔧 Scaffold Method: ${method.name}\n`);
+		print.debug(`Description: ${method.description}`);
+		print.header("\n📝 Variables Schema:");
 		console.log(JSON.stringify(method.variables_schema, null, 2));
 		const includes = "includes" in method ? method.includes : [];
 		if (includes && includes.length > 0) {
-			logger.header("\n📁 Files to be created:");
+			print.header("\n📁 Files to be created:");
 			includes.forEach((include) => {
 				const parts = include.split(">>");
-				if (parts.length === 2) logger.debug(`  - ${parts[1].trim()}`);
-				else logger.debug(`  - ${include}`);
+				if (parts.length === 2) print.debug(`  - ${parts[1].trim()}`);
+				else print.debug(`  - ${include}`);
 			});
 		}
 	} catch (error) {

package/dist/logger-qztMS7ET.js

@@ -0,0 +1,32 @@
+const require_chunk = require('./chunk-nOFOJqeH.js');
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let node_os = require("node:os");
+node_os = require_chunk.__toESM(node_os);
+let pino = require("pino");
+pino = require_chunk.__toESM(pino);
+
+//#region src/utils/logger.ts
+const logsDir = node_path.join(node_os.tmpdir(), "scaffold-mcp-logs");
+const logger = (0, pino.default)({
+	level: process.env.LOG_LEVEL || "debug",
+	timestamp: pino.default.stdTimeFunctions.isoTime
+}, pino.default.destination({
+	dest: node_path.join(logsDir, "scaffold-mcp.log"),
+	mkdir: true,
+	sync: true
+}));
+const log = {
+	debug: (msg, ...args) => logger.debug({ args }, msg),
+	info: (msg, ...args) => logger.info({ args }, msg),
+	warn: (msg, ...args) => logger.warn({ args }, msg),
+	error: (msg, ...args) => logger.error({ args }, msg)
+};
+
+//#endregion
+Object.defineProperty(exports, 'log', {
+  enumerable: true,
+  get: function () {
+    return log;
+  }
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agiflowai/scaffold-mcp",
   "description": "MCP server for scaffolding applications with boilerplate templates",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "license": "AGPL-3.0",
   "author": "AgiflowIO",
   "repository": {
@@ -41,8 +41,10 @@
     "fs-extra": "11.3.2",
     "js-yaml": "4.1.0",
     "liquidjs": "10.21.1",
+    "pino": "^10.0.0",
+    "pino-pretty": "^13.1.1",
     "zod": "3.25.76",
-    "@agiflowai/scaffold-generator": "0.3.1"
+    "@agiflowai/scaffold-generator": "0.3.3"
   },
   "devDependencies": {
     "@types/express": "^5.0.0",
@@ -58,7 +60,7 @@
   "scripts": {
     "dev": "node --loader ts-node/esm src/index.ts",
     "build": "tsdown",
-    "test": "vitest",
+    "test": "vitest --run",
     "typecheck": "tsc --noEmit"
   }
 }

package/dist/ScaffoldService-BXKXXg4M.js

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

package/dist/TemplateService-B0ns4TR_.js

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