@agiflowai/scaffold-mcp 0.2.0 → 0.3.1

package/dist/index.js

@@ -1,28 +1,41 @@
 #!/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 { exec } from "node:child_process";
-import * as path$1 from "node:path";
-import path from "node:path";
-import { promisify } from "node:util";
-import * as fs$1 from "fs-extra";
-import fs from "fs-extra";
-import chalk from "chalk";
-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";
+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');
+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 __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/console.ts
 /**
@@ -30,34 +43,34 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 */
 const logger = {
 	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();
@@ -82,7 +95,8 @@ const icons = {
 	download: "=�",
 	upload: "=�",
 	gear: "�",
-	clipboard: "=�"
+	clipboard: "=�",
+	skip: "⏭"
 };
 /**
 * Themed message helpers
@@ -135,15 +149,98 @@ const sections = {
 	}
 };
 
+//#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
-const execAsync = promisify(exec);
 /**
 * 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;
@@ -151,25 +248,27 @@ 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));
+		await fs_extra.ensureDir(node_path.default.dirname(targetFolder));
+		const parsedUrl = parseGitHubUrl(templateUrl);
 		try {
-			await execAsync(`git clone ${templateUrl} "${targetFolder}"`);
-			const gitFolder = path.join(targetFolder, ".git");
-			if (await fs$1.pathExists(gitFolder)) await fs$1.remove(gitFolder);
+			if (parsedUrl.isSubdirectory && parsedUrl.branch && parsedUrl.subdirectory) {
+				logger.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")];
+			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)) {
+			for (const configFile of configFiles) if (await fs_extra.pathExists(configFile)) {
 				logger.header(`\n${icons.config} Configuration file found:`);
-				logger.indent(path.basename(configFile));
+				logger.indent(node_path.default.basename(configFile));
 				hasConfig = true;
 				break;
 			}
@@ -194,29 +293,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);
 	}
 };
 
@@ -228,11 +327,11 @@ 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);
+		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);
 	}
 	/**
 	* Scans all scaffold.yaml files and returns available boilerplates
@@ -241,10 +340,10 @@ 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`);
@@ -273,15 +372,15 @@ 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;
+				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);
 				}
 			}
@@ -366,13 +465,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}`;
 				});
@@ -389,11 +488,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,
@@ -402,7 +501,7 @@ 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}`);
 		}
@@ -411,14 +510,14 @@ var BoilerplateService = class {
 
 //#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 templatesDir = await require_ScaffoldService.TemplatesManager.findTemplatesPath();
+		const { boilerplates } = await new BoilerplateService(templatesDir).listBoilerplates();
 		if (boilerplates.length === 0) {
 			messages.warning("No boilerplate templates found.");
 			return;
@@ -439,7 +538,8 @@ 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 templatesDir = await require_ScaffoldService.TemplatesManager.findTemplatesPath();
+		const boilerplateService = new BoilerplateService(templatesDir);
 		let variables = {};
 		if (options.vars) try {
 			variables = JSON.parse(options.vars);
@@ -498,7 +598,8 @@ 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 templatesDir = await require_ScaffoldService.TemplatesManager.findTemplatesPath();
+		const bp = await new BoilerplateService(templatesDir).getBoilerplate(boilerplateName);
 		if (!bp) {
 			messages.error(`Boilerplate '${boilerplateName}' not found.`);
 			process.exit(1);
@@ -522,36 +623,69 @@ 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 = {
+	owner: "AgiFlow",
+	repo: "aicode-toolkit",
+	branch: "main",
+	path: "templates"
+};
+/**
+* Download templates from GitHub repository
+*/
+async function downloadTemplates(templatesPath) {
+	try {
+		logger.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)`);
+		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)`);
+				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}`);
+		}
+		logger.success(`\n${icons.check} All templates downloaded successfully!`);
+	} catch (error) {
+		throw new Error(`Failed to download templates: ${error.message}`);
 	}
 }
 /**
 * Init command - initialize templates folder
 */
-const initCommand = new Command("init").description("Initialize templates folder structure at workspace root").action(async () => {
+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 = path.join(workspaceRoot, "templates");
+		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}`);
-		await fs$1.ensureDir(templatesPath);
-		await fs$1.ensureDir(path.join(templatesPath, "boilerplates"));
-		await fs$1.ensureDir(path.join(templatesPath, "scaffolds"));
-		await fs$1.writeFile(path.join(templatesPath, "README.md"), `# Templates
+		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.
 
-## Structure
+## Templates
 
-- \`boilerplates/\` - Full project boilerplate templates
-- \`scaffolds/\` - Feature scaffolding methods for existing projects
+Templates are organized by framework/technology and include configuration files (\`scaffold.yaml\`) that define:
+- Boilerplates: Full project starter templates
+- Features: Code scaffolding methods for adding new features to existing projects
 
-## Adding Templates
+## Adding More Templates
 
 Use the \`add\` command to add templates from remote repositories:
 
@@ -559,31 +693,38 @@ Use the \`add\` command to add templates from remote repositories:
 scaffold-mcp add --name my-template --url https://github.com/user/template
 \`\`\`
 
-## Creating Custom Templates
+Or add templates from subdirectories:
 
-### Boilerplate Template Structure
+\`\`\`bash
+scaffold-mcp add --name nextjs-template --url https://github.com/user/repo/tree/main/templates/nextjs
+\`\`\`
 
-Each boilerplate should have:
-- \`boilerplate.yaml\` - Configuration file
-- Template files with variable placeholders using Liquid syntax (\`{{ variableName }}\`)
+## Creating Custom Templates
 
-### Scaffold Method Structure
+Each template should have a \`scaffold.yaml\` configuration file defining:
+- \`boilerplate\`: Array of boilerplate configurations
+- \`features\`: Array of feature scaffold configurations
 
-Each scaffold method should have:
-- \`scaffold.yaml\` - Configuration file
-- Template files organized by project type
+Template files use Liquid syntax for variable placeholders: \`{{ variableName }}\`
 
-See documentation for more details on template creation.
+See existing templates for examples and documentation for more details.
 `);
-		logger.success(`${icons.check} Templates folder initialized successfully!`);
-		logger.header(`\n${icons.folder} Created structure:`);
-		logger.indent(`${templatesPath}/`);
-		logger.indent(`├── boilerplates/`);
-		logger.indent(`├── scaffolds/`);
-		logger.indent(`└── README.md`);
-		sections.nextSteps([`Add templates using: scaffold-mcp add --name <name> --url <url>`, `Or manually create templates in ${templatesPath}/`]);
+		logger.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);
+		const nextSteps = [];
+		if (options.download === false) {
+			nextSteps.push(`Download templates: scaffold-mcp init --download`);
+			nextSteps.push(`Add templates manually: scaffold-mcp add --name <name> --url <url>`);
+		} else {
+			nextSteps.push(`List available boilerplates: scaffold-mcp boilerplate list`);
+			nextSteps.push(`Add more templates: scaffold-mcp add --name <name> --url <url>`);
+		}
+		sections.nextSteps(nextSteps);
 	} catch (error) {
-		logger.error(`${icons.cross} Error initializing templates folder:`, error);
+		messages.error(`Error initializing templates folder: ${error.message}`);
 		process.exit(1);
 	}
 });
@@ -1025,7 +1166,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) => {
@@ -1033,9 +1174,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,
@@ -1078,13 +1219,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 {
@@ -1115,7 +1256,7 @@ var BoilerplateGeneratorService = class {
 		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}`,
@@ -1127,43 +1268,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",
@@ -1525,7 +1666,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) => {
@@ -1533,9 +1674,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,
@@ -1578,13 +1719,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 {
@@ -1615,7 +1756,7 @@ var ScaffoldGeneratorService = class {
 		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}`,
@@ -1627,14 +1768,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);
 	}
 };
 
@@ -1759,9 +1900,7 @@ Best practices:
 - Use conditional includes with ?variableName=value for optional files
 - Use path mapping with -> when source and target paths differ
 - Use {{ variableName }} in target paths for dynamic file placement
-- Avoid wildcards unless you have a good reason
-
-See templates/nextjs-15/scaffold.yaml features section for examples.`,
+- Avoid wildcards unless you have a good reason`,
 						items: { type: "string" }
 					},
 					patterns: {
@@ -1891,22 +2030,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({
@@ -1953,11 +2092,11 @@ 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;
 				}
@@ -1976,9 +2115,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;
@@ -1986,11 +2125,11 @@ 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);
 						}
 					}
@@ -2011,16 +2150,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-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 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,
@@ -2322,8 +2461,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: [{
@@ -2346,7 +2485,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);
@@ -2359,7 +2498,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"
 	}, {
@@ -2423,7 +2562,7 @@ Example workflow for feature:
 			prompts: {}
 		}
 	});
-	server.setRequestHandler(ListToolsRequestSchema, async () => {
+	server.setRequestHandler(__modelcontextprotocol_sdk_types_js.ListToolsRequestSchema, async () => {
 		const listBoilerplateTool = listBoilerplatesTool.getDefinition();
 		const useBoilerplateToolDef = useBoilerplateTool.getDefinition();
 		const listScaffoldingMethodsToolDef = listScaffoldingMethodsTool.getDefinition();
@@ -2443,7 +2582,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 || {});
@@ -2464,7 +2603,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());
@@ -2474,7 +2613,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) };
@@ -2494,24 +2633,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();
 	}
 };
 /**
@@ -2519,15 +2664,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,
@@ -2537,7 +2682,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) => {
@@ -2559,18 +2704,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",
@@ -2590,7 +2737,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"];
@@ -2598,7 +2745,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() {
@@ -2681,7 +2828,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,
@@ -2692,7 +2839,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) => {
@@ -2711,7 +2858,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);
@@ -2794,7 +2941,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");
 	}
@@ -2842,7 +2989,7 @@ 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 };
@@ -2851,13 +2998,12 @@ const mcpServeCommand = new Command("mcp-serve").description("Start MCP server w
 			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);
+			const handler = new HttpTransportHandler(() => createServer(serverOptions), config);
 			await startServer(handler);
 		} else if (transportType === "sse") {
 			const config = {
@@ -2879,21 +3025,19 @@ 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 templatesDir = await require_ScaffoldService.TemplatesManager.findTemplatesPath();
 		const fileSystemService = new FileSystemService();
 		const methods = (await new ScaffoldingMethodsService(fileSystemService, templatesDir).listScaffoldingMethods(absolutePath)).methods;
 		if (methods.length === 0) {
@@ -2914,8 +3058,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);
@@ -2928,6 +3072,7 @@ 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 templatesDir = await require_ScaffoldService.TemplatesManager.findTemplatesPath();
 		const fileSystemService = new FileSystemService();
 		const scaffoldingMethodsService = new ScaffoldingMethodsService(fileSystemService, templatesDir);
 		const methods = (await scaffoldingMethodsService.listScaffoldingMethods(projectPath)).methods;
@@ -2988,11 +3133,12 @@ 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 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);
 		if (!method) {
@@ -3024,7 +3170,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);
@@ -3035,5 +3181,4 @@ async function main() {
 }
 main();
 
-//#endregion
-export {  };
+//#endregion