@agiflowai/scaffold-mcp 0.4.1 → 0.6.0

package/dist/index.cjs

@@ -1,30 +1,27 @@
 #!/usr/bin/env node
 const require_chunk = require('./chunk-CUT6urMc.cjs');
-const require_logger = require('./logger-DqgpBYuP.cjs');
-const require_ScaffoldConfigLoader = require('./ScaffoldConfigLoader-BrmvENTo.cjs');
-const require_ScaffoldService = require('./ScaffoldService-BtjrgKI1.cjs');
-const require_TemplateService = require('./TemplateService-B6UG6adf.cjs');
-const require_VariableReplacementService = require('./VariableReplacementService-DuI8K1r2.cjs');
+const require_ScaffoldConfigLoader = require('./ScaffoldConfigLoader-1Pcv9cxm.cjs');
+const require_ScaffoldService = require('./ScaffoldService-BgFWAOLQ.cjs');
+const require_TemplateService = require('./TemplateService-_KpkoLfZ.cjs');
+const require_VariableReplacementService = require('./VariableReplacementService-ClshNY_C.cjs');
 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 __agiflowai_aicode_utils = require("@agiflowai/aicode-utils");
 __agiflowai_aicode_utils = require_chunk.__toESM(__agiflowai_aicode_utils);
+let fs_extra = require("fs-extra");
+fs_extra = require_chunk.__toESM(fs_extra);
+let execa = require("execa");
+execa = require_chunk.__toESM(execa);
 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 __inquirer_prompts = require("@inquirer/prompts");
+__inquirer_prompts = require_chunk.__toESM(__inquirer_prompts);
 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");
@@ -41,7 +38,31 @@ let __modelcontextprotocol_sdk_server_stdio_js = require("@modelcontextprotocol/
 __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);
+/**
+* Execute a git command safely using execa to prevent command injection
+*/
+async function execGit(args, cwd) {
+	try {
+		await (0, execa.execa)("git", args, { cwd });
+	} catch (error) {
+		const execaError = error;
+		throw new Error(`Git command failed: ${execaError.stderr || execaError.message}`);
+	}
+}
+/**
+* Find the workspace root by searching upwards for .git folder
+* Returns null if no .git folder is found (indicating a new project setup is needed)
+*/
+async function findWorkspaceRoot(startPath = process.cwd()) {
+	let currentPath = node_path.default.resolve(startPath);
+	const rootPath = node_path.default.parse(currentPath).root;
+	while (true) {
+		const gitPath = node_path.default.join(currentPath, ".git");
+		if (await fs_extra.pathExists(gitPath)) return currentPath;
+		if (currentPath === rootPath) return null;
+		currentPath = node_path.default.dirname(currentPath);
+	}
+}
 /**
 * Parse GitHub URL to detect if it's a subdirectory
 * Supports formats:
@@ -81,14 +102,29 @@ function parseGitHubUrl(url) {
 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`);
+		await execGit(["init", tempFolder]);
+		await execGit([
+			"remote",
+			"add",
+			"origin",
+			repoUrl
+		], tempFolder);
+		await execGit([
+			"config",
+			"core.sparseCheckout",
+			"true"
+		], tempFolder);
 		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}`);
+		await execGit([
+			"pull",
+			"--depth=1",
+			"origin",
+			branch
+		], tempFolder);
 		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}'`);
+		if (await fs_extra.pathExists(targetFolder)) throw new Error(`Target folder already exists: ${targetFolder}`);
 		await fs_extra.move(sourceDir, targetFolder);
 		await fs_extra.remove(tempFolder);
 	} catch (error) {
@@ -100,7 +136,11 @@ async function cloneSubdirectory(repoUrl, branch, subdirectory, targetFolder) {
 * Clone entire repository
 */
 async function cloneRepository(repoUrl, targetFolder) {
-	await execAsync(`git clone ${repoUrl} "${targetFolder}"`);
+	await execGit([
+		"clone",
+		repoUrl,
+		targetFolder
+	]);
 	const gitFolder = node_path.default.join(targetFolder, ".git");
 	if (await fs_extra.pathExists(gitFolder)) await fs_extra.remove(gitFolder);
 }
@@ -123,172 +163,59 @@ async function fetchGitHubDirectoryContents(owner, repo, path$6, branch = "main"
 	}));
 }
 
-//#endregion
-//#region src/utils/print.ts
-/**
-* Themed console utilities for consistent CLI output
-*/
-const print = {
-	info: (message) => {
-		console.log(chalk.default.cyan(message));
-	},
-	success: (message) => {
-		console.log(chalk.default.green(message));
-	},
-	warning: (message) => {
-		console.log(chalk.default.yellow(message));
-	},
-	error: (message, error) => {
-		if (error) {
-			const errorMsg = error instanceof Error ? error.message : error;
-			console.error(chalk.default.red(message), errorMsg);
-		} else console.error(chalk.default.red(message));
-	},
-	debug: (message) => {
-		console.log(chalk.default.gray(message));
-	},
-	header: (message) => {
-		console.log(chalk.default.bold.cyan(message));
-	},
-	item: (message) => {
-		console.log(chalk.default.gray(`   - ${message}`));
-	},
-	indent: (message) => {
-		console.log(chalk.default.gray(`   ${message}`));
-	},
-	highlight: (message) => {
-		console.log(chalk.default.bold.green(message));
-	},
-	newline: () => {
-		console.log();
-	}
-};
-/**
-* Emoji icons for consistent visual markers
-*/
-const icons = {
-	rocket: "=�",
-	check: "",
-	cross: "L",
-	warning: "�",
-	info: "9",
-	package: "=�",
-	folder: "=�",
-	file: "📄",
-	config: "📝",
-	wrench: "🔧",
-	chart: "📊",
-	bulb: "💡",
-	download: "=�",
-	upload: "=�",
-	gear: "�",
-	clipboard: "=�",
-	skip: "⏭"
-};
-/**
-* Themed message helpers
-*/
-const messages = {
-	info: (message) => {
-		print.info(`${icons.info} ${message}`);
-	},
-	success: (message) => {
-		print.success(`${icons.check} ${message}`);
-	},
-	error: (message, error) => {
-		print.error(`${icons.cross} ${message}`, error);
-	},
-	warning: (message) => {
-		print.warning(`${icons.warning} ${message}`);
-	},
-	hint: (message) => {
-		print.warning(`${icons.bulb} ${message}`);
-	},
-	loading: (message) => {
-		print.info(`${icons.rocket} ${message}`);
-	}
-};
-/**
-* Section formatters
-*/
-const sections = {
-	header: (title) => {
-		print.newline();
-		print.header(`${title}`);
-		print.newline();
-	},
-	list: (title, items) => {
-		print.header(`\n${title}\n`);
-		items.forEach((item) => print.item(item));
-	},
-	nextSteps: (steps) => {
-		print.header(`\n${icons.clipboard} Next steps:`);
-		steps.forEach((step) => print.indent(step));
-	},
-	createdFiles: (files, maxShow = 10) => {
-		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) => {
-		print.warning(`\n${icons.warning} Warnings:`);
-		warnings.forEach((warning) => print.item(warning));
-	}
-};
-
 //#endregion
 //#region src/cli/add.ts
 /**
 * Add command - add a template to templates folder
 */
-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) => {
+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>", "Override templates folder path (uses toolkit.yaml config by default)").option("--type <type>", "Template type: boilerplate or scaffold", "boilerplate").action(async (options) => {
 	try {
-		const templatesPath = node_path.default.resolve(options.path);
+		const templatesPath = options.path ? node_path.default.resolve(options.path) : await __agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPath();
 		const templateType = options.type.toLowerCase();
 		const templateName = options.name;
 		const templateUrl = options.url;
 		if (templateType !== "boilerplate" && templateType !== "scaffold") {
-			messages.error("Invalid template type. Use: boilerplate or scaffold");
+			__agiflowai_aicode_utils.messages.error("Invalid template type. Use: boilerplate or scaffold");
 			process.exit(1);
 		}
 		const targetFolder = node_path.default.join(templatesPath, `${templateType}s`, templateName);
 		if (await fs_extra.pathExists(targetFolder)) {
-			messages.error(`Template '${templateName}' already exists at ${targetFolder}`);
+			__agiflowai_aicode_utils.messages.error(`Template '${templateName}' already exists at ${targetFolder}`);
 			process.exit(1);
 		}
-		print.info(`${icons.download} Downloading template '${templateName}' from ${templateUrl}...`);
+		__agiflowai_aicode_utils.print.info(`${__agiflowai_aicode_utils.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) {
-				print.info(`${icons.folder} Detected subdirectory: ${parsedUrl.subdirectory} (branch: ${parsedUrl.branch})`);
+				__agiflowai_aicode_utils.print.info(`${__agiflowai_aicode_utils.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!`);
-			print.header(`\n${icons.folder} Template location:`);
-			print.indent(targetFolder);
+			__agiflowai_aicode_utils.messages.success(`Template '${templateName}' added successfully!`);
+			__agiflowai_aicode_utils.print.header(`\n${__agiflowai_aicode_utils.icons.folder} Template location:`);
+			__agiflowai_aicode_utils.print.indent(targetFolder);
 			const configFiles = [node_path.default.join(targetFolder, "boilerplate.yaml"), node_path.default.join(targetFolder, "scaffold.yaml")];
 			let hasConfig = false;
 			for (const configFile of configFiles) if (await fs_extra.pathExists(configFile)) {
-				print.header(`\n${icons.config} Configuration file found:`);
-				print.indent(node_path.default.basename(configFile));
+				__agiflowai_aicode_utils.print.header(`\n${__agiflowai_aicode_utils.icons.config} Configuration file found:`);
+				__agiflowai_aicode_utils.print.indent(node_path.default.basename(configFile));
 				hasConfig = true;
 				break;
 			}
 			if (!hasConfig) {
-				messages.warning("Warning: No configuration file found (boilerplate.yaml or scaffold.yaml)");
-				print.indent("You may need to create one manually.");
+				__agiflowai_aicode_utils.messages.warning("Warning: No configuration file found (boilerplate.yaml or scaffold.yaml)");
+				__agiflowai_aicode_utils.print.indent("You may need to create one manually.");
 			}
-			sections.nextSteps([`Review the template in ${targetFolder}`, `Test it with: scaffold-mcp ${templateType} list`]);
+			__agiflowai_aicode_utils.sections.nextSteps([`Review the template in ${targetFolder}`, `Test it with: scaffold-mcp ${templateType} list`]);
 		} catch (error) {
-			if (error.message.includes("not found") || error.message.includes("command not found")) messages.error("git command not found. Please install git first.");
-			else if (error.message.includes("Authentication failed")) messages.error("Authentication failed. Make sure you have access to the repository.");
-			else if (error.message.includes("Repository not found")) messages.error("Repository not found. Check the URL and try again.");
-			else messages.error("Failed to clone repository:", error);
+			if (error.message.includes("not found") || error.message.includes("command not found")) __agiflowai_aicode_utils.messages.error("git command not found. Please install git first.");
+			else if (error.message.includes("Authentication failed")) __agiflowai_aicode_utils.messages.error("Authentication failed. Make sure you have access to the repository.");
+			else if (error.message.includes("Repository not found")) __agiflowai_aicode_utils.messages.error("Repository not found. Check the URL and try again.");
+			else __agiflowai_aicode_utils.messages.error("Failed to clone repository:", error);
 			process.exit(1);
 		}
 	} catch (error) {
-		messages.error("Error adding template:", error);
+		__agiflowai_aicode_utils.messages.error("Error adding template:", error);
 		process.exit(1);
 	}
 });
@@ -347,7 +274,7 @@ var BoilerplateService = class {
 				const scaffoldConfig = js_yaml.load(scaffoldContent);
 				if (scaffoldConfig.boilerplate) for (const boilerplate of scaffoldConfig.boilerplate) {
 					if (!boilerplate.targetFolder) {
-						require_logger.log.warn(`Skipping boilerplate '${boilerplate.name}' in ${templatePath}: targetFolder is required in scaffold.yaml`);
+						__agiflowai_aicode_utils.log.warn(`Skipping boilerplate '${boilerplate.name}' in ${templatePath}: targetFolder is required in scaffold.yaml`);
 						continue;
 					}
 					boilerplates.push({
@@ -361,7 +288,7 @@ var BoilerplateService = class {
 					});
 				}
 			} catch (error) {
-				require_logger.log.warn(`Failed to load scaffold.yaml for ${templatePath}:`, error);
+				__agiflowai_aicode_utils.log.warn(`Failed to load scaffold.yaml for ${templatePath}:`, error);
 			}
 		}
 		return { boilerplates };
@@ -390,7 +317,7 @@ var BoilerplateService = class {
 	* Executes a specific boilerplate with provided variables
 	*/
 	async useBoilerplate(request) {
-		const { boilerplateName, variables } = request;
+		const { boilerplateName, variables, monolith = false, targetFolderOverride } = request;
 		const boilerplateList = await this.listBoilerplates();
 		const boilerplate = boilerplateList.boilerplates.find((b) => b.name === boilerplateName);
 		if (!boilerplate) return {
@@ -408,11 +335,12 @@ var BoilerplateService = class {
 			message: "Missing required parameter: packageName or appName"
 		};
 		const folderName = packageName.includes("/") ? packageName.split("/")[1] : packageName;
+		const targetFolder = targetFolderOverride || (monolith ? "." : boilerplate.target_folder);
 		try {
 			const result = await this.scaffoldService.useBoilerplate({
 				projectName: folderName,
 				packageName,
-				targetFolder: boilerplate.target_folder,
+				targetFolder,
 				templateFolder: boilerplate.template_path,
 				boilerplateName,
 				variables: {
@@ -423,7 +351,11 @@ var BoilerplateService = class {
 				}
 			});
 			if (!result.success) return result;
-			this.ensureProjectJsonSourceTemplate(boilerplate.target_folder, folderName, boilerplate.template_path);
+			if (monolith) await __agiflowai_aicode_utils.ProjectConfigResolver.createToolkitYaml(boilerplate.template_path);
+			else {
+				const projectPath = node_path.join(targetFolder, folderName);
+				await __agiflowai_aicode_utils.ProjectConfigResolver.createProjectJson(projectPath, folderName, boilerplate.template_path);
+			}
 			return {
 				success: result.success,
 				message: result.message,
@@ -481,29 +413,6 @@ var BoilerplateService = class {
 			};
 		}
 	}
-	/**
-	* Ensures project.json has sourceTemplate field
-	* If project.json exists, updates it; otherwise creates a new one
-	*/
-	ensureProjectJsonSourceTemplate(targetFolder, projectName, sourceTemplate) {
-		const projectJsonPath = node_path.join(targetFolder, projectName, "project.json");
-		try {
-			let projectJson;
-			if (fs_extra.existsSync(projectJsonPath)) {
-				const content = fs_extra.readFileSync(projectJsonPath, "utf8");
-				projectJson = JSON.parse(content);
-			} else projectJson = {
-				name: projectName,
-				$schema: "../../node_modules/nx/schemas/project-schema.json",
-				sourceRoot: `${targetFolder}/${projectName}`,
-				projectType: "application"
-			};
-			projectJson.sourceTemplate = sourceTemplate;
-			fs_extra.writeFileSync(projectJsonPath, `${JSON.stringify(projectJson, null, 2)}\n`, "utf8");
-		} catch (error) {
-			require_logger.log.warn(`Failed to update project.json with sourceTemplate: ${error}`);
-		}
-	}
 };
 
 //#endregion
@@ -516,78 +425,85 @@ boilerplateCommand.command("list").description("List all available boilerplate t
 	try {
 		const { boilerplates } = await new BoilerplateService(await __agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPath()).listBoilerplates();
 		if (boilerplates.length === 0) {
-			messages.warning("No boilerplate templates found.");
+			__agiflowai_aicode_utils.messages.warning("No boilerplate templates found.");
 			return;
 		}
-		print.header(`\n${icons.package} Available Boilerplate Templates:\n`);
+		__agiflowai_aicode_utils.print.header(`\n${__agiflowai_aicode_utils.icons.package} Available Boilerplate Templates:\n`);
 		for (const bp of boilerplates) {
-			print.highlight(`  ${bp.name}`);
-			print.debug(`    ${bp.description}`);
-			print.debug(`    Target: ${bp.target_folder}`);
+			__agiflowai_aicode_utils.print.highlight(`  ${bp.name}`);
+			__agiflowai_aicode_utils.print.debug(`    ${bp.description}`);
+			__agiflowai_aicode_utils.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) print.debug(`    Required: ${required.join(", ")}`);
-			print.newline();
+			if (required && required.length > 0) __agiflowai_aicode_utils.print.debug(`    Required: ${required.join(", ")}`);
+			__agiflowai_aicode_utils.print.newline();
 		}
 	} catch (error) {
-		messages.error("Error listing boilerplates:", error);
+		__agiflowai_aicode_utils.messages.error("Error listing boilerplates:", error);
 		process.exit(1);
 	}
 });
-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) => {
+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("-m, --monolith", "Create as monolith project at workspace root with toolkit.yaml (default: false, creates as monorepo with project.json)").option("-t, --target-folder <path>", "Override target folder (defaults to boilerplate targetFolder for monorepo, workspace root for monolith)").option("--verbose", "Enable verbose logging").action(async (boilerplateName, options) => {
 	try {
 		const boilerplateService = new BoilerplateService(await __agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPath());
 		let variables = {};
 		if (options.vars) try {
 			variables = JSON.parse(options.vars);
 		} catch (error) {
-			messages.error("Error parsing variables JSON:", error);
-			messages.hint("Example: --vars '{\"appName\": \"my-app\", \"description\": \"My application\"}'");
+			__agiflowai_aicode_utils.messages.error("Error parsing variables JSON:", error);
+			__agiflowai_aicode_utils.messages.hint("Example: --vars '{\"appName\": \"my-app\", \"description\": \"My application\"}'");
 			process.exit(1);
 		}
 		const boilerplate = await boilerplateService.getBoilerplate(boilerplateName);
 		if (!boilerplate) {
 			const { boilerplates } = await boilerplateService.listBoilerplates();
-			messages.error(`Boilerplate '${boilerplateName}' not found.`);
-			print.warning(`Available boilerplates: ${boilerplates.map((b) => b.name).join(", ")}`);
+			__agiflowai_aicode_utils.messages.error(`Boilerplate '${boilerplateName}' not found.`);
+			__agiflowai_aicode_utils.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 : [];
 		const missing = required.filter((key) => !variables[key]);
 		if (missing.length > 0) {
-			messages.error(`Missing required variables: ${missing.join(", ")}`);
-			messages.hint(`Use --vars with a JSON object containing: ${missing.join(", ")}`);
+			__agiflowai_aicode_utils.messages.error(`Missing required variables: ${missing.join(", ")}`);
+			__agiflowai_aicode_utils.messages.hint(`Use --vars with a JSON object containing: ${missing.join(", ")}`);
 			const exampleVars = {};
 			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}>`;
-			print.debug(`Example: scaffold-mcp boilerplate create ${boilerplateName} --vars '${JSON.stringify(exampleVars)}'`);
+			__agiflowai_aicode_utils.print.debug(`Example: scaffold-mcp boilerplate create ${boilerplateName} --vars '${JSON.stringify(exampleVars)}'`);
 			process.exit(1);
 		}
 		if (options.verbose) {
-			print.info(`${icons.wrench} Boilerplate: ${boilerplateName}`);
-			print.info(`${icons.chart} Variables: ${JSON.stringify(variables, null, 2)}`);
+			__agiflowai_aicode_utils.print.info(`${__agiflowai_aicode_utils.icons.wrench} Boilerplate: ${boilerplateName}`);
+			__agiflowai_aicode_utils.print.info(`${__agiflowai_aicode_utils.icons.chart} Variables: ${JSON.stringify(variables, null, 2)}`);
 		}
-		messages.loading(`Creating project from boilerplate '${boilerplateName}'...`);
+		__agiflowai_aicode_utils.messages.loading(`Creating project from boilerplate '${boilerplateName}'...`);
 		const result = await boilerplateService.useBoilerplate({
 			boilerplateName,
-			variables
+			variables,
+			monolith: options.monolith,
+			targetFolderOverride: options.targetFolder
 		});
 		if (result.success) {
-			messages.success("Project created successfully!");
-			print.info(result.message);
-			if (result.createdFiles && result.createdFiles.length > 0) sections.createdFiles(result.createdFiles);
+			__agiflowai_aicode_utils.messages.success("Project created successfully!");
+			__agiflowai_aicode_utils.print.info(result.message);
+			if (result.createdFiles && result.createdFiles.length > 0) __agiflowai_aicode_utils.sections.createdFiles(result.createdFiles);
 			const projectName = variables.appName || variables.packageName;
-			if (projectName) sections.nextSteps([
-				`cd ${boilerplate.target_folder}/${projectName}`,
-				"pnpm install",
-				"pnpm dev"
-			]);
+			if (projectName) {
+				const targetFolder = options.targetFolder || (options.monolith ? "." : boilerplate.target_folder);
+				const projectPath = options.monolith ? "." : `${targetFolder}/${projectName}`;
+				const steps = projectPath === "." ? ["pnpm install", "pnpm dev"] : [
+					`cd ${projectPath}`,
+					"pnpm install",
+					"pnpm dev"
+				];
+				__agiflowai_aicode_utils.sections.nextSteps(steps);
+			}
 		} else {
-			messages.error(`Failed to create project: ${result.message}`);
+			__agiflowai_aicode_utils.messages.error(`Failed to create project: ${result.message}`);
 			process.exit(1);
 		}
 	} catch (error) {
-		messages.error("Error creating project:", error);
+		__agiflowai_aicode_utils.messages.error("Error creating project:", error);
 		if (options.verbose) console.error("Stack trace:", error.stack);
 		process.exit(1);
 	}
@@ -596,18 +512,18 @@ boilerplateCommand.command("info <boilerplateName>").description("Show detailed
 	try {
 		const bp = await new BoilerplateService(await __agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPath()).getBoilerplate(boilerplateName);
 		if (!bp) {
-			messages.error(`Boilerplate '${boilerplateName}' not found.`);
+			__agiflowai_aicode_utils.messages.error(`Boilerplate '${boilerplateName}' not found.`);
 			process.exit(1);
 		}
-		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:`);
+		__agiflowai_aicode_utils.print.header(`\n${__agiflowai_aicode_utils.icons.package} Boilerplate: ${bp.name}\n`);
+		__agiflowai_aicode_utils.print.debug(`Description: ${bp.description}`);
+		__agiflowai_aicode_utils.print.debug(`Template Path: ${bp.template_path}`);
+		__agiflowai_aicode_utils.print.debug(`Target Folder: ${bp.target_folder}`);
+		__agiflowai_aicode_utils.print.header(`\n${__agiflowai_aicode_utils.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);
+		if (bp.includes && bp.includes.length > 0) __agiflowai_aicode_utils.sections.list(`${__agiflowai_aicode_utils.icons.folder} Included Files:`, bp.includes);
 	} catch (error) {
-		messages.error("Error getting boilerplate info:", error);
+		__agiflowai_aicode_utils.messages.error("Error getting boilerplate info:", error);
 		process.exit(1);
 	}
 });
@@ -615,16 +531,14 @@ boilerplateCommand.command("info <boilerplateName>").description("Show detailed
 //#endregion
 //#region src/cli/init.ts
 /**
-* Find the workspace root by searching upwards for .git folder
+* Execute git init safely using execa to prevent command injection
 */
-async function findWorkspaceRoot(startPath = process.cwd()) {
-	let currentPath = node_path.default.resolve(startPath);
-	const rootPath = node_path.default.parse(currentPath).root;
-	while (true) {
-		const gitPath = node_path.default.join(currentPath, ".git");
-		if (await fs_extra.pathExists(gitPath)) return currentPath;
-		if (currentPath === rootPath) return process.cwd();
-		currentPath = node_path.default.dirname(currentPath);
+async function gitInit(projectPath) {
+	try {
+		await (0, execa.execa)("git", ["init", projectPath]);
+	} catch (error) {
+		const execaError = error;
+		throw new Error(`Git init failed: ${execaError.stderr || execaError.message}`);
 	}
 }
 const DEFAULT_TEMPLATE_REPO = {
@@ -634,28 +548,147 @@ const DEFAULT_TEMPLATE_REPO = {
 	path: "templates"
 };
 /**
+* Interactive setup for new projects
+* Prompts user for project details when no .git folder is found
+* @param providedName - Optional project name from CLI argument
+* @param providedProjectType - Optional project type from CLI argument
+*/
+async function setupNewProject(providedName, providedProjectType) {
+	__agiflowai_aicode_utils.print.header(`\n${__agiflowai_aicode_utils.icons.rocket} New Project Setup`);
+	__agiflowai_aicode_utils.print.info("No Git repository detected. Let's set up a new project!\n");
+	let projectName;
+	const reservedNames = [
+		".",
+		"..",
+		"CON",
+		"PRN",
+		"AUX",
+		"NUL",
+		"COM1",
+		"COM2",
+		"COM3",
+		"COM4",
+		"COM5",
+		"COM6",
+		"COM7",
+		"COM8",
+		"COM9",
+		"LPT1",
+		"LPT2",
+		"LPT3",
+		"LPT4",
+		"LPT5",
+		"LPT6",
+		"LPT7",
+		"LPT8",
+		"LPT9"
+	];
+	const validateProjectName = (value) => {
+		const trimmed = value.trim();
+		if (!trimmed) return "Project name is required";
+		if (!/^[a-zA-Z0-9]/.test(trimmed)) return "Project name must start with a letter or number";
+		if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(trimmed)) return "Project name can only contain letters, numbers, hyphens, and underscores";
+		if (reservedNames.includes(trimmed.toUpperCase())) return "Project name uses a reserved name";
+		return true;
+	};
+	if (providedName) {
+		const trimmedName = providedName.trim();
+		const validationResult = validateProjectName(trimmedName);
+		if (validationResult !== true) throw new Error(validationResult);
+		projectName = trimmedName;
+		__agiflowai_aicode_utils.print.info(`Project name: ${projectName}`);
+	} else projectName = await (0, __inquirer_prompts.input)({
+		message: "Enter your project name:",
+		validate: validateProjectName
+	});
+	let projectType;
+	if (providedProjectType) {
+		if (providedProjectType !== __agiflowai_aicode_utils.ProjectType.MONOLITH && providedProjectType !== __agiflowai_aicode_utils.ProjectType.MONOREPO) throw new Error(`Invalid project type '${providedProjectType}'. Must be '${__agiflowai_aicode_utils.ProjectType.MONOLITH}' or '${__agiflowai_aicode_utils.ProjectType.MONOREPO}'`);
+		projectType = providedProjectType;
+		__agiflowai_aicode_utils.print.info(`Project type: ${projectType}`);
+	} else projectType = await (0, __inquirer_prompts.select)({
+		message: "Select project type:",
+		choices: [{
+			name: "Monolith - Single application structure",
+			value: __agiflowai_aicode_utils.ProjectType.MONOLITH,
+			description: "Traditional single-application project structure"
+		}, {
+			name: "Monorepo - Multiple packages/apps in one repository",
+			value: __agiflowai_aicode_utils.ProjectType.MONOREPO,
+			description: "Multiple packages managed together (uses workspaces)"
+		}]
+	});
+	const hasExistingRepo = await (0, __inquirer_prompts.confirm)({
+		message: "Do you have an existing Git repository you want to use?",
+		default: false
+	});
+	const projectPath = node_path.default.join(process.cwd(), projectName.trim());
+	try {
+		await fs_extra.mkdir(projectPath, { recursive: false });
+		__agiflowai_aicode_utils.print.success(`${__agiflowai_aicode_utils.icons.check} Created project directory: ${projectPath}`);
+	} catch (error) {
+		if (error.code === "EEXIST") throw new Error(`Directory '${projectName}' already exists. Please choose a different name.`);
+		throw error;
+	}
+	if (hasExistingRepo) {
+		const repoUrl = await (0, __inquirer_prompts.input)({
+			message: "Enter Git repository URL:",
+			validate: (value) => {
+				if (!value.trim()) return "Repository URL is required";
+				if (!value.match(/^(https?:\/\/|git@)/)) return "Please enter a valid Git repository URL";
+				return true;
+			}
+		});
+		__agiflowai_aicode_utils.print.info(`${__agiflowai_aicode_utils.icons.download} Cloning repository...`);
+		try {
+			const parsed = parseGitHubUrl(repoUrl.trim());
+			if (parsed.isSubdirectory && parsed.branch && parsed.subdirectory) await cloneSubdirectory(parsed.repoUrl, parsed.branch, parsed.subdirectory, projectPath);
+			else await cloneRepository(parsed.repoUrl, projectPath);
+			__agiflowai_aicode_utils.print.success(`${__agiflowai_aicode_utils.icons.check} Repository cloned successfully`);
+		} catch (error) {
+			await fs_extra.remove(projectPath);
+			throw new Error(`Failed to clone repository: ${error.message}`);
+		}
+	} else if (await (0, __inquirer_prompts.confirm)({
+		message: "Initialize a new Git repository?",
+		default: true
+	})) {
+		__agiflowai_aicode_utils.print.info(`${__agiflowai_aicode_utils.icons.rocket} Initializing Git repository...`);
+		try {
+			await gitInit(projectPath);
+			__agiflowai_aicode_utils.print.success(`${__agiflowai_aicode_utils.icons.check} Git repository initialized`);
+		} catch (error) {
+			__agiflowai_aicode_utils.messages.warning(`Failed to initialize Git: ${error.message}`);
+		}
+	}
+	return {
+		projectPath,
+		projectType
+	};
+}
+/**
 * Download templates from GitHub repository
 */
 async function downloadTemplates(templatesPath) {
 	try {
-		print.info(`${icons.download} Fetching templates from ${DEFAULT_TEMPLATE_REPO.owner}/${DEFAULT_TEMPLATE_REPO.repo}...`);
+		__agiflowai_aicode_utils.print.info(`${__agiflowai_aicode_utils.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");
+			__agiflowai_aicode_utils.messages.warning("No templates found in repository");
 			return;
 		}
-		print.info(`${icons.folder} Found ${templateDirs.length} template(s)`);
+		__agiflowai_aicode_utils.print.info(`${__agiflowai_aicode_utils.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)) {
-				print.info(`${icons.skip} Skipping ${template.name} (already exists)`);
+				__agiflowai_aicode_utils.print.info(`${__agiflowai_aicode_utils.icons.skip} Skipping ${template.name} (already exists)`);
 				continue;
 			}
-			print.info(`${icons.download} Downloading ${template.name}...`);
+			__agiflowai_aicode_utils.print.info(`${__agiflowai_aicode_utils.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}`);
+			__agiflowai_aicode_utils.print.success(`${__agiflowai_aicode_utils.icons.check} Downloaded ${template.name}`);
 		}
-		print.success(`\n${icons.check} All templates downloaded successfully!`);
+		__agiflowai_aicode_utils.print.success(`\n${__agiflowai_aicode_utils.icons.check} All templates downloaded successfully!`);
 	} catch (error) {
 		throw new Error(`Failed to download templates: ${error.message}`);
 	}
@@ -663,11 +696,43 @@ async function downloadTemplates(templatesPath) {
 /**
 * Init command - initialize templates folder
 */
-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) => {
+const initCommand = new commander.Command("init").description("Initialize templates folder structure at workspace root or create new project").option("--no-download", "Skip downloading templates from repository").option("--path <path>", "Custom path for templates folder (relative to workspace root)").option("--name <name>", "Project name (for new projects)").option("--project-type <type>", "Project type: monolith or monorepo (for new projects)").action(async (options) => {
 	try {
-		const workspaceRoot = await findWorkspaceRoot();
-		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}`);
+		let workspaceRoot = await findWorkspaceRoot();
+		let projectType;
+		if (!workspaceRoot) {
+			const projectSetup = await setupNewProject(options.name, options.projectType);
+			workspaceRoot = projectSetup.projectPath;
+			projectType = projectSetup.projectType;
+			__agiflowai_aicode_utils.print.info(`\n${__agiflowai_aicode_utils.icons.folder} Project type: ${projectType}`);
+		}
+		let templatesPath = options.path ? node_path.default.join(workspaceRoot, options.path) : node_path.default.join(workspaceRoot, "templates");
+		if (await fs_extra.pathExists(templatesPath)) {
+			__agiflowai_aicode_utils.messages.warning(`\n⚠️  Templates folder already exists at: ${templatesPath}`);
+			if (await (0, __inquirer_prompts.confirm)({
+				message: "Do you want to use a different folder for templates?",
+				default: false
+			})) {
+				const alternateFolder = await (0, __inquirer_prompts.input)({
+					message: "Enter alternate folder name for templates:",
+					default: "my-templates",
+					validate: (value) => {
+						if (!value.trim()) return "Folder name is required";
+						if (!/^[a-zA-Z0-9_\-/]+$/.test(value)) return "Folder name can only contain letters, numbers, hyphens, underscores, and slashes";
+						return true;
+					}
+				});
+				templatesPath = node_path.default.join(workspaceRoot, alternateFolder.trim());
+				const toolkitConfig = {
+					templatesPath: alternateFolder.trim(),
+					projectType
+				};
+				__agiflowai_aicode_utils.print.info(`\n${__agiflowai_aicode_utils.icons.config} Creating toolkit.yaml with custom templates path...`);
+				await __agiflowai_aicode_utils.TemplatesManagerService.writeToolkitConfig(toolkitConfig, workspaceRoot);
+				__agiflowai_aicode_utils.print.success(`${__agiflowai_aicode_utils.icons.check} toolkit.yaml created`);
+			} else __agiflowai_aicode_utils.print.info(`\n${__agiflowai_aicode_utils.icons.info} Using existing templates folder`);
+		}
+		__agiflowai_aicode_utils.print.info(`\n${__agiflowai_aicode_utils.icons.rocket} Initializing templates folder at: ${templatesPath}`);
 		await fs_extra.ensureDir(templatesPath);
 		await fs_extra.writeFile(node_path.default.join(templatesPath, "README.md"), `# Templates
 
@@ -703,11 +768,11 @@ Template files use Liquid syntax for variable placeholders: \`{{ variableName }}
 
 See existing templates for examples and documentation for more details.
 `);
-		print.success(`${icons.check} Templates folder created!`);
+		__agiflowai_aicode_utils.print.success(`${__agiflowai_aicode_utils.icons.check} Templates folder created!`);
 		if (options.download !== false) await downloadTemplates(templatesPath);
-		else print.info(`${icons.skip} Skipping template download (use --download to enable)`);
-		print.header(`\n${icons.folder} Templates location:`);
-		print.indent(templatesPath);
+		else __agiflowai_aicode_utils.print.info(`${__agiflowai_aicode_utils.icons.skip} Skipping template download (use --download to enable)`);
+		__agiflowai_aicode_utils.print.header(`\n${__agiflowai_aicode_utils.icons.folder} Templates location:`);
+		__agiflowai_aicode_utils.print.indent(templatesPath);
 		const nextSteps = [];
 		if (options.download === false) {
 			nextSteps.push(`Download templates: scaffold-mcp init --download`);
@@ -716,9 +781,9 @@ See existing templates for examples and documentation for more details.
 			nextSteps.push(`List available boilerplates: scaffold-mcp boilerplate list`);
 			nextSteps.push(`Add more templates: scaffold-mcp add --name <name> --url <url>`);
 		}
-		sections.nextSteps(nextSteps);
+		__agiflowai_aicode_utils.sections.nextSteps(nextSteps);
 	} catch (error) {
-		messages.error(`Error initializing templates folder: ${error.message}`);
+		__agiflowai_aicode_utils.messages.error(`Error initializing templates folder: ${error.message}`);
 		process.exit(1);
 	}
 });
@@ -2110,11 +2175,7 @@ var ScaffoldingMethodsService = class {
 	}
 	async listScaffoldingMethods(projectPath) {
 		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 sourceTemplate = (await __agiflowai_aicode_utils.ProjectConfigResolver.resolveProjectConfig(absoluteProjectPath)).sourceTemplate;
 		const templatePath = await this.findTemplatePath(sourceTemplate);
 		if (!templatePath) throw new Error(`Template not found for sourceTemplate: ${sourceTemplate}`);
 		const fullTemplatePath = node_path.default.join(this.templatesRootPath, templatePath);
@@ -2177,7 +2238,7 @@ var ScaffoldingMethodsService = class {
 					for (const boilerplate of architectConfig.boilerplate) if (boilerplate.name?.includes(sourceTemplate)) return templateDir;
 				}
 			} catch (error) {
-				require_logger.log.warn(`Failed to read scaffold.yaml at ${scaffoldYamlPath}:`, error);
+				__agiflowai_aicode_utils.log.warn(`Failed to read scaffold.yaml at ${scaffoldYamlPath}:`, error);
 			}
 		}
 		return null;
@@ -2210,11 +2271,11 @@ var ScaffoldingMethodsService = class {
 						}
 					}
 				} catch (error) {
-					require_logger.log.warn(`Failed to read subdirectories in ${itemPath}:`, error);
+					__agiflowai_aicode_utils.log.warn(`Failed to read subdirectories in ${itemPath}:`, error);
 				}
 			}
 		} catch (error) {
-			require_logger.log.warn(`Failed to read templates root directory ${this.templatesRootPath}:`, error);
+			__agiflowai_aicode_utils.log.warn(`Failed to read templates root directory ${this.templatesRootPath}:`, error);
 		}
 		return templateDirs;
 	}
@@ -2226,10 +2287,10 @@ var ScaffoldingMethodsService = class {
 			const availableMethods = scaffoldingMethods.methods.map((m) => m.name).join(", ");
 			throw new Error(`Scaffold method '${scaffold_feature_name}' not found. Available methods: ${availableMethods}`);
 		}
-		const ScaffoldService$1 = (await Promise.resolve().then(() => require("./ScaffoldService-CkVFZBcb.cjs"))).ScaffoldService;
-		const ScaffoldConfigLoader$1 = (await Promise.resolve().then(() => require("./ScaffoldConfigLoader-DQMCLVGD.cjs"))).ScaffoldConfigLoader;
-		const VariableReplacementService$1 = (await Promise.resolve().then(() => require("./VariableReplacementService-CS_Uwxfu.cjs"))).VariableReplacementService;
-		const TemplateService$1 = (await Promise.resolve().then(() => require("./TemplateService-DFiUdYAi.cjs"))).TemplateService;
+		const ScaffoldService$1 = (await Promise.resolve().then(() => require("./ScaffoldService-BvD9WvRi.cjs"))).ScaffoldService;
+		const ScaffoldConfigLoader$1 = (await Promise.resolve().then(() => require("./ScaffoldConfigLoader-DzcV5a_c.cjs"))).ScaffoldConfigLoader;
+		const VariableReplacementService$1 = (await Promise.resolve().then(() => require("./VariableReplacementService-YUpL5nAC.cjs"))).VariableReplacementService;
+		const TemplateService$1 = (await Promise.resolve().then(() => require("./TemplateService-B5EZjPB0.cjs"))).TemplateService;
 		const templateService = new TemplateService$1();
 		const scaffoldConfigLoader = new ScaffoldConfigLoader$1(this.fileSystem, templateService);
 		const variableReplacer = new VariableReplacementService$1(this.fileSystem, templateService);
@@ -2280,7 +2341,7 @@ var ListScaffoldingMethodsTool = class ListScaffoldingMethodsTool {
 			description: `Lists all available scaffolding methods (features) that can be added to an existing project.
 
 This tool:
-- Reads the project's sourceTemplate from project.json
+- Reads the project's sourceTemplate from project.json (monorepo) or toolkit.yaml (monolith)
 - Returns available features for that template type
 - Provides variable schemas for each scaffolding method
 - Shows descriptions of what each method creates
@@ -2299,7 +2360,7 @@ Example methods might include:
 				type: "object",
 				properties: { projectPath: {
 					type: "string",
-					description: "Absolute path to the project directory containing project.json (e.g., \"apps/my-app\", \"backend/apis/my-api\", \"packages/my-package\")"
+					description: "Absolute path to the project directory (for monorepo: containing project.json; for monolith: workspace root with toolkit.yaml)"
 				} },
 				required: ["projectPath"],
 				additionalProperties: false
@@ -2349,14 +2410,17 @@ var UseBoilerplateTool = class UseBoilerplateTool {
 This tool will:
 - Generate all necessary files from the template
 - Replace template variables with provided values
-- Create the project in the appropriate monorepo directory
+- Create the project in the appropriate directory (monorepo or monolith)
 - Set up initial configuration files (package.json, tsconfig.json, etc.)
+- Create toolkit.yaml (monolith) or project.json (monorepo) with sourceTemplate
 
 IMPORTANT:
 - Always call \`list-boilerplates\` first to get the exact variable schema
 - Follow the schema exactly - required fields must be provided
 - Use kebab-case for project names (e.g., "my-new-app", not "MyNewApp")
-- The tool will validate all variables against the schema before proceeding`,
+- The tool will validate all variables against the schema before proceeding
+- For monolith projects, use monolith: true to create at workspace root
+- For monorepo projects, files are created in targetFolder/projectName`,
 			inputSchema: {
 				type: "object",
 				properties: {
@@ -2367,6 +2431,14 @@ IMPORTANT:
 					variables: {
 						type: "object",
 						description: "Variables object matching the boilerplate's variables_schema exactly"
+					},
+					monolith: {
+						type: "boolean",
+						description: "If true, creates project at workspace root with toolkit.yaml. If false or omitted, creates in targetFolder/projectName with project.json (monorepo mode)"
+					},
+					targetFolderOverride: {
+						type: "string",
+						description: "Optional override for target folder. If not provided, uses boilerplate targetFolder (monorepo) or workspace root (monolith)"
 					}
 				},
 				required: ["boilerplateName", "variables"],
@@ -2379,12 +2451,14 @@ IMPORTANT:
 	*/
 	async execute(args) {
 		try {
-			const { boilerplateName, variables } = args;
+			const { boilerplateName, variables, monolith, targetFolderOverride } = args;
 			if (!boilerplateName) throw new Error("Missing required parameter: boilerplateName");
 			if (!variables) throw new Error("Missing required parameter: variables");
 			const request = {
 				boilerplateName,
-				variables
+				variables,
+				monolith,
+				targetFolderOverride
 			};
 			return { content: [{
 				type: "text",
@@ -2447,7 +2521,7 @@ IMPORTANT:
 				properties: {
 					projectPath: {
 						type: "string",
-						description: "Absolute path to the project directory containing project.json"
+						description: "Absolute path to the project directory (for monorepo: containing project.json; for monolith: workspace root with toolkit.yaml)"
 					},
 					scaffold_feature_name: {
 						type: "string",
@@ -3112,43 +3186,43 @@ const scaffoldCommand = new commander.Command("scaffold").description("Add featu
 scaffoldCommand.command("list <projectPath>").description("List available scaffolding methods for a project").action(async (projectPath) => {
 	try {
 		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");
+		if (!await __agiflowai_aicode_utils.ProjectConfigResolver.hasConfiguration(absolutePath)) {
+			__agiflowai_aicode_utils.messages.error(`No project configuration found in ${absolutePath}`);
+			__agiflowai_aicode_utils.messages.hint("For monorepo: ensure project.json exists with sourceTemplate field\nFor monolith: ensure toolkit.yaml exists at workspace root");
 			process.exit(1);
 		}
 		const templatesDir = await __agiflowai_aicode_utils.TemplatesManagerService.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.");
+			__agiflowai_aicode_utils.messages.warning("No scaffolding methods available for this project.");
 			return;
 		}
-		print.header(`\n${icons.wrench} Available Scaffolding Methods for ${projectPath}:\n`);
+		__agiflowai_aicode_utils.print.header(`\n${__agiflowai_aicode_utils.icons.wrench} Available Scaffolding Methods for ${projectPath}:\n`);
 		for (const method of methods) {
-			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();
+			__agiflowai_aicode_utils.print.highlight(`  ${method.name}`);
+			__agiflowai_aicode_utils.print.debug(`    ${method.instruction || method.description || "No description available"}`);
+			if (method.variables_schema.required && method.variables_schema.required.length > 0) __agiflowai_aicode_utils.print.debug(`    Required: ${method.variables_schema.required.join(", ")}`);
+			__agiflowai_aicode_utils.print.newline();
 		}
 	} catch (error) {
-		messages.error("Error listing scaffolding methods:", error);
+		__agiflowai_aicode_utils.messages.error("Error listing scaffolding methods:", error);
 		process.exit(1);
 	}
 });
 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 = 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");
+		if (!await __agiflowai_aicode_utils.ProjectConfigResolver.hasConfiguration(projectPath)) {
+			__agiflowai_aicode_utils.messages.error(`No project configuration found in ${projectPath}`);
+			__agiflowai_aicode_utils.messages.hint("For monorepo: ensure project.json exists with sourceTemplate field\nFor monolith: ensure toolkit.yaml exists at workspace root");
 			process.exit(1);
 		}
 		let variables = {};
 		if (options.vars) try {
 			variables = JSON.parse(options.vars);
 		} catch (error) {
-			messages.error("Error parsing variables JSON:", error);
-			messages.hint("Example: --vars '{\"componentName\": \"UserProfile\", \"description\": \"User profile component\"}'");
+			__agiflowai_aicode_utils.messages.error("Error parsing variables JSON:", error);
+			__agiflowai_aicode_utils.messages.hint("Example: --vars '{\"componentName\": \"UserProfile\", \"description\": \"User profile component\"}'");
 			process.exit(1);
 		}
 		const templatesDir = await __agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPath();
@@ -3156,55 +3230,55 @@ scaffoldCommand.command("add <featureName>").description("Add a feature to an ex
 		const methods = (await scaffoldingMethodsService.listScaffoldingMethods(projectPath)).methods;
 		const method = methods.find((m) => m.name === featureName);
 		if (!method) {
-			messages.error(`Scaffold method '${featureName}' not found.`);
-			print.warning(`Available methods: ${methods.map((m) => m.name).join(", ")}`);
-			print.debug(`Run 'scaffold-mcp scaffold list ${options.project}' to see all available methods`);
+			__agiflowai_aicode_utils.messages.error(`Scaffold method '${featureName}' not found.`);
+			__agiflowai_aicode_utils.print.warning(`Available methods: ${methods.map((m) => m.name).join(", ")}`);
+			__agiflowai_aicode_utils.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 : [];
 		const missing = required.filter((key) => !variables[key]);
 		if (missing.length > 0) {
-			messages.error(`❌ Missing required variables: ${missing.join(", ")}`);
-			messages.hint(`💡 Use --vars with a JSON object containing: ${missing.join(", ")}`);
+			__agiflowai_aicode_utils.messages.error(`❌ Missing required variables: ${missing.join(", ")}`);
+			__agiflowai_aicode_utils.messages.hint(`💡 Use --vars with a JSON object containing: ${missing.join(", ")}`);
 			const exampleVars = {};
 			for (const key of required) if (key.includes("Name")) exampleVars[key] = "MyFeature";
 			else if (key === "description") exampleVars[key] = "Feature description";
 			else exampleVars[key] = `<${key}>`;
-			print.debug(`Example: scaffold-mcp scaffold add ${featureName} --project ${options.project} --vars '${JSON.stringify(exampleVars)}'`);
+			__agiflowai_aicode_utils.print.debug(`Example: scaffold-mcp scaffold add ${featureName} --project ${options.project} --vars '${JSON.stringify(exampleVars)}'`);
 			process.exit(1);
 		}
 		if (options.verbose) {
-			print.info(`🔧 Feature: ${featureName}`);
-			print.info(`📊 Variables: ${JSON.stringify(variables, null, 2)}`);
-			print.info(`📁 Project Path: ${projectPath}`);
+			__agiflowai_aicode_utils.print.info(`🔧 Feature: ${featureName}`);
+			__agiflowai_aicode_utils.print.info(`📊 Variables: ${JSON.stringify(variables, null, 2)}`);
+			__agiflowai_aicode_utils.print.info(`📁 Project Path: ${projectPath}`);
 		}
-		print.info(`🚀 Adding '${featureName}' to project...`);
+		__agiflowai_aicode_utils.print.info(`🚀 Adding '${featureName}' to project...`);
 		const result = await scaffoldingMethodsService.useScaffoldMethod({
 			projectPath,
 			scaffold_feature_name: featureName,
 			variables
 		});
 		if (result.success) {
-			messages.success("✅ Feature added successfully!");
+			__agiflowai_aicode_utils.messages.success("✅ Feature added successfully!");
 			console.log(result.message);
 			if (result.createdFiles && result.createdFiles.length > 0) {
-				print.header("\n📁 Created files:");
-				result.createdFiles.forEach((file) => print.debug(`   - ${file}`));
+				__agiflowai_aicode_utils.print.header("\n📁 Created files:");
+				result.createdFiles.forEach((file) => __agiflowai_aicode_utils.print.debug(`   - ${file}`));
 			}
 			if (result.warnings && result.warnings.length > 0) {
-				messages.warning("\n⚠️  Warnings:");
-				result.warnings.forEach((warning) => print.debug(`   - ${warning}`));
+				__agiflowai_aicode_utils.messages.warning("\n⚠️  Warnings:");
+				result.warnings.forEach((warning) => __agiflowai_aicode_utils.print.debug(`   - ${warning}`));
 			}
-			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");
+			__agiflowai_aicode_utils.print.header("\n📋 Next steps:");
+			__agiflowai_aicode_utils.print.debug("   - Review the generated files");
+			__agiflowai_aicode_utils.print.debug("   - Update imports if necessary");
+			__agiflowai_aicode_utils.print.debug("   - Run tests to ensure everything works");
 		} else {
-			messages.error(`❌ Failed to add feature: ${result.message}`);
+			__agiflowai_aicode_utils.messages.error(`❌ Failed to add feature: ${result.message}`);
 			process.exit(1);
 		}
 	} catch (error) {
-		messages.error(`❌ Error adding feature: ${error.message}`);
+		__agiflowai_aicode_utils.messages.error(`❌ Error adding feature: ${error.message}`);
 		if (options.verbose) console.error("Stack trace:", error.stack);
 		process.exit(1);
 	}
@@ -3212,31 +3286,32 @@ 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 = 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}`);
+		if (!await __agiflowai_aicode_utils.ProjectConfigResolver.hasConfiguration(projectPath)) {
+			__agiflowai_aicode_utils.messages.error(`No project configuration found in ${projectPath}`);
+			__agiflowai_aicode_utils.messages.hint("For monorepo: ensure project.json exists with sourceTemplate field\nFor monolith: ensure toolkit.yaml exists at workspace root");
 			process.exit(1);
 		}
 		const templatesDir = await __agiflowai_aicode_utils.TemplatesManagerService.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.`);
+			__agiflowai_aicode_utils.messages.error(`❌ Scaffold method '${featureName}' not found.`);
 			process.exit(1);
 		}
-		print.header(`\n🔧 Scaffold Method: ${method.name}\n`);
-		print.debug(`Description: ${method.description}`);
-		print.header("\n📝 Variables Schema:");
+		__agiflowai_aicode_utils.print.header(`\n🔧 Scaffold Method: ${method.name}\n`);
+		__agiflowai_aicode_utils.print.debug(`Description: ${method.description}`);
+		__agiflowai_aicode_utils.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) {
-			print.header("\n📁 Files to be created:");
+			__agiflowai_aicode_utils.print.header("\n📁 Files to be created:");
 			includes.forEach((include) => {
 				const parts = include.split(">>");
-				if (parts.length === 2) print.debug(`  - ${parts[1].trim()}`);
-				else print.debug(`  - ${include}`);
+				if (parts.length === 2) __agiflowai_aicode_utils.print.debug(`  - ${parts[1].trim()}`);
+				else __agiflowai_aicode_utils.print.debug(`  - ${include}`);
 			});
 		}
 	} catch (error) {
-		messages.error(`❌ Error getting scaffold info: ${error.message}`);
+		__agiflowai_aicode_utils.messages.error(`❌ Error getting scaffold info: ${error.message}`);
 		process.exit(1);
 	}
 });