@agiflowai/scaffold-mcp 0.3.0 → 0.3.2

package/dist/index.js

@@ -1,63 +1,161 @@
 #!/usr/bin/env node
-import { ScaffoldService, TemplatesManager } from "./ScaffoldService-CnJ1nj1v.js";
-import { ScaffoldConfigLoader } from "./ScaffoldConfigLoader-CI0T6zdG.js";
-import { TemplateService } from "./TemplateService-CnxvhRVW.js";
-import { VariableReplacementService } from "./VariableReplacementService-Bq0GDhTo.js";
-import { Command } from "commander";
-import * as path$1 from "node:path";
-import path from "node:path";
-import * as fs$1 from "fs-extra";
-import fs from "fs-extra";
-import chalk from "chalk";
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
-import { jsonSchemaToZod } from "@composio/json-schema-to-zod";
-import * as yaml$1 from "js-yaml";
-import yaml from "js-yaml";
-import { z } from "zod";
-import { fileURLToPath } from "node:url";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListToolsRequestSchema, isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
-import { randomUUID } from "node:crypto";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import express from "express";
-import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-
-//#region src/utils/console.ts
+const require_chunk = require('./chunk-nOFOJqeH.js');
+const require_logger = require('./logger-Dno88AK9.js');
+const require_ScaffoldConfigLoader = require('./ScaffoldConfigLoader-CvIJEFcI.js');
+const require_ScaffoldService = require('./ScaffoldService-N6X24Vw0.js');
+const require_TemplateService = require('./TemplateService-Em2i9bb7.js');
+const require_VariableReplacementService = require('./VariableReplacementService-BGmF2DVE.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 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");
+js_yaml = require_chunk.__toESM(js_yaml);
+let zod = require("zod");
+zod = require_chunk.__toESM(zod);
+let __modelcontextprotocol_sdk_server_index_js = require("@modelcontextprotocol/sdk/server/index.js");
+__modelcontextprotocol_sdk_server_index_js = require_chunk.__toESM(__modelcontextprotocol_sdk_server_index_js);
+let __modelcontextprotocol_sdk_types_js = require("@modelcontextprotocol/sdk/types.js");
+__modelcontextprotocol_sdk_types_js = require_chunk.__toESM(__modelcontextprotocol_sdk_types_js);
+let node_crypto = require("node:crypto");
+node_crypto = require_chunk.__toESM(node_crypto);
+let __modelcontextprotocol_sdk_server_streamableHttp_js = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+__modelcontextprotocol_sdk_server_streamableHttp_js = require_chunk.__toESM(__modelcontextprotocol_sdk_server_streamableHttp_js);
+let express = require("express");
+express = require_chunk.__toESM(express);
+let __modelcontextprotocol_sdk_server_sse_js = require("@modelcontextprotocol/sdk/server/sse.js");
+__modelcontextprotocol_sdk_server_sse_js = require_chunk.__toESM(__modelcontextprotocol_sdk_server_sse_js);
+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/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.cyan(message));
+		console.log(chalk.default.cyan(message));
 	},
 	success: (message) => {
-		console.log(chalk.green(message));
+		console.log(chalk.default.green(message));
 	},
 	warning: (message) => {
-		console.log(chalk.yellow(message));
+		console.log(chalk.default.yellow(message));
 	},
 	error: (message, error) => {
 		if (error) {
 			const errorMsg = error instanceof Error ? error.message : error;
-			console.error(chalk.red(message), errorMsg);
-		} else console.error(chalk.red(message));
+			console.error(chalk.default.red(message), errorMsg);
+		} else console.error(chalk.default.red(message));
 	},
 	debug: (message) => {
-		console.log(chalk.gray(message));
+		console.log(chalk.default.gray(message));
 	},
 	header: (message) => {
-		console.log(chalk.bold.cyan(message));
+		console.log(chalk.default.bold.cyan(message));
 	},
 	item: (message) => {
-		console.log(chalk.gray(`   - ${message}`));
+		console.log(chalk.default.gray(`   - ${message}`));
 	},
 	indent: (message) => {
-		console.log(chalk.gray(`   ${message}`));
+		console.log(chalk.default.gray(`   ${message}`));
 	},
 	highlight: (message) => {
-		console.log(chalk.bold.green(message));
+		console.log(chalk.default.bold.green(message));
 	},
 	newline: () => {
 		console.log();
@@ -90,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}`);
 	}
 };
 /**
@@ -113,121 +211,37 @@ 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 = promisify(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 = path.join(tempFolder, ".git", "info", "sparse-checkout");
-		await fs$1.writeFile(sparseCheckoutFile, `${subdirectory}\n`);
-		await execAsync(`git -C "${tempFolder}" pull --depth=1 origin ${branch}`);
-		const sourceDir = path.join(tempFolder, subdirectory);
-		if (!await fs$1.pathExists(sourceDir)) throw new Error(`Subdirectory '${subdirectory}' not found in repository at branch '${branch}'`);
-		await fs$1.move(sourceDir, targetFolder);
-		await fs$1.remove(tempFolder);
-	} catch (error) {
-		if (await fs$1.pathExists(tempFolder)) await fs$1.remove(tempFolder);
-		throw error;
-	}
-}
-/**
-* Clone entire repository
-*/
-async function cloneRepository(repoUrl, targetFolder) {
-	await execAsync(`git clone ${repoUrl} "${targetFolder}"`);
-	const gitFolder = path.join(targetFolder, ".git");
-	if (await fs$1.pathExists(gitFolder)) await fs$1.remove(gitFolder);
-}
-/**
-* Fetch directory listing from GitHub API
-*/
-async function fetchGitHubDirectoryContents(owner, repo, path$2, branch = "main") {
-	const url = `https://api.github.com/repos/${owner}/${repo}/contents/${path$2}?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
 /**
 * Add command - add a template to templates folder
 */
-const addCommand = new Command("add").description("Add a template to templates folder").requiredOption("--name <name>", "Template name").requiredOption("--url <url>", "URL of the template repository to download").option("--path <path>", "Path to templates folder", "./templates").option("--type <type>", "Template type: boilerplate or scaffold", "boilerplate").action(async (options) => {
+const addCommand = new commander.Command("add").description("Add a template to templates folder").requiredOption("--name <name>", "Template name").requiredOption("--url <url>", "URL of the template repository to download").option("--path <path>", "Path to templates folder", "./templates").option("--type <type>", "Template type: boilerplate or scaffold", "boilerplate").action(async (options) => {
 	try {
-		const templatesPath = path.resolve(options.path);
+		const templatesPath = node_path.default.resolve(options.path);
 		const templateType = options.type.toLowerCase();
 		const templateName = options.name;
 		const templateUrl = options.url;
@@ -235,33 +249,33 @@ const addCommand = new Command("add").description("Add a template to templates f
 			messages.error("Invalid template type. Use: boilerplate or scaffold");
 			process.exit(1);
 		}
-		const targetFolder = path.join(templatesPath, `${templateType}s`, templateName);
-		if (await fs$1.pathExists(targetFolder)) {
+		const targetFolder = node_path.default.join(templatesPath, `${templateType}s`, templateName);
+		if (await fs_extra.pathExists(targetFolder)) {
 			messages.error(`Template '${templateName}' already exists at ${targetFolder}`);
 			process.exit(1);
 		}
-		logger.info(`${icons.download} Downloading template '${templateName}' from ${templateUrl}...`);
-		await fs$1.ensureDir(path.dirname(targetFolder));
+		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);
-			const configFiles = [path.join(targetFolder, "boilerplate.yaml"), path.join(targetFolder, "scaffold.yaml")];
+			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$1.pathExists(configFile)) {
-				logger.header(`\n${icons.config} Configuration file found:`);
-				logger.indent(path.basename(configFile));
+			for (const configFile of configFiles) if (await fs_extra.pathExists(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) {
@@ -280,29 +294,29 @@ const addCommand = new Command("add").description("Add a template to templates f
 //#endregion
 //#region src/services/FileSystemService.ts
 var FileSystemService = class {
-	async pathExists(path$2) {
-		return fs.pathExists(path$2);
+	async pathExists(path$6) {
+		return fs_extra.default.pathExists(path$6);
 	}
-	async readFile(path$2, encoding = "utf8") {
-		return fs.readFile(path$2, encoding);
+	async readFile(path$6, encoding = "utf8") {
+		return fs_extra.default.readFile(path$6, encoding);
 	}
-	async readJson(path$2) {
-		return fs.readJson(path$2);
+	async readJson(path$6) {
+		return fs_extra.default.readJson(path$6);
 	}
-	async writeFile(path$2, content, encoding = "utf8") {
-		return fs.writeFile(path$2, content, encoding);
+	async writeFile(path$6, content, encoding = "utf8") {
+		return fs_extra.default.writeFile(path$6, content, encoding);
 	}
-	async ensureDir(path$2) {
-		return fs.ensureDir(path$2);
+	async ensureDir(path$6) {
+		return fs_extra.default.ensureDir(path$6);
 	}
 	async copy(src, dest) {
-		return fs.copy(src, dest);
+		return fs_extra.default.copy(src, dest);
 	}
-	async readdir(path$2) {
-		return fs.readdir(path$2);
+	async readdir(path$6) {
+		return fs_extra.default.readdir(path$6);
 	}
-	async stat(path$2) {
-		return fs.stat(path$2);
+	async stat(path$6) {
+		return fs_extra.default.stat(path$6);
 	}
 };
 
@@ -314,11 +328,9 @@ var BoilerplateService = class {
 	scaffoldService;
 	constructor(templatesPath) {
 		this.templatesPath = templatesPath;
-		this.templateService = new TemplateService();
+		this.templateService = new require_TemplateService.TemplateService();
 		const fileSystemService = new FileSystemService();
-		const scaffoldConfigLoader = new ScaffoldConfigLoader(fileSystemService, this.templateService);
-		const variableReplacementService = new VariableReplacementService(fileSystemService, this.templateService);
-		this.scaffoldService = new 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
@@ -327,13 +339,13 @@ var BoilerplateService = class {
 		const boilerplates = [];
 		const templateDirs = await this.discoverTemplateDirectories();
 		for (const templatePath of templateDirs) {
-			const scaffoldYamlPath = path$1.join(this.templatesPath, templatePath, "scaffold.yaml");
-			if (fs$1.existsSync(scaffoldYamlPath)) try {
-				const scaffoldContent = fs$1.readFileSync(scaffoldYamlPath, "utf8");
-				const scaffoldConfig = yaml$1.load(scaffoldContent);
+			const scaffoldYamlPath = node_path.join(this.templatesPath, templatePath, "scaffold.yaml");
+			if (fs_extra.existsSync(scaffoldYamlPath)) try {
+				const scaffoldContent = fs_extra.readFileSync(scaffoldYamlPath, "utf8");
+				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({
@@ -347,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 };
@@ -359,17 +371,14 @@ var BoilerplateService = class {
 	async discoverTemplateDirectories() {
 		const templateDirs = [];
 		const findTemplates = (dir, baseDir = "") => {
-			if (!fs$1.existsSync(dir)) return;
-			const items = fs$1.readdirSync(dir);
+			if (!fs_extra.existsSync(dir)) return;
+			const items = fs_extra.readdirSync(dir);
 			const hasPackageJson = items.includes("package.json") || items.includes("package.json.liquid");
 			const hasScaffoldYaml = items.includes("scaffold.yaml");
 			if (hasPackageJson && hasScaffoldYaml) templateDirs.push(baseDir);
 			for (const item of items) {
-				const itemPath = path$1.join(dir, item);
-				if (fs$1.statSync(itemPath).isDirectory() && !item.startsWith(".") && item !== "node_modules") {
-					const newBaseDir = baseDir ? path$1.join(baseDir, item) : item;
-					findTemplates(itemPath, newBaseDir);
-				}
+				const itemPath = node_path.join(dir, item);
+				if (fs_extra.statSync(itemPath).isDirectory() && !item.startsWith(".") && item !== "node_modules") findTemplates(itemPath, baseDir ? node_path.join(baseDir, item) : item);
 			}
 		};
 		findTemplates(this.templatesPath);
@@ -452,13 +461,13 @@ var BoilerplateService = class {
 	validateBoilerplateVariables(boilerplate, variables) {
 		const errors = [];
 		try {
-			jsonSchemaToZod(boilerplate.variables_schema).parse(variables);
+			(0, __composio_json_schema_to_zod.jsonSchemaToZod)(boilerplate.variables_schema).parse(variables);
 			return {
 				isValid: true,
 				errors: []
 			};
 		} catch (error) {
-			if (error instanceof z.ZodError) {
+			if (error instanceof zod.z.ZodError) {
 				const zodErrors = error.errors.map((err) => {
 					return `${err.path.length > 0 ? err.path.join(".") : "root"}: ${err.message}`;
 				});
@@ -475,11 +484,11 @@ var BoilerplateService = class {
 	* If project.json exists, updates it; otherwise creates a new one
 	*/
 	ensureProjectJsonSourceTemplate(targetFolder, projectName, sourceTemplate) {
-		const projectJsonPath = path$1.join(targetFolder, projectName, "project.json");
+		const projectJsonPath = node_path.join(targetFolder, projectName, "project.json");
 		try {
 			let projectJson;
-			if (fs$1.existsSync(projectJsonPath)) {
-				const content = fs$1.readFileSync(projectJsonPath, "utf8");
+			if (fs_extra.existsSync(projectJsonPath)) {
+				const content = fs_extra.readFileSync(projectJsonPath, "utf8");
 				projectJson = JSON.parse(content);
 			} else projectJson = {
 				name: projectName,
@@ -488,35 +497,34 @@ var BoilerplateService = class {
 				projectType: "application"
 			};
 			projectJson.sourceTemplate = sourceTemplate;
-			fs$1.writeFileSync(projectJsonPath, `${JSON.stringify(projectJson, null, 2)}\n`, "utf8");
+			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}`);
 		}
 	}
 };
 
 //#endregion
 //#region src/cli/boilerplate.ts
-const templatesDir$1 = TemplatesManager.findTemplatesPathSync();
 /**
 * Boilerplate CLI command
 */
-const boilerplateCommand = new Command("boilerplate").description("Manage boilerplate templates");
+const boilerplateCommand = new commander.Command("boilerplate").description("Manage boilerplate templates");
 boilerplateCommand.command("list").description("List all available boilerplate templates").action(async () => {
 	try {
-		const { boilerplates } = await new BoilerplateService(templatesDir$1).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);
@@ -525,7 +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 boilerplateService = new BoilerplateService(templatesDir$1);
+		const boilerplateService = new BoilerplateService(await require_ScaffoldService.TemplatesManager.findTemplatesPath());
 		let variables = {};
 		if (options.vars) try {
 			variables = JSON.parse(options.vars);
@@ -538,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 : [];
@@ -550,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({
@@ -564,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([
@@ -584,16 +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 bp = await new BoilerplateService(templatesDir$1).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) {
@@ -608,13 +616,13 @@ boilerplateCommand.command("info <boilerplateName>").description("Show detailed
 * Find the workspace root by searching upwards for .git folder
 */
 async function findWorkspaceRoot(startPath = process.cwd()) {
-	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);
 	}
 }
 const DEFAULT_TEMPLATE_REPO = {
@@ -628,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 = path.join(templatesPath, template.name);
-			if (await fs$1.pathExists(targetFolder)) {
-				logger.info(`${icons.skip} Skipping ${template.name} (already exists)`);
+			const targetFolder = node_path.default.join(templatesPath, template.name);
+			if (await fs_extra.pathExists(targetFolder)) {
+				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}`);
 	}
@@ -654,13 +661,13 @@ async function downloadTemplates(templatesPath) {
 /**
 * Init command - initialize templates folder
 */
-const initCommand = new Command("init").description("Initialize templates folder structure at workspace root").option("--no-download", "Skip downloading templates from repository").option("--path <path>", "Custom path for templates folder (relative to workspace root)").action(async (options) => {
+const initCommand = new commander.Command("init").description("Initialize templates folder structure at workspace root").option("--no-download", "Skip downloading templates from repository").option("--path <path>", "Custom path for templates folder (relative to workspace root)").action(async (options) => {
 	try {
 		const workspaceRoot = await findWorkspaceRoot();
-		const templatesPath = options.path ? path.join(workspaceRoot, options.path) : path.join(workspaceRoot, "templates");
-		logger.info(`${icons.rocket} Initializing templates folder at: ${templatesPath}`);
-		await fs$1.ensureDir(templatesPath);
-		await fs$1.writeFile(path.join(templatesPath, "README.md"), `# Templates
+		const templatesPath = options.path ? node_path.default.join(workspaceRoot, options.path) : node_path.default.join(workspaceRoot, "templates");
+		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
 
 This folder contains boilerplate templates and scaffolding methods for your projects.
 
@@ -694,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`);
@@ -1010,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`
 			}
 		}];
 	}
@@ -1125,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`
 			}
 		}];
 	}
@@ -1151,7 +1189,7 @@ var BoilerplateGeneratorService = class {
 	* Custom YAML dumper that forces literal block style (|) for description and instruction fields
 	*/
 	dumpYamlWithLiteralBlocks(config) {
-		const LiteralBlockType = new yaml$1.Type("tag:yaml.org,2002:str", {
+		const LiteralBlockType = new js_yaml.Type("tag:yaml.org,2002:str", {
 			kind: "scalar",
 			construct: (data) => data,
 			represent: (data) => {
@@ -1159,9 +1197,9 @@ var BoilerplateGeneratorService = class {
 			},
 			defaultStyle: "|"
 		});
-		const LITERAL_SCHEMA = yaml$1.DEFAULT_SCHEMA.extend([LiteralBlockType]);
+		const LITERAL_SCHEMA = js_yaml.DEFAULT_SCHEMA.extend([LiteralBlockType]);
 		const processedConfig = this.processConfigForLiteralBlocks(config);
-		return yaml$1.dump(processedConfig, {
+		return js_yaml.dump(processedConfig, {
 			schema: LITERAL_SCHEMA,
 			indent: 2,
 			lineWidth: -1,
@@ -1204,13 +1242,13 @@ var BoilerplateGeneratorService = class {
 	*/
 	async generateBoilerplate(options) {
 		const { templateName, boilerplateName, description, instruction, targetFolder, variables, includes = [] } = options;
-		const templatePath = path$1.join(this.templatesPath, templateName);
-		await fs$1.ensureDir(templatePath);
-		const scaffoldYamlPath = path$1.join(templatePath, "scaffold.yaml");
+		const templatePath = node_path.join(this.templatesPath, templateName);
+		await fs_extra.ensureDir(templatePath);
+		const scaffoldYamlPath = node_path.join(templatePath, "scaffold.yaml");
 		let scaffoldConfig = {};
-		if (await fs$1.pathExists(scaffoldYamlPath)) {
-			const yamlContent$1 = await fs$1.readFile(scaffoldYamlPath, "utf-8");
-			scaffoldConfig = yaml$1.load(yamlContent$1);
+		if (await fs_extra.pathExists(scaffoldYamlPath)) {
+			const yamlContent$1 = await fs_extra.readFile(scaffoldYamlPath, "utf-8");
+			scaffoldConfig = js_yaml.load(yamlContent$1);
 		}
 		if (!scaffoldConfig.boilerplate) scaffoldConfig.boilerplate = [];
 		if (scaffoldConfig.boilerplate.findIndex((b) => b.name === boilerplateName) !== -1) return {
@@ -1218,30 +1256,29 @@ 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;
 		scaffoldConfig.boilerplate.push(boilerplateDefinition);
 		const yamlContent = this.dumpYamlWithLiteralBlocks(scaffoldConfig);
-		await fs$1.writeFile(scaffoldYamlPath, yamlContent, "utf-8");
+		await fs_extra.writeFile(scaffoldYamlPath, yamlContent, "utf-8");
 		return {
 			success: true,
 			message: `Boilerplate '${boilerplateName}' added to ${scaffoldYamlPath}`,
@@ -1253,43 +1290,43 @@ var BoilerplateGeneratorService = class {
 	* List all templates (directories in templates folder)
 	*/
 	async listTemplates() {
-		return (await fs$1.readdir(this.templatesPath, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+		return (await fs_extra.readdir(this.templatesPath, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
 	}
 	/**
 	* Check if a template exists
 	*/
 	async templateExists(templateName) {
-		const templatePath = path$1.join(this.templatesPath, templateName);
-		return fs$1.pathExists(templatePath);
+		const templatePath = node_path.join(this.templatesPath, templateName);
+		return fs_extra.pathExists(templatePath);
 	}
 	/**
 	* Create or update a template file for a boilerplate
 	*/
 	async createTemplateFile(options) {
 		const { templateName, filePath, content, sourceFile, header } = options;
-		const templatePath = path$1.join(this.templatesPath, templateName);
-		if (!await fs$1.pathExists(templatePath)) return {
+		const templatePath = node_path.join(this.templatesPath, templateName);
+		if (!await fs_extra.pathExists(templatePath)) return {
 			success: false,
 			message: `Template directory '${templateName}' does not exist at ${templatePath}`
 		};
 		let fileContent = content || "";
 		if (sourceFile) {
-			if (!await fs$1.pathExists(sourceFile)) return {
+			if (!await fs_extra.pathExists(sourceFile)) return {
 				success: false,
 				message: `Source file '${sourceFile}' does not exist`
 			};
-			fileContent = await fs$1.readFile(sourceFile, "utf-8");
+			fileContent = await fs_extra.readFile(sourceFile, "utf-8");
 		}
 		if (!fileContent && !sourceFile) return {
 			success: false,
 			message: "Either content or sourceFile must be provided"
 		};
 		const templateFilePath = filePath.endsWith(".liquid") ? filePath : `${filePath}.liquid`;
-		const fullPath = path$1.join(templatePath, templateFilePath);
-		await fs$1.ensureDir(path$1.dirname(fullPath));
+		const fullPath = node_path.join(templatePath, templateFilePath);
+		await fs_extra.ensureDir(node_path.dirname(fullPath));
 		let finalContent = fileContent;
 		if (header) finalContent = `${header}\n\n${fileContent}`;
-		await fs$1.writeFile(fullPath, finalContent, "utf-8");
+		await fs_extra.writeFile(fullPath, finalContent, "utf-8");
 		return {
 			success: true,
 			message: "Template file created successfully",
@@ -1325,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",
@@ -1339,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
@@ -1651,7 +1741,7 @@ var ScaffoldGeneratorService = class {
 	* Custom YAML dumper that forces literal block style (|) for description and instruction fields
 	*/
 	dumpYamlWithLiteralBlocks(config) {
-		const LiteralBlockType = new yaml$1.Type("tag:yaml.org,2002:str", {
+		const LiteralBlockType = new js_yaml.Type("tag:yaml.org,2002:str", {
 			kind: "scalar",
 			construct: (data) => data,
 			represent: (data) => {
@@ -1659,9 +1749,9 @@ var ScaffoldGeneratorService = class {
 			},
 			defaultStyle: "|"
 		});
-		const LITERAL_SCHEMA = yaml$1.DEFAULT_SCHEMA.extend([LiteralBlockType]);
+		const LITERAL_SCHEMA = js_yaml.DEFAULT_SCHEMA.extend([LiteralBlockType]);
 		const processedConfig = this.processConfigForLiteralBlocks(config);
-		return yaml$1.dump(processedConfig, {
+		return js_yaml.dump(processedConfig, {
 			schema: LITERAL_SCHEMA,
 			indent: 2,
 			lineWidth: -1,
@@ -1704,13 +1794,13 @@ var ScaffoldGeneratorService = class {
 	*/
 	async generateFeatureScaffold(options) {
 		const { templateName, featureName, description, instruction, variables, includes = [], patterns = [] } = options;
-		const templatePath = path$1.join(this.templatesPath, templateName);
-		await fs$1.ensureDir(templatePath);
-		const scaffoldYamlPath = path$1.join(templatePath, "scaffold.yaml");
+		const templatePath = node_path.join(this.templatesPath, templateName);
+		await fs_extra.ensureDir(templatePath);
+		const scaffoldYamlPath = node_path.join(templatePath, "scaffold.yaml");
 		let scaffoldConfig = {};
-		if (await fs$1.pathExists(scaffoldYamlPath)) {
-			const yamlContent$1 = await fs$1.readFile(scaffoldYamlPath, "utf-8");
-			scaffoldConfig = yaml$1.load(yamlContent$1);
+		if (await fs_extra.pathExists(scaffoldYamlPath)) {
+			const yamlContent$1 = await fs_extra.readFile(scaffoldYamlPath, "utf-8");
+			scaffoldConfig = js_yaml.load(yamlContent$1);
 		}
 		if (!scaffoldConfig.features) scaffoldConfig.features = [];
 		if (scaffoldConfig.features.findIndex((f) => f.name === featureName) !== -1) return {
@@ -1718,30 +1808,29 @@ 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;
 		if (patterns && patterns.length > 0) featureDefinition.patterns = patterns;
 		scaffoldConfig.features.push(featureDefinition);
 		const yamlContent = this.dumpYamlWithLiteralBlocks(scaffoldConfig);
-		await fs$1.writeFile(scaffoldYamlPath, yamlContent, "utf-8");
+		await fs_extra.writeFile(scaffoldYamlPath, yamlContent, "utf-8");
 		return {
 			success: true,
 			message: `Feature '${featureName}' added to ${scaffoldYamlPath}`,
@@ -1753,14 +1842,14 @@ var ScaffoldGeneratorService = class {
 	* List all templates (directories in templates folder)
 	*/
 	async listTemplates() {
-		return (await fs$1.readdir(this.templatesPath, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+		return (await fs_extra.readdir(this.templatesPath, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
 	}
 	/**
 	* Check if a template exists
 	*/
 	async templateExists(templateName) {
-		const templatePath = path$1.join(this.templatesPath, templateName);
-		return fs$1.pathExists(templatePath);
+		const templatePath = node_path.join(this.templatesPath, templateName);
+		return fs_extra.pathExists(templatePath);
 	}
 };
 
@@ -2015,22 +2104,22 @@ var ScaffoldingMethodsService = class {
 	constructor(fileSystem, templatesRootPath) {
 		this.fileSystem = fileSystem;
 		this.templatesRootPath = templatesRootPath;
-		this.templateService = new TemplateService();
+		this.templateService = new require_TemplateService.TemplateService();
 	}
 	async listScaffoldingMethods(projectPath) {
-		const absoluteProjectPath = path.resolve(projectPath);
-		const projectJsonPath = path.join(absoluteProjectPath, "project.json");
+		const absoluteProjectPath = node_path.default.resolve(projectPath);
+		const projectJsonPath = node_path.default.join(absoluteProjectPath, "project.json");
 		if (!await this.fileSystem.pathExists(projectJsonPath)) throw new Error(`project.json not found at ${projectJsonPath}`);
 		const projectConfig = await this.fileSystem.readJson(projectJsonPath);
 		if (!projectConfig.sourceTemplate) throw new Error(`sourceTemplate not specified in project.json at ${projectJsonPath}`);
 		const sourceTemplate = projectConfig.sourceTemplate;
 		const templatePath = await this.findTemplatePath(sourceTemplate);
 		if (!templatePath) throw new Error(`Template not found for sourceTemplate: ${sourceTemplate}`);
-		const fullTemplatePath = path.join(this.templatesRootPath, templatePath);
-		const scaffoldYamlPath = path.join(fullTemplatePath, "scaffold.yaml");
+		const fullTemplatePath = node_path.default.join(this.templatesRootPath, templatePath);
+		const scaffoldYamlPath = node_path.default.join(fullTemplatePath, "scaffold.yaml");
 		if (!await this.fileSystem.pathExists(scaffoldYamlPath)) throw new Error(`scaffold.yaml not found at ${scaffoldYamlPath}`);
 		const scaffoldContent = await this.fileSystem.readFile(scaffoldYamlPath, "utf8");
-		const architectConfig = yaml.load(scaffoldContent);
+		const architectConfig = js_yaml.default.load(scaffoldContent);
 		const methods = [];
 		if (architectConfig.features && Array.isArray(architectConfig.features)) architectConfig.features.forEach((feature) => {
 			if (feature.name) methods.push({
@@ -2077,16 +2166,16 @@ var ScaffoldingMethodsService = class {
 		const templateDirs = await this.discoverTemplateDirs();
 		if (templateDirs.includes(sourceTemplate)) return sourceTemplate;
 		for (const templateDir of templateDirs) {
-			const templatePath = path.join(this.templatesRootPath, templateDir);
-			const scaffoldYamlPath = path.join(templatePath, "scaffold.yaml");
+			const templatePath = node_path.default.join(this.templatesRootPath, templateDir);
+			const scaffoldYamlPath = node_path.default.join(templatePath, "scaffold.yaml");
 			if (await this.fileSystem.pathExists(scaffoldYamlPath)) try {
 				const scaffoldContent = await this.fileSystem.readFile(scaffoldYamlPath, "utf8");
-				const architectConfig = yaml.load(scaffoldContent);
+				const architectConfig = js_yaml.default.load(scaffoldContent);
 				if (architectConfig.boilerplate && Array.isArray(architectConfig.boilerplate)) {
 					for (const boilerplate of architectConfig.boilerplate) if (boilerplate.name?.includes(sourceTemplate)) return templateDir;
 				}
 			} catch (error) {
-				console.warn(`Failed to read scaffold.yaml at ${scaffoldYamlPath}:`, error);
+				require_logger.log.warn(`Failed to read scaffold.yaml at ${scaffoldYamlPath}:`, error);
 			}
 		}
 		return null;
@@ -2100,9 +2189,9 @@ var ScaffoldingMethodsService = class {
 		try {
 			const items = await this.fileSystem.readdir(this.templatesRootPath);
 			for (const item of items) {
-				const itemPath = path.join(this.templatesRootPath, item);
+				const itemPath = node_path.default.join(this.templatesRootPath, item);
 				if (!(await this.fileSystem.stat(itemPath)).isDirectory()) continue;
-				const scaffoldYamlPath = path.join(itemPath, "scaffold.yaml");
+				const scaffoldYamlPath = node_path.default.join(itemPath, "scaffold.yaml");
 				if (await this.fileSystem.pathExists(scaffoldYamlPath)) {
 					templateDirs.push(item);
 					continue;
@@ -2110,20 +2199,20 @@ var ScaffoldingMethodsService = class {
 				try {
 					const subItems = await this.fileSystem.readdir(itemPath);
 					for (const subItem of subItems) {
-						const subItemPath = path.join(itemPath, subItem);
+						const subItemPath = node_path.default.join(itemPath, subItem);
 						if (!(await this.fileSystem.stat(subItemPath)).isDirectory()) continue;
-						const subScaffoldYamlPath = path.join(subItemPath, "scaffold.yaml");
+						const subScaffoldYamlPath = node_path.default.join(subItemPath, "scaffold.yaml");
 						if (await this.fileSystem.pathExists(subScaffoldYamlPath)) {
-							const relativePath = path.join(item, subItem);
+							const relativePath = node_path.default.join(item, subItem);
 							templateDirs.push(relativePath);
 						}
 					}
 				} 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;
 	}
@@ -2135,16 +2224,16 @@ 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 import("./ScaffoldService-CDhYAUrp.js")).ScaffoldService;
-		const ScaffoldConfigLoader$1 = (await import("./ScaffoldConfigLoader-DhthV6xq.js")).ScaffoldConfigLoader;
-		const VariableReplacementService$1 = (await import("./VariableReplacementService-CrxFJrqU.js")).VariableReplacementService;
-		const TemplateService$1 = (await import("./TemplateService-PmTU3_On.js")).TemplateService;
+		const ScaffoldService$1 = (await Promise.resolve().then(() => require("./ScaffoldService-CEJt8Yw4.js"))).ScaffoldService;
+		const ScaffoldConfigLoader$1 = (await Promise.resolve().then(() => require("./ScaffoldConfigLoader-BhrrsLya.js"))).ScaffoldConfigLoader;
+		const VariableReplacementService$1 = (await Promise.resolve().then(() => require("./VariableReplacementService-BLwdHUSz.js"))).VariableReplacementService;
+		const TemplateService$1 = (await Promise.resolve().then(() => require("./TemplateService-Z2SW_58N.js"))).TemplateService;
 		const templateService = new TemplateService$1();
 		const scaffoldConfigLoader = new ScaffoldConfigLoader$1(this.fileSystem, templateService);
 		const variableReplacer = new VariableReplacementService$1(this.fileSystem, templateService);
 		const scaffoldService = new ScaffoldService$1(this.fileSystem, scaffoldConfigLoader, variableReplacer, this.templatesRootPath);
-		const absoluteProjectPath = path.resolve(projectPath);
-		const projectName = path.basename(absoluteProjectPath);
+		const absoluteProjectPath = node_path.default.resolve(projectPath);
+		const projectName = node_path.default.basename(absoluteProjectPath);
 		const result = await scaffoldService.useFeature({
 			projectPath: absoluteProjectPath,
 			templateFolder: scaffoldingMethods.templatePath,
@@ -2297,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 {
@@ -2378,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 {
@@ -2446,8 +2553,8 @@ Parameters:
 			const { file_path, content } = args;
 			if (!file_path) throw new Error("Missing required parameter: file_path");
 			if (content === void 0 || content === null) throw new Error("Missing required parameter: content");
-			const resolvedPath = path.isAbsolute(file_path) ? file_path : path.resolve(process.cwd(), file_path);
-			const dirPath = path.dirname(resolvedPath);
+			const resolvedPath = node_path.default.isAbsolute(file_path) ? file_path : node_path.default.resolve(process.cwd(), file_path);
+			const dirPath = node_path.default.dirname(resolvedPath);
 			await this.fileSystemService.ensureDir(dirPath);
 			await this.fileSystemService.writeFile(resolvedPath, content);
 			return { content: [{
@@ -2470,7 +2577,7 @@ Parameters:
 //#region src/server/index.ts
 function createServer(options = {}) {
 	const { adminEnabled = false } = options;
-	const templatesPath = TemplatesManager.findTemplatesPathSync();
+	const templatesPath = require_ScaffoldService.TemplatesManager.findTemplatesPathSync();
 	const listBoilerplatesTool = new ListBoilerplatesTool(templatesPath);
 	const useBoilerplateTool = new UseBoilerplateTool(templatesPath);
 	const listScaffoldingMethodsTool = new ListScaffoldingMethodsTool(templatesPath);
@@ -2483,7 +2590,7 @@ function createServer(options = {}) {
 	const generateFeatureScaffoldPrompt = adminEnabled ? new GenerateFeatureScaffoldPrompt() : null;
 	const scaffoldApplicationPrompt = new ScaffoldApplicationPrompt();
 	const scaffoldFeaturePrompt = new ScaffoldFeaturePrompt();
-	const server = new Server({
+	const server = new __modelcontextprotocol_sdk_server_index_js.Server({
 		name: "scaffold-mcp",
 		version: "1.0.0"
 	}, {
@@ -2547,18 +2654,13 @@ Example workflow for feature:
 			prompts: {}
 		}
 	});
-	server.setRequestHandler(ListToolsRequestSchema, async () => {
-		const listBoilerplateTool = listBoilerplatesTool.getDefinition();
-		const useBoilerplateToolDef = useBoilerplateTool.getDefinition();
-		const listScaffoldingMethodsToolDef = listScaffoldingMethodsTool.getDefinition();
-		const useScaffoldMethodToolDef = useScaffoldMethodTool.getDefinition();
-		const writeToFileToolDef = writeToFileTool.getDefinition();
+	server.setRequestHandler(__modelcontextprotocol_sdk_types_js.ListToolsRequestSchema, async () => {
 		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());
@@ -2567,7 +2669,7 @@ Example workflow for feature:
 		}
 		return { tools };
 	});
-	server.setRequestHandler(CallToolRequestSchema, async (request) => {
+	server.setRequestHandler(__modelcontextprotocol_sdk_types_js.CallToolRequestSchema, async (request) => {
 		const { name, arguments: args } = request.params;
 		if (name === ListBoilerplatesTool.TOOL_NAME) return await listBoilerplatesTool.execute(args || {});
 		if (name === UseBoilerplateTool.TOOL_NAME) return await useBoilerplateTool.execute(args || {});
@@ -2588,7 +2690,7 @@ Example workflow for feature:
 		}
 		throw new Error(`Unknown tool: ${name}`);
 	});
-	server.setRequestHandler(ListPromptsRequestSchema, async () => {
+	server.setRequestHandler(__modelcontextprotocol_sdk_types_js.ListPromptsRequestSchema, async () => {
 		const prompts = [];
 		prompts.push(scaffoldApplicationPrompt.getDefinition());
 		prompts.push(scaffoldFeaturePrompt.getDefinition());
@@ -2598,7 +2700,7 @@ Example workflow for feature:
 		}
 		return { prompts };
 	});
-	server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+	server.setRequestHandler(__modelcontextprotocol_sdk_types_js.GetPromptRequestSchema, async (request) => {
 		const { name, arguments: args } = request.params;
 		if (name === ScaffoldApplicationPrompt.PROMPT_NAME) return { messages: scaffoldApplicationPrompt.getMessages(args) };
 		if (name === ScaffoldFeaturePrompt.PROMPT_NAME) return { messages: scaffoldFeaturePrompt.getMessages(args) };
@@ -2618,24 +2720,30 @@ Example workflow for feature:
 //#endregion
 //#region src/transports/http.ts
 /**
-* Session manager for HTTP transports
+* HTTP session manager
 */
-var HttpSessionManager = class {
-	transports = /* @__PURE__ */ new Map();
+var HttpFullSessionManager = class {
+	sessions = /* @__PURE__ */ new Map();
 	getSession(sessionId) {
-		return this.transports.get(sessionId);
+		return this.sessions.get(sessionId);
 	}
-	setSession(sessionId, transport) {
-		this.transports.set(sessionId, transport);
+	setSession(sessionId, transport, server) {
+		this.sessions.set(sessionId, {
+			transport,
+			server
+		});
 	}
 	deleteSession(sessionId) {
-		this.transports.delete(sessionId);
+		const session = this.sessions.get(sessionId);
+		if (session) session.server.close();
+		this.sessions.delete(sessionId);
 	}
 	hasSession(sessionId) {
-		return this.transports.has(sessionId);
+		return this.sessions.has(sessionId);
 	}
 	clear() {
-		this.transports.clear();
+		for (const session of this.sessions.values()) session.server.close();
+		this.sessions.clear();
 	}
 };
 /**
@@ -2643,15 +2751,15 @@ var HttpSessionManager = class {
 * Provides stateful session management with resumability support
 */
 var HttpTransportHandler = class {
-	mcpServer;
+	serverFactory;
 	app;
 	server = null;
 	sessionManager;
 	config;
-	constructor(mcpServer, config) {
-		this.mcpServer = mcpServer;
-		this.app = express();
-		this.sessionManager = new HttpSessionManager();
+	constructor(serverFactory, config) {
+		this.serverFactory = typeof serverFactory === "function" ? serverFactory : () => serverFactory;
+		this.app = (0, express.default)();
+		this.sessionManager = new HttpFullSessionManager();
 		this.config = {
 			mode: config.mode,
 			port: config.port ?? 3e3,
@@ -2661,7 +2769,7 @@ var HttpTransportHandler = class {
 		this.setupRoutes();
 	}
 	setupMiddleware() {
-		this.app.use(express.json());
+		this.app.use(express.default.json());
 	}
 	setupRoutes() {
 		this.app.post("/mcp", async (req, res) => {
@@ -2683,18 +2791,20 @@ var HttpTransportHandler = class {
 	async handlePostRequest(req, res) {
 		const sessionId = req.headers["mcp-session-id"];
 		let transport;
-		if (sessionId && this.sessionManager.hasSession(sessionId)) transport = this.sessionManager.getSession(sessionId);
-		else if (!sessionId && isInitializeRequest(req.body)) {
-			transport = new StreamableHTTPServerTransport({
-				sessionIdGenerator: () => randomUUID(),
+		if (sessionId && this.sessionManager.hasSession(sessionId)) transport = this.sessionManager.getSession(sessionId).transport;
+		else if (!sessionId && (0, __modelcontextprotocol_sdk_types_js.isInitializeRequest)(req.body)) {
+			const mcpServer = this.serverFactory();
+			transport = new __modelcontextprotocol_sdk_server_streamableHttp_js.StreamableHTTPServerTransport({
+				sessionIdGenerator: () => (0, node_crypto.randomUUID)(),
+				enableJsonResponse: true,
 				onsessioninitialized: (sessionId$1) => {
-					this.sessionManager.setSession(sessionId$1, transport);
+					this.sessionManager.setSession(sessionId$1, transport, mcpServer);
 				}
 			});
 			transport.onclose = () => {
 				if (transport.sessionId) this.sessionManager.deleteSession(transport.sessionId);
 			};
-			await this.mcpServer.connect(transport);
+			await mcpServer.connect(transport);
 		} else {
 			res.status(400).json({
 				jsonrpc: "2.0",
@@ -2714,7 +2824,7 @@ var HttpTransportHandler = class {
 			res.status(400).send("Invalid or missing session ID");
 			return;
 		}
-		await this.sessionManager.getSession(sessionId).handleRequest(req, res);
+		await this.sessionManager.getSession(sessionId).transport.handleRequest(req, res);
 	}
 	async handleDeleteRequest(req, res) {
 		const sessionId = req.headers["mcp-session-id"];
@@ -2722,7 +2832,7 @@ var HttpTransportHandler = class {
 			res.status(400).send("Invalid or missing session ID");
 			return;
 		}
-		await this.sessionManager.getSession(sessionId).handleRequest(req, res);
+		await this.sessionManager.getSession(sessionId).transport.handleRequest(req, res);
 		this.sessionManager.deleteSession(sessionId);
 	}
 	async start() {
@@ -2805,7 +2915,7 @@ var SseTransportHandler = class {
 	config;
 	constructor(serverFactory, config) {
 		this.serverFactory = typeof serverFactory === "function" ? serverFactory : () => serverFactory;
-		this.app = express();
+		this.app = (0, express.default)();
 		this.sessionManager = new SseSessionManager();
 		this.config = {
 			mode: config.mode,
@@ -2816,7 +2926,7 @@ var SseTransportHandler = class {
 		this.setupRoutes();
 	}
 	setupMiddleware() {
-		this.app.use(express.json());
+		this.app.use(express.default.json());
 	}
 	setupRoutes() {
 		this.app.get("/sse", async (req, res) => {
@@ -2835,7 +2945,7 @@ var SseTransportHandler = class {
 	async handleSseConnection(_req, res) {
 		try {
 			const mcpServer = this.serverFactory();
-			const transport = new SSEServerTransport("/messages", res);
+			const transport = new __modelcontextprotocol_sdk_server_sse_js.SSEServerTransport("/messages", res);
 			this.sessionManager.setSession(transport.sessionId, transport, mcpServer);
 			res.on("close", () => {
 				this.sessionManager.deleteSession(transport.sessionId);
@@ -2918,7 +3028,7 @@ var StdioTransportHandler = class {
 		this.server = server;
 	}
 	async start() {
-		this.transport = new StdioServerTransport();
+		this.transport = new __modelcontextprotocol_sdk_server_stdio_js.StdioServerTransport();
 		await this.server.connect(this.transport);
 		console.error("Scaffolding MCP server started on stdio");
 	}
@@ -2966,32 +3076,22 @@ async function startServer(handler) {
 /**
 * MCP Serve command
 */
-const mcpServeCommand = new Command("mcp-serve").description("Start MCP server with specified transport").option("-t, --type <type>", "Transport type: stdio, http, or sse", "stdio").option("-p, --port <port>", "Port to listen on (http/sse only)", (val) => parseInt(val, 10), 3e3).option("--host <host>", "Host to bind to (http/sse only)", "localhost").option("--admin-enable", "Enable admin tools (generate-boilerplate)", false).action(async (options) => {
+const mcpServeCommand = new commander.Command("mcp-serve").description("Start MCP server with specified transport").option("-t, --type <type>", "Transport type: stdio, http, or sse", "stdio").option("-p, --port <port>", "Port to listen on (http/sse only)", (val) => parseInt(val, 10), 3e3).option("--host <host>", "Host to bind to (http/sse only)", "localhost").option("--admin-enable", "Enable admin tools (generate-boilerplate)", false).action(async (options) => {
 	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 server = createServer(serverOptions);
-			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(server, 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);
 		}
@@ -3003,33 +3103,30 @@ const mcpServeCommand = new Command("mcp-serve").description("Start MCP server w
 
 //#endregion
 //#region src/cli/scaffold.ts
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const templatesDir = path.resolve(__dirname, "../../../../templates");
 /**
 * Scaffold CLI command
 */
-const scaffoldCommand = new Command("scaffold").description("Add features to existing projects");
+const scaffoldCommand = new commander.Command("scaffold").description("Add features to existing projects");
 scaffoldCommand.command("list <projectPath>").description("List available scaffolding methods for a project").action(async (projectPath) => {
 	try {
-		const absolutePath = path.resolve(projectPath);
-		if (!fs$1.existsSync(path.join(absolutePath, "project.json"))) {
+		const absolutePath = node_path.default.resolve(projectPath);
+		if (!fs_extra.existsSync(node_path.default.join(absolutePath, "project.json"))) {
 			messages.error(`No project.json found in ${absolutePath}`);
 			messages.hint("Make sure you are in a valid project directory");
 			process.exit(1);
 		}
-		const fileSystemService = new FileSystemService();
-		const methods = (await new ScaffoldingMethodsService(fileSystemService, templatesDir).listScaffoldingMethods(absolutePath)).methods;
+		const templatesDir = await require_ScaffoldService.TemplatesManager.findTemplatesPath();
+		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);
@@ -3038,8 +3135,8 @@ scaffoldCommand.command("list <projectPath>").description("List available scaffo
 });
 scaffoldCommand.command("add <featureName>").description("Add a feature to an existing project").option("-p, --project <path>", "Project path", process.cwd()).option("-v, --vars <json>", "JSON string containing variables for the feature").option("--verbose", "Enable verbose logging").action(async (featureName, options) => {
 	try {
-		const projectPath = path.resolve(options.project);
-		if (!fs$1.existsSync(path.join(projectPath, "project.json"))) {
+		const projectPath = node_path.default.resolve(options.project);
+		if (!fs_extra.existsSync(node_path.default.join(projectPath, "project.json"))) {
 			messages.error(`No project.json found in ${projectPath}`);
 			messages.hint("Make sure you are in a valid project directory");
 			process.exit(1);
@@ -3052,14 +3149,14 @@ scaffoldCommand.command("add <featureName>").description("Add a feature to an ex
 			messages.hint("Example: --vars '{\"componentName\": \"UserProfile\", \"description\": \"User profile component\"}'");
 			process.exit(1);
 		}
-		const fileSystemService = new FileSystemService();
-		const scaffoldingMethodsService = new ScaffoldingMethodsService(fileSystemService, templatesDir);
+		const templatesDir = await require_ScaffoldService.TemplatesManager.findTemplatesPath();
+		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 : [];
@@ -3071,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,
@@ -3089,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);
@@ -3112,28 +3209,28 @@ scaffoldCommand.command("add <featureName>").description("Add a feature to an ex
 });
 scaffoldCommand.command("info <featureName>").description("Show detailed information about a scaffold method").option("-p, --project <path>", "Project path", process.cwd()).action(async (featureName, options) => {
 	try {
-		const projectPath = path.resolve(options.project);
-		if (!fs$1.existsSync(path.join(projectPath, "project.json"))) {
+		const projectPath = node_path.default.resolve(options.project);
+		if (!fs_extra.existsSync(node_path.default.join(projectPath, "project.json"))) {
 			messages.error(`❌ No project.json found in ${projectPath}`);
 			process.exit(1);
 		}
-		const fileSystemService = new FileSystemService();
-		const method = (await new ScaffoldingMethodsService(fileSystemService, templatesDir).listScaffoldingMethods(projectPath)).methods.find((m) => m.name === featureName);
+		const templatesDir = await require_ScaffoldService.TemplatesManager.findTemplatesPath();
+		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) {
@@ -3148,7 +3245,7 @@ scaffoldCommand.command("info <featureName>").description("Show detailed informa
 * Main entry point
 */
 async function main() {
-	const program = new Command();
+	const program = new commander.Command();
 	program.name("scaffold-mcp").description("MCP server for scaffolding applications with boilerplate templates").version("1.0.0");
 	program.addCommand(mcpServeCommand);
 	program.addCommand(boilerplateCommand);
@@ -3159,5 +3256,4 @@ async function main() {
 }
 main();
 
-//#endregion
-export {  };
+//#endregion