@agiflowai/scaffold-mcp 1.0.0 → 1.0.1

package/dist/{stdio-Dmpwju2k.js → stdio-Bxn4A1IU.js}

@@ -1,14 +1,13 @@
 import { ScaffoldConfigLoader } from "./ScaffoldConfigLoader-CI0T6zdG.js";
-import { ScaffoldService } from "./ScaffoldService-QgQKHMM-.js";
+import { ScaffoldService } from "./ScaffoldService-DB7-Cyod.js";
 import { TemplateService } from "./TemplateService-CiZJA06s.js";
-import { VariableReplacementService } from "./VariableReplacementService-B3qARIC9.js";
+import { VariableReplacementService } from "./VariableReplacementService-DRxd9ILB.js";
+import { ProjectConfigResolver, log } from "@agiflowai/aicode-utils";
 import * as path$1 from "node:path";
 import path from "node:path";
-import { ProjectConfigResolver, log } from "@agiflowai/aicode-utils";
+import { jsonSchemaToZod } from "@composio/json-schema-to-zod";
 import * as fs$1 from "fs-extra";
 import fs from "fs-extra";
-import { execa } from "execa";
-import { jsonSchemaToZod } from "@composio/json-schema-to-zod";
 import * as yaml$1 from "js-yaml";
 import yaml from "js-yaml";
 import { z } from "zod";
@@ -19,133 +18,6 @@ import express from "express";
 import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
-//#region src/utils/git.ts
-/**
-* Execute a git command safely using execa to prevent command injection
-*/
-async function execGit(args, cwd) {
-	try {
-		await 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 = path.resolve(startPath);
-	const rootPath = path.parse(currentPath).root;
-	while (true) {
-		const gitPath = path.join(currentPath, ".git");
-		if (await fs$1.pathExists(gitPath)) return currentPath;
-		if (currentPath === rootPath) return null;
-		currentPath = path.dirname(currentPath);
-	}
-}
-/**
-* 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 execGit(["init", tempFolder]);
-		await execGit([
-			"remote",
-			"add",
-			"origin",
-			repoUrl
-		], tempFolder);
-		await execGit([
-			"config",
-			"core.sparseCheckout",
-			"true"
-		], tempFolder);
-		const sparseCheckoutFile = path.join(tempFolder, ".git", "info", "sparse-checkout");
-		await fs$1.writeFile(sparseCheckoutFile, `${subdirectory}\n`);
-		await execGit([
-			"pull",
-			"--depth=1",
-			"origin",
-			branch
-		], tempFolder);
-		const sourceDir = path.join(tempFolder, subdirectory);
-		if (!await fs$1.pathExists(sourceDir)) throw new Error(`Subdirectory '${subdirectory}' not found in repository at branch '${branch}'`);
-		if (await fs$1.pathExists(targetFolder)) throw new Error(`Target folder already exists: ${targetFolder}`);
-		await fs$1.move(sourceDir, targetFolder);
-		await fs$1.remove(tempFolder);
-	} catch (error) {
-		if (await fs$1.pathExists(tempFolder)) await fs$1.remove(tempFolder);
-		throw error;
-	}
-}
-/**
-* Clone entire repository
-*/
-async function cloneRepository(repoUrl, targetFolder) {
-	await execGit([
-		"clone",
-		repoUrl,
-		targetFolder
-	]);
-	const gitFolder = path.join(targetFolder, ".git");
-	if (await fs$1.pathExists(gitFolder)) await fs$1.remove(gitFolder);
-}
-/**
-* Fetch directory listing from GitHub API
-*/
-async function fetchGitHubDirectoryContents(owner, repo, path$2, branch = "main") {
-	const url = `https://api.github.com/repos/${owner}/${repo}/contents/${path$2}?ref=${branch}`;
-	const response = await fetch(url, { headers: {
-		Accept: "application/vnd.github.v3+json",
-		"User-Agent": "scaffold-mcp"
-	} });
-	if (!response.ok) throw new Error(`Failed to fetch directory contents: ${response.statusText}`);
-	const data = await response.json();
-	if (!Array.isArray(data)) throw new Error("Expected directory but got file");
-	return data.map((item) => ({
-		name: item.name,
-		type: item.type,
-		path: item.path
-	}));
-}
-
-//#endregion
 //#region src/services/FileSystemService.ts
 var FileSystemService = class {
 	async pathExists(path$2) {
@@ -242,7 +114,28 @@ var BoilerplateService = class {
 	* Executes a specific boilerplate with provided variables
 	*/
 	async useBoilerplate(request) {
-		const { boilerplateName, variables, monolith = false, targetFolderOverride } = request;
+		let { boilerplateName, variables, monolith, targetFolderOverride } = request;
+		if (monolith === void 0) try {
+			const config = await ProjectConfigResolver.resolveProjectConfig(process.cwd());
+			monolith = config.type === "monolith";
+			log.info(`Auto-detected project type: ${config.type}`);
+		} catch (_error) {
+			monolith = false;
+			log.info("No project configuration found, defaulting to monorepo mode");
+		}
+		if (monolith && !boilerplateName) try {
+			boilerplateName = (await ProjectConfigResolver.resolveProjectConfig(process.cwd())).sourceTemplate;
+			log.info(`Using boilerplate from toolkit.yaml: ${boilerplateName}`);
+		} catch (error) {
+			return {
+				success: false,
+				message: `Failed to read boilerplate name from toolkit.yaml: ${error instanceof Error ? error.message : String(error)}`
+			};
+		}
+		if (!boilerplateName) return {
+			success: false,
+			message: "Missing required parameter: boilerplateName"
+		};
 		const boilerplateList = await this.listBoilerplates();
 		const boilerplate = boilerplateList.boilerplates.find((b) => b.name === boilerplateName);
 		if (!boilerplate) return {
@@ -261,9 +154,10 @@ var BoilerplateService = class {
 		};
 		const folderName = packageName.includes("/") ? packageName.split("/")[1] : packageName;
 		const targetFolder = targetFolderOverride || (monolith ? "." : boilerplate.target_folder);
+		const projectNameForPath = monolith ? "" : folderName;
 		try {
 			const result = await this.scaffoldService.useBoilerplate({
-				projectName: folderName,
+				projectName: projectNameForPath,
 				packageName,
 				targetFolder,
 				templateFolder: boilerplate.template_path,
@@ -509,44 +403,28 @@ var BoilerplateGeneratorService = class {
 var GenerateBoilerplateFileTool = class GenerateBoilerplateFileTool {
 	static TOOL_NAME = "generate-boilerplate-file";
 	boilerplateGeneratorService;
-	constructor(templatesPath) {
+	isMonolith;
+	constructor(templatesPath, isMonolith = false) {
 		this.boilerplateGeneratorService = new BoilerplateGeneratorService(templatesPath);
+		this.isMonolith = isMonolith;
 	}
 	/**
 	* Get the tool definition for MCP
 	*/
 	getDefinition() {
-		return {
-			name: GenerateBoilerplateFileTool.TOOL_NAME,
-			description: `Create or update template files for boilerplates or features in the specified template directory.
-
-This tool:
-- Creates template files with .liquid extension for variable substitution
-- Supports creating nested directory structures
-- Can create files from source files (copying and converting to templates)
-- Validates that the template directory exists
-- Works for both boilerplate includes and feature scaffold includes
-
-IMPORTANT - Always add header comments:
-- For code files (*.ts, *.tsx, *.js, *.jsx), ALWAYS include a header parameter with design patterns, coding standards, and things to avoid
-- Headers help AI understand and follow established patterns when working with generated code
-- Use the header parameter to document the architectural decisions and best practices
-
-Use this after generate-boilerplate or generate-feature-scaffold to create the actual template files referenced in the includes array.`,
-			inputSchema: {
-				type: "object",
-				properties: {
-					templateName: {
-						type: "string",
-						description: "Name of the template folder (must already exist)"
-					},
-					filePath: {
-						type: "string",
-						description: "Path of the file to create within the template (e.g., \"package.json\", \"src/app/page.tsx\")"
-					},
-					content: {
-						type: "string",
-						description: `Content of the template file using Liquid template syntax.
+		const properties = {};
+		if (!this.isMonolith) properties.templateName = {
+			type: "string",
+			description: "Name of the template folder (must already exist)"
+		};
+		Object.assign(properties, {
+			filePath: {
+				type: "string",
+				description: "Path of the file to create within the template (e.g., \"package.json\", \"src/app/page.tsx\")"
+			},
+			content: {
+				type: "string",
+				description: `Content of the template file using Liquid template syntax.
 
 LIQUID SYNTAX:
 - Variables: {{ variableName }} - Replaced with actual values
@@ -615,14 +493,14 @@ export function calculateTax(income: number) {
   const stateRate = 0.05;
   return income * (federalRate + stateRate);
 }`
-					},
-					sourceFile: {
-						type: "string",
-						description: "Optional: Path to a source file to copy and convert to a template"
-					},
-					header: {
-						type: "string",
-						description: `Optional: Header comment to add at the top of the file to provide AI hints about design patterns, coding standards, and best practices.
+			},
+			sourceFile: {
+				type: "string",
+				description: "Optional: Path to a source file to copy and convert to a template"
+			},
+			header: {
+				type: "string",
+				description: `Optional: Header comment to add at the top of the file to provide AI hints about design patterns, coding standards, and best practices.
 
 Example format for TypeScript/JavaScript files:
 /**
@@ -642,9 +520,31 @@ Example format for TypeScript/JavaScript files:
  */
 
 The header helps AI understand and follow established patterns when working with generated code.`
-					}
-				},
-				required: ["templateName", "filePath"],
+			}
+		});
+		const required = ["filePath"];
+		if (!this.isMonolith) required.unshift("templateName");
+		return {
+			name: GenerateBoilerplateFileTool.TOOL_NAME,
+			description: `Create or update template files for boilerplates or features in the specified template directory.
+
+This tool:
+- Creates template files with .liquid extension for variable substitution
+- Supports creating nested directory structures
+- Can create files from source files (copying and converting to templates)
+- Validates that the template directory exists
+- Works for both boilerplate includes and feature scaffold includes
+
+IMPORTANT - Always add header comments:
+- For code files (*.ts, *.tsx, *.js, *.jsx), ALWAYS include a header parameter with design patterns, coding standards, and things to avoid
+- Headers help AI understand and follow established patterns when working with generated code
+- Use the header parameter to document the architectural decisions and best practices
+
+Use this after generate-boilerplate or generate-feature-scaffold to create the actual template files referenced in the includes array.`,
+			inputSchema: {
+				type: "object",
+				properties,
+				required,
 				additionalProperties: false
 			}
 		};
@@ -654,7 +554,29 @@ The header helps AI understand and follow established patterns when working with
 	*/
 	async execute(args) {
 		try {
-			const result = await this.boilerplateGeneratorService.createTemplateFile(args);
+			let { templateName } = args;
+			if (this.isMonolith && !templateName) try {
+				templateName = (await ProjectConfigResolver.resolveProjectConfig(process.cwd())).sourceTemplate;
+			} catch (error) {
+				return {
+					content: [{
+						type: "text",
+						text: `Failed to read template name from configuration: ${error instanceof Error ? error.message : String(error)}`
+					}],
+					isError: true
+				};
+			}
+			if (!templateName) return {
+				content: [{
+					type: "text",
+					text: "Missing required parameter: templateName"
+				}],
+				isError: true
+			};
+			const result = await this.boilerplateGeneratorService.createTemplateFile({
+				...args,
+				templateName
+			});
 			if (!result.success) return {
 				content: [{
 					type: "text",
@@ -692,42 +614,32 @@ The header helps AI understand and follow established patterns when working with
 var GenerateBoilerplateTool = class GenerateBoilerplateTool {
 	static TOOL_NAME = "generate-boilerplate";
 	boilerplateGeneratorService;
-	constructor(templatesPath) {
+	isMonolith;
+	constructor(templatesPath, isMonolith = false) {
 		this.boilerplateGeneratorService = new BoilerplateGeneratorService(templatesPath);
+		this.isMonolith = isMonolith;
 	}
 	/**
 	* Get the tool definition for MCP
 	*/
 	getDefinition() {
-		return {
-			name: GenerateBoilerplateTool.TOOL_NAME,
-			description: `Add a new boilerplate configuration to a template's scaffold.yaml file.
-
-This tool:
-- Creates or updates scaffold.yaml in the specified template directory
-- Adds a boilerplate entry with proper schema following the nextjs-15 pattern
-- Validates the boilerplate name doesn't already exist
-- Creates the template directory if it doesn't exist
-
-Use this to add custom boilerplate configurations for frameworks not yet supported or for your specific project needs.`,
-			inputSchema: {
-				type: "object",
-				properties: {
-					templateName: {
-						type: "string",
-						description: "Name of the template folder (kebab-case, e.g., \"my-framework\")"
-					},
-					boilerplateName: {
-						type: "string",
-						description: "Name of the boilerplate (kebab-case, e.g., \"scaffold-my-app\")"
-					},
-					targetFolder: {
-						type: "string",
-						description: "Target folder where projects will be created (e.g., \"apps\", \"packages\")"
-					},
-					description: {
-						type: "string",
-						description: `Detailed description of what this boilerplate creates and its key features.
+		const properties = {};
+		if (!this.isMonolith) properties.templateName = {
+			type: "string",
+			description: "Name of the template folder (kebab-case, e.g., \"my-framework\")"
+		};
+		Object.assign(properties, {
+			boilerplateName: {
+				type: "string",
+				description: "Name of the boilerplate (kebab-case, e.g., \"scaffold-my-app\")"
+			},
+			targetFolder: {
+				type: "string",
+				description: "Target folder where projects will be created (e.g., \"apps\", \"packages\")"
+			},
+			description: {
+				type: "string",
+				description: `Detailed description of what this boilerplate creates and its key features.
 
 STRUCTURE (3-5 sentences in multiple paragraphs):
 - Paragraph 1: Core technology stack and primary value proposition
@@ -738,10 +650,10 @@ Example: "A modern React SPA template powered by Vite for lightning-fast HMR, fe
 Perfect for building data-driven dashboards, admin panels, and interactive web applications requiring client-side routing and real-time data synchronization.
 
 Includes Agiflow Config Management System integration with systematic environment variable naming (VITE_{CATEGORY}_{SUBCATEGORY}_{PROPERTY}) and auto-generated configuration templates for cloud deployment."`
-					},
-					instruction: {
-						type: "string",
-						description: `Optional detailed instructions about the generated files, their purposes, and how to work with them.
+			},
+			instruction: {
+				type: "string",
+				description: `Optional detailed instructions about the generated files, their purposes, and how to work with them.
 
 STRUCTURE (Multi-section guide):
 
@@ -785,47 +697,47 @@ Design patterns to follow:
 - Type-safe Routes: Leverage [framework] type inference for params
 - State Management: Use [library] for server state, [library] for client state
 [... list key patterns with explanations ...]"`
+			},
+			variables: {
+				type: "array",
+				description: "Array of variable definitions for the boilerplate",
+				items: {
+					type: "object",
+					properties: {
+						name: {
+							type: "string",
+							description: "Variable name (camelCase)"
+						},
+						description: {
+							type: "string",
+							description: "Variable description"
+						},
+						type: {
+							type: "string",
+							enum: [
+								"string",
+								"number",
+								"boolean"
+							],
+							description: "Variable type"
+						},
+						required: {
+							type: "boolean",
+							description: "Whether this variable is required"
+						},
+						default: { description: "Optional default value for the variable" }
 					},
-					variables: {
-						type: "array",
-						description: "Array of variable definitions for the boilerplate",
-						items: {
-							type: "object",
-							properties: {
-								name: {
-									type: "string",
-									description: "Variable name (camelCase)"
-								},
-								description: {
-									type: "string",
-									description: "Variable description"
-								},
-								type: {
-									type: "string",
-									enum: [
-										"string",
-										"number",
-										"boolean"
-									],
-									description: "Variable type"
-								},
-								required: {
-									type: "boolean",
-									description: "Whether this variable is required"
-								},
-								default: { description: "Optional default value for the variable" }
-							},
-							required: [
-								"name",
-								"description",
-								"type",
-								"required"
-							]
-						}
-					},
-					includes: {
-						type: "array",
-						description: `Array of specific file paths to include in the boilerplate (highly recommended to list explicitly).
+					required: [
+						"name",
+						"description",
+						"type",
+						"required"
+					]
+				}
+			},
+			includes: {
+				type: "array",
+				description: `Array of specific file paths to include in the boilerplate (highly recommended to list explicitly).
 
 Examples:
 - ["package.json", "tsconfig.json", "src/index.ts"] - Explicit file list (recommended)
@@ -839,16 +751,33 @@ Best practices:
 - Avoid wildcards unless you have a good reason
 
 See templates/nextjs-15/scaffold.yaml for a good example of explicit file listing.`,
-						items: { type: "string" }
-					}
-				},
-				required: [
-					"templateName",
-					"boilerplateName",
-					"description",
-					"targetFolder",
-					"variables"
-				],
+				items: { type: "string" }
+			}
+		});
+		const required = [
+			"boilerplateName",
+			"description",
+			"variables"
+		];
+		if (!this.isMonolith) {
+			required.unshift("templateName");
+			required.push("targetFolder");
+		}
+		return {
+			name: GenerateBoilerplateTool.TOOL_NAME,
+			description: `Add a new boilerplate configuration to a template's scaffold.yaml file.
+
+This tool:
+- Creates or updates scaffold.yaml in the specified template directory
+- Adds a boilerplate entry with proper schema following the nextjs-15 pattern
+- Validates the boilerplate name doesn't already exist
+- Creates the template directory if it doesn't exist
+
+Use this to add custom boilerplate configurations for frameworks not yet supported or for your specific project needs.`,
+			inputSchema: {
+				type: "object",
+				properties,
+				required,
 				additionalProperties: false
 			}
 		};
@@ -858,7 +787,38 @@ See templates/nextjs-15/scaffold.yaml for a good example of explicit file listin
 	*/
 	async execute(args) {
 		try {
-			const result = await this.boilerplateGeneratorService.generateBoilerplate(args);
+			let { templateName, targetFolder } = args;
+			if (this.isMonolith && !templateName) try {
+				templateName = (await ProjectConfigResolver.resolveProjectConfig(process.cwd())).sourceTemplate;
+			} catch (error) {
+				return {
+					content: [{
+						type: "text",
+						text: `Failed to read template name from configuration: ${error instanceof Error ? error.message : String(error)}`
+					}],
+					isError: true
+				};
+			}
+			if (this.isMonolith && !targetFolder) targetFolder = ".";
+			if (!templateName) return {
+				content: [{
+					type: "text",
+					text: "Missing required parameter: templateName"
+				}],
+				isError: true
+			};
+			if (!targetFolder) return {
+				content: [{
+					type: "text",
+					text: "Missing required parameter: targetFolder"
+				}],
+				isError: true
+			};
+			const result = await this.boilerplateGeneratorService.generateBoilerplate({
+				...args,
+				templateName,
+				targetFolder
+			});
 			if (!result.success) return {
 				content: [{
 					type: "text",
@@ -1026,38 +986,28 @@ var ScaffoldGeneratorService = class {
 var GenerateFeatureScaffoldTool = class GenerateFeatureScaffoldTool {
 	static TOOL_NAME = "generate-feature-scaffold";
 	scaffoldGeneratorService;
-	constructor(templatesPath) {
+	isMonolith;
+	constructor(templatesPath, isMonolith = false) {
 		this.scaffoldGeneratorService = new ScaffoldGeneratorService(templatesPath);
+		this.isMonolith = isMonolith;
 	}
 	/**
 	* Get the tool definition for MCP
 	*/
 	getDefinition() {
-		return {
-			name: GenerateFeatureScaffoldTool.TOOL_NAME,
-			description: `Add a new feature scaffold configuration to a template's scaffold.yaml file.
-
-This tool:
-- Creates or updates scaffold.yaml in the specified template directory
-- Adds a feature entry with proper schema following the nextjs-15 pattern
-- Validates the feature name doesn't already exist
-- Creates the template directory if it doesn't exist
-
-Use this to add custom feature scaffolds (pages, components, services, etc.) for frameworks not yet supported or for your specific project needs.`,
-			inputSchema: {
-				type: "object",
-				properties: {
-					templateName: {
-						type: "string",
-						description: "Name of the template folder (kebab-case, e.g., \"nextjs-15\")"
-					},
-					featureName: {
-						type: "string",
-						description: "Name of the feature (kebab-case, e.g., \"scaffold-nextjs-page\")"
-					},
-					description: {
-						type: "string",
-						description: `Detailed description of what this feature creates and its key capabilities.
+		const properties = {};
+		if (!this.isMonolith) properties.templateName = {
+			type: "string",
+			description: "Name of the template folder (kebab-case, e.g., \"nextjs-15\")"
+		};
+		Object.assign(properties, {
+			featureName: {
+				type: "string",
+				description: "Name of the feature (kebab-case, e.g., \"scaffold-nextjs-page\")"
+			},
+			description: {
+				type: "string",
+				description: `Detailed description of what this feature creates and its key capabilities.
 
 STRUCTURE (2-3 sentences):
 - Sentence 1: What type of code it generates (component, page, service, etc.)
@@ -1065,10 +1015,10 @@ STRUCTURE (2-3 sentences):
 - Sentence 3: Primary use cases or when to use it
 
 Example: "Generate a new service class for TypeScript libraries following best practices. Creates a service class with interface, implementation, and unit tests. Perfect for creating reusable service modules with dependency injection patterns."`
-					},
-					instruction: {
-						type: "string",
-						description: `Optional detailed instructions about the generated files, their purposes, and how to work with them.
+			},
+			instruction: {
+				type: "string",
+				description: `Optional detailed instructions about the generated files, their purposes, and how to work with them.
 
 STRUCTURE (Concise multi-aspect guide):
 
@@ -1079,47 +1029,47 @@ STRUCTURE (Concise multi-aspect guide):
 5. **Testing approach**: How to test the feature
 
 Example: "Services follow a class-based pattern with optional interface separation. The service class implements business logic and can be dependency injected. Place services in src/services/ directory. For services with interfaces, define the interface in src/types/interfaces/ for better separation of concerns. Service names should be PascalCase and end with 'Service' suffix. Write comprehensive unit tests for all public methods."`
+			},
+			variables: {
+				type: "array",
+				description: "Array of variable definitions for the feature",
+				items: {
+					type: "object",
+					properties: {
+						name: {
+							type: "string",
+							description: "Variable name (camelCase)"
+						},
+						description: {
+							type: "string",
+							description: "Variable description"
+						},
+						type: {
+							type: "string",
+							enum: [
+								"string",
+								"number",
+								"boolean"
+							],
+							description: "Variable type"
+						},
+						required: {
+							type: "boolean",
+							description: "Whether this variable is required"
+						},
+						default: { description: "Optional default value for the variable" }
 					},
-					variables: {
-						type: "array",
-						description: "Array of variable definitions for the feature",
-						items: {
-							type: "object",
-							properties: {
-								name: {
-									type: "string",
-									description: "Variable name (camelCase)"
-								},
-								description: {
-									type: "string",
-									description: "Variable description"
-								},
-								type: {
-									type: "string",
-									enum: [
-										"string",
-										"number",
-										"boolean"
-									],
-									description: "Variable type"
-								},
-								required: {
-									type: "boolean",
-									description: "Whether this variable is required"
-								},
-								default: { description: "Optional default value for the variable" }
-							},
-							required: [
-								"name",
-								"description",
-								"type",
-								"required"
-							]
-						}
-					},
-					includes: {
-						type: "array",
-						description: `Array of specific file paths to include in the feature (highly recommended to list explicitly).
+					required: [
+						"name",
+						"description",
+						"type",
+						"required"
+					]
+				}
+			},
+			includes: {
+				type: "array",
+				description: `Array of specific file paths to include in the feature (highly recommended to list explicitly).
 
 Supports advanced syntax:
 - Basic: "src/app/page/page.tsx" - Always included
@@ -1140,11 +1090,11 @@ Best practices:
 - 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`,
-						items: { type: "string" }
-					},
-					patterns: {
-						type: "array",
-						description: `Optional array of glob patterns to match existing files that this feature works with.
+				items: { type: "string" }
+			},
+			patterns: {
+				type: "array",
+				description: `Optional array of glob patterns to match existing files that this feature works with.
 
 Used to help identify where this feature can be applied in a project.
 
@@ -1157,15 +1107,30 @@ Best practices:
 - Use glob patterns that match the file types this feature works with
 - Keep patterns specific enough to be meaningful but broad enough to be useful
 - Consider both the feature's output and input files`,
-						items: { type: "string" }
-					}
-				},
-				required: [
-					"templateName",
-					"featureName",
-					"description",
-					"variables"
-				],
+				items: { type: "string" }
+			}
+		});
+		const required = [
+			"featureName",
+			"description",
+			"variables"
+		];
+		if (!this.isMonolith) required.unshift("templateName");
+		return {
+			name: GenerateFeatureScaffoldTool.TOOL_NAME,
+			description: `Add a new feature scaffold configuration to a template's scaffold.yaml file.
+
+This tool:
+- Creates or updates scaffold.yaml in the specified template directory
+- Adds a feature entry with proper schema following the nextjs-15 pattern
+- Validates the feature name doesn't already exist
+- Creates the template directory if it doesn't exist
+
+Use this to add custom feature scaffolds (pages, components, services, etc.) for frameworks not yet supported or for your specific project needs.`,
+			inputSchema: {
+				type: "object",
+				properties,
+				required,
 				additionalProperties: false
 			}
 		};
@@ -1175,7 +1140,29 @@ Best practices:
 	*/
 	async execute(args) {
 		try {
-			const result = await this.scaffoldGeneratorService.generateFeatureScaffold(args);
+			let { templateName } = args;
+			if (this.isMonolith && !templateName) try {
+				templateName = (await ProjectConfigResolver.resolveProjectConfig(process.cwd())).sourceTemplate;
+			} catch (error) {
+				return {
+					content: [{
+						type: "text",
+						text: `Failed to read template name from configuration: ${error instanceof Error ? error.message : String(error)}`
+					}],
+					isError: true
+				};
+			}
+			if (!templateName) return {
+				content: [{
+					type: "text",
+					text: "Missing required parameter: templateName"
+				}],
+				isError: true
+			};
+			const result = await this.scaffoldGeneratorService.generateFeatureScaffold({
+				...args,
+				templateName
+			});
 			if (!result.success) return {
 				content: [{
 					type: "text",
@@ -1210,29 +1197,30 @@ Best practices:
 	}
 };
 
+//#endregion
+//#region src/instructions/tools/list-boilerplates/description.md?raw
+var description_default$2 = "{% if isMonolith %}\nNot available for monolith projects. Monolith uses a single template defined in `toolkit.yaml`.\n\nUse `list-scaffolding-methods` for available features instead.\n{% else %}\nLists all available project boilerplates for creating new applications, APIs, or packages in the monorepo.\n\nEach boilerplate includes:\n- Complete project template with starter files\n- Variable schema for customization\n- Target directory information (e.g., apps/, packages/)\n- Required and optional configuration options\n\nUse this FIRST when creating new projects to understand available templates and their requirements.\n{% endif %}\n";
+
 //#endregion
 //#region src/tools/ListBoilerplatesTool.ts
 var ListBoilerplatesTool = class ListBoilerplatesTool {
 	static TOOL_NAME = "list-boilerplates";
 	boilerplateService;
-	constructor(templatesPath) {
+	templateService;
+	isMonolith;
+	constructor(templatesPath, isMonolith = false) {
 		this.boilerplateService = new BoilerplateService(templatesPath);
+		this.templateService = new TemplateService();
+		this.isMonolith = isMonolith;
 	}
 	/**
 	* Get the tool definition for MCP
 	*/
 	getDefinition() {
+		const description = this.templateService.renderString(description_default$2, { isMonolith: this.isMonolith });
 		return {
 			name: ListBoilerplatesTool.TOOL_NAME,
-			description: `Lists all available project boilerplates for creating new applications, APIs, or packages in the monorepo.
-
-Each boilerplate includes:
-- Complete project template with starter files
-- Variable schema for customization
-- Target directory information
-- Required and optional configuration options
-
-Use this FIRST when creating new projects to understand available templates and their requirements.`,
+			description: description.trim(),
 			inputSchema: {
 				type: "object",
 				properties: {},
@@ -1262,6 +1250,10 @@ Use this FIRST when creating new projects to understand available templates and
 	}
 };
 
+//#endregion
+//#region src/instructions/tools/list-scaffolding-methods/description.md?raw
+var description_default$1 = "Lists all available scaffolding methods (features) that can be added to an existing project{% if not isMonolith %} or for a specific template{% endif %}.\n\nThis tool:\n{% if isMonolith %}\n- Reads your project's sourceTemplate from toolkit.yaml at workspace root\n{% else %}\n- Reads the project's sourceTemplate from project.json (monorepo) or toolkit.yaml (monolith), OR\n- Directly uses the provided templateName to list available features\n{% endif %}\n- Returns available features for that template type\n- Provides variable schemas for each scaffolding method\n- Shows descriptions of what each method creates\n\nUse this FIRST when adding features to understand:\n- What scaffolding methods are available\n- What variables each method requires\n- What files/features will be generated\n\nExample methods might include:\n- Adding new React routes (for React apps)\n- Creating API endpoints (for backend projects)\n- Adding new components (for frontend projects)\n- Setting up database models (for API projects)\n";
+
 //#endregion
 //#region src/services/ScaffoldingMethodsService.ts
 var ScaffoldingMethodsService = class {
@@ -1274,8 +1266,11 @@ var ScaffoldingMethodsService = class {
 	async listScaffoldingMethods(projectPath) {
 		const absoluteProjectPath = path.resolve(projectPath);
 		const sourceTemplate = (await ProjectConfigResolver.resolveProjectConfig(absoluteProjectPath)).sourceTemplate;
-		const templatePath = await this.findTemplatePath(sourceTemplate);
-		if (!templatePath) throw new Error(`Template not found for sourceTemplate: ${sourceTemplate}`);
+		return this.listScaffoldingMethodsByTemplate(sourceTemplate);
+	}
+	async listScaffoldingMethodsByTemplate(templateName) {
+		const templatePath = await this.findTemplatePath(templateName);
+		if (!templatePath) throw new Error(`Template not found for sourceTemplate: ${templateName}`);
 		const fullTemplatePath = path.join(this.templatesRootPath, templatePath);
 		const scaffoldYamlPath = path.join(fullTemplatePath, "scaffold.yaml");
 		if (!await this.fileSystem.pathExists(scaffoldYamlPath)) throw new Error(`scaffold.yaml not found at ${scaffoldYamlPath}`);
@@ -1283,8 +1278,9 @@ var ScaffoldingMethodsService = class {
 		const architectConfig = yaml.load(scaffoldContent);
 		const methods = [];
 		if (architectConfig.features && Array.isArray(architectConfig.features)) architectConfig.features.forEach((feature) => {
-			if (feature.name) methods.push({
-				name: feature.name,
+			const featureName = feature.name || `scaffold-${templateName}`;
+			methods.push({
+				name: featureName,
 				description: feature.description || "",
 				instruction: feature.instruction || "",
 				variables_schema: feature.variables_schema || {
@@ -1297,7 +1293,7 @@ var ScaffoldingMethodsService = class {
 			});
 		});
 		return {
-			sourceTemplate,
+			sourceTemplate: templateName,
 			templatePath,
 			methods
 		};
@@ -1342,6 +1338,14 @@ var ScaffoldingMethodsService = class {
 		return null;
 	}
 	/**
+	* Resolves the project path, handling both monorepo and monolith cases
+	* Uses ProjectConfigResolver to find the correct workspace/project root
+	*/
+	async resolveProjectPath(projectPath) {
+		const absolutePath = path.resolve(projectPath);
+		return (await ProjectConfigResolver.resolveProjectConfig(absolutePath)).workspaceRoot || absolutePath;
+	}
+	/**
 	* Dynamically discovers all template directories
 	* Supports both flat structure (templates/nextjs-15) and nested structure (templates/apps/nextjs-15)
 	**/
@@ -1379,21 +1383,21 @@ var ScaffoldingMethodsService = class {
 	}
 	async useScaffoldMethod(request) {
 		const { projectPath, scaffold_feature_name, variables } = request;
-		const scaffoldingMethods = await this.listScaffoldingMethods(projectPath);
+		const absoluteProjectPath = await this.resolveProjectPath(projectPath);
+		const scaffoldingMethods = await this.listScaffoldingMethods(absoluteProjectPath);
 		const method = scaffoldingMethods.methods.find((m) => m.name === scaffold_feature_name);
 		if (!method) {
 			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-DVsusUh5.js")).ScaffoldService;
+		const ScaffoldService$1 = (await import("./ScaffoldService-CJ3vNmAj.js")).ScaffoldService;
 		const ScaffoldConfigLoader$1 = (await import("./ScaffoldConfigLoader-DhthV6xq.js")).ScaffoldConfigLoader;
-		const VariableReplacementService$1 = (await import("./VariableReplacementService-D8C-IsP-.js")).VariableReplacementService;
+		const VariableReplacementService$1 = (await import("./VariableReplacementService-BAwTGv_R.js")).VariableReplacementService;
 		const TemplateService$1 = (await import("./TemplateService-DropYdp8.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 result = await scaffoldService.useFeature({
 			projectPath: absoluteProjectPath,
@@ -1426,41 +1430,36 @@ var ListScaffoldingMethodsTool = class ListScaffoldingMethodsTool {
 	static TOOL_NAME = "list-scaffolding-methods";
 	fileSystemService;
 	scaffoldingMethodsService;
-	constructor(templatesPath) {
+	templateService;
+	isMonolith;
+	constructor(templatesPath, isMonolith = false) {
 		this.fileSystemService = new FileSystemService();
 		this.scaffoldingMethodsService = new ScaffoldingMethodsService(this.fileSystemService, templatesPath);
+		this.templateService = new TemplateService();
+		this.isMonolith = isMonolith;
 	}
 	/**
 	* Get the tool definition for MCP
 	*/
 	getDefinition() {
+		const description = this.templateService.renderString(description_default$1, { isMonolith: this.isMonolith });
+		const properties = {};
+		if (!this.isMonolith) {
+			properties.projectPath = {
+				type: "string",
+				description: "Absolute path to the project directory (for monorepo: containing project.json; for monolith: workspace root with toolkit.yaml). Either projectPath or templateName is required."
+			};
+			properties.templateName = {
+				type: "string",
+				description: "Name of the template to list scaffolding methods for (e.g., \"nextjs-15\", \"typescript-mcp-package\"). Either projectPath or templateName is required."
+			};
+		}
 		return {
 			name: ListScaffoldingMethodsTool.TOOL_NAME,
-			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 (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
-
-Use this FIRST when adding features to existing projects to understand:
-- What scaffolding methods are available
-- What variables each method requires
-- What files/features will be generated
-
-Example methods might include:
-- Adding new React routes (for React apps)
-- Creating API endpoints (for backend projects)
-- Adding new components (for frontend projects)
-- Setting up database models (for API projects)`,
+			description: description.trim(),
 			inputSchema: {
 				type: "object",
-				properties: { projectPath: {
-					type: "string",
-					description: "Absolute path to the project directory (for monorepo: containing project.json; for monolith: workspace root with toolkit.yaml)"
-				} },
-				required: ["projectPath"],
+				properties,
 				additionalProperties: false
 			}
 		};
@@ -1470,9 +1469,19 @@ Example methods might include:
 	*/
 	async execute(args) {
 		try {
-			const { projectPath } = args;
-			if (!projectPath) throw new Error("Missing required parameter: projectPath");
-			const result = await this.scaffoldingMethodsService.listScaffoldingMethods(projectPath);
+			const { projectPath, templateName } = args;
+			let result;
+			if (this.isMonolith) try {
+				const resolvedTemplateName = (await ProjectConfigResolver.resolveProjectConfig(process.cwd())).sourceTemplate;
+				result = await this.scaffoldingMethodsService.listScaffoldingMethodsByTemplate(resolvedTemplateName);
+			} catch (error) {
+				throw new Error(`Failed to read template name from configuration: ${error instanceof Error ? error.message : String(error)}`);
+			}
+			else {
+				if (!projectPath && !templateName) throw new Error("Either projectPath or templateName must be provided");
+				if (projectPath) result = await this.scaffoldingMethodsService.listScaffoldingMethods(projectPath);
+				else result = await this.scaffoldingMethodsService.listScaffoldingMethodsByTemplate(templateName);
+			}
 			return { content: [{
 				type: "text",
 				text: JSON.stringify(result, null, 2)
@@ -1489,57 +1498,48 @@ Example methods might include:
 	}
 };
 
+//#endregion
+//#region src/instructions/tools/use-boilerplate/description.md?raw
+var description_default = "{% if isMonolith %}\nThis tool is not available for monolith projects.\n\nMonolith projects use a single template specified in `toolkit.yaml` (sourceTemplate field). The template cannot be changed through this tool - it's determined by the workspace configuration.\n\nUse `list-scaffolding-methods` and `use-scaffold-method` to add features to your monolith project instead.\n{% else %}\nCreates a new project from a boilerplate template with the specified variables.\n\n**For Monorepo Projects Only:**\nThis tool creates new sub-projects (apps, packages) in your monorepo. Each project can use a different template.\n\nThis tool will:\n- Generate all necessary files from the selected boilerplate template\n- Replace template variables with provided values\n- Create the project in targetFolder/projectName (e.g., apps/my-new-app)\n- Set up initial configuration files (package.json, tsconfig.json, etc.)\n- Create project.json with sourceTemplate reference\n\nIMPORTANT:\n- Always call `list-boilerplates` first to get the exact variable schema\n- Follow the schema exactly - required fields must be provided\n- Use kebab-case for project names (e.g., \"my-new-app\", not \"MyNewApp\")\n- The tool will validate all variables against the schema before proceeding\n- Each new project can use a different boilerplate template\n{% endif %}\n";
+
 //#endregion
 //#region src/tools/UseBoilerplateTool.ts
 var UseBoilerplateTool = class UseBoilerplateTool {
 	static TOOL_NAME = "use-boilerplate";
 	boilerplateService;
-	constructor(templatesPath) {
+	templateService;
+	isMonolith;
+	constructor(templatesPath, isMonolith = false) {
 		this.boilerplateService = new BoilerplateService(templatesPath);
+		this.templateService = new TemplateService();
+		this.isMonolith = isMonolith;
 	}
 	/**
 	* Get the tool definition for MCP
 	*/
 	getDefinition() {
+		const description = this.templateService.renderString(description_default, { isMonolith: this.isMonolith });
+		const properties = { variables: {
+			type: "object",
+			description: "Variables object matching the boilerplate's variables_schema exactly"
+		} };
+		if (!this.isMonolith) {
+			properties.boilerplateName = {
+				type: "string",
+				description: "Exact name of the boilerplate to use (from list-boilerplates response)"
+			};
+			properties.targetFolderOverride = {
+				type: "string",
+				description: "Optional override for target folder. If not provided, uses boilerplate targetFolder (monorepo) or workspace root (monolith)"
+			};
+		}
 		return {
 			name: UseBoilerplateTool.TOOL_NAME,
-			description: `Creates a new project from a boilerplate template with the specified variables.
-
-This tool will:
-- Generate all necessary files from the template
-- Replace template variables with provided values
-- 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
-- For monolith projects, use monolith: true to create at workspace root
-- For monorepo projects, files are created in targetFolder/projectName`,
+			description: description.trim(),
 			inputSchema: {
 				type: "object",
-				properties: {
-					boilerplateName: {
-						type: "string",
-						description: "Exact name of the boilerplate to use (from list-boilerplates response)"
-					},
-					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"],
+				properties,
+				required: this.isMonolith ? ["variables"] : ["boilerplateName", "variables"],
 				additionalProperties: false
 			}
 		};
@@ -1549,14 +1549,12 @@ IMPORTANT:
 	*/
 	async execute(args) {
 		try {
-			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 { boilerplateName, variables, targetFolderOverride } = args;
 			const request = {
 				boilerplateName,
 				variables,
-				monolith,
-				targetFolderOverride
+				targetFolderOverride,
+				monolith: this.isMonolith
 			};
 			return { content: [{
 				type: "text",
@@ -1589,14 +1587,30 @@ var UseScaffoldMethodTool = class UseScaffoldMethodTool {
 	static TOOL_NAME = "use-scaffold-method";
 	fileSystemService;
 	scaffoldingMethodsService;
-	constructor(templatesPath) {
+	isMonolith;
+	constructor(templatesPath, isMonolith = false) {
 		this.fileSystemService = new FileSystemService();
 		this.scaffoldingMethodsService = new ScaffoldingMethodsService(this.fileSystemService, templatesPath);
+		this.isMonolith = isMonolith;
 	}
 	/**
 	* Get the tool definition for MCP
 	*/
 	getDefinition() {
+		const properties = {
+			scaffold_feature_name: {
+				type: "string",
+				description: "Exact name of the scaffold method to use (from list-scaffolding-methods response)"
+			},
+			variables: {
+				type: "object",
+				description: "Variables object matching the scaffold method's variables_schema exactly"
+			}
+		};
+		if (!this.isMonolith) properties.projectPath = {
+			type: "string",
+			description: "Absolute path to the project directory (for monorepo: containing project.json; for monolith: workspace root with toolkit.yaml)"
+		};
 		return {
 			name: UseScaffoldMethodTool.TOOL_NAME,
 			description: `Generates and adds a specific feature to an existing project using a scaffolding method.
@@ -1616,21 +1630,8 @@ IMPORTANT:
 `,
 			inputSchema: {
 				type: "object",
-				properties: {
-					projectPath: {
-						type: "string",
-						description: "Absolute path to the project directory (for monorepo: containing project.json; for monolith: workspace root with toolkit.yaml)"
-					},
-					scaffold_feature_name: {
-						type: "string",
-						description: "Exact name of the scaffold method to use (from list-scaffolding-methods response)"
-					},
-					variables: {
-						type: "object",
-						description: "Variables object matching the scaffold method's variables_schema exactly"
-					}
-				},
-				required: [
+				properties,
+				required: this.isMonolith ? ["scaffold_feature_name", "variables"] : [
 					"projectPath",
 					"scaffold_feature_name",
 					"variables"
@@ -1645,13 +1646,11 @@ IMPORTANT:
 	async execute(args) {
 		try {
 			const { projectPath, scaffold_feature_name, variables } = args;
-			if (!projectPath) throw new Error("Missing required parameter: projectPath");
-			if (!scaffold_feature_name) throw new Error("Missing required parameter: scaffold_feature_name");
-			if (!variables) throw new Error("Missing required parameter: variables");
+			const resolvedProjectPath = this.isMonolith ? process.cwd() : projectPath;
 			return { content: [{
 				type: "text",
 				text: `${(await this.scaffoldingMethodsService.useScaffoldMethod({
-					projectPath,
+					projectPath: resolvedProjectPath,
 					scaffold_feature_name,
 					variables
 				})).message}
@@ -2071,4 +2070,4 @@ var StdioTransportHandler = class {
 };
 
 //#endregion
-export { BoilerplateGeneratorService, BoilerplateService, FileSystemService, GenerateBoilerplateFileTool, GenerateBoilerplateTool, GenerateFeatureScaffoldTool, HttpTransportHandler, ListBoilerplatesTool, ListScaffoldingMethodsTool, ScaffoldGeneratorService, ScaffoldingMethodsService, SseTransportHandler, StdioTransportHandler, UseBoilerplateTool, UseScaffoldMethodTool, WriteToFileTool, cloneRepository, cloneSubdirectory, fetchGitHubDirectoryContents, findWorkspaceRoot, parseGitHubUrl };
+export { BoilerplateGeneratorService, BoilerplateService, FileSystemService, GenerateBoilerplateFileTool, GenerateBoilerplateTool, GenerateFeatureScaffoldTool, HttpTransportHandler, ListBoilerplatesTool, ListScaffoldingMethodsTool, ScaffoldGeneratorService, ScaffoldingMethodsService, SseTransportHandler, StdioTransportHandler, UseBoilerplateTool, UseScaffoldMethodTool, WriteToFileTool };