@agiflowai/scaffold-mcp 0.6.0 → 1.0.1

package/dist/cli.cjs

@@ -0,0 +1,779 @@
+#!/usr/bin/env node
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const require_stdio = require('./stdio-TGsG8akc.cjs');
+require('./ScaffoldConfigLoader-BrmvENTo.cjs');
+require('./ScaffoldService-BwDmXt83.cjs');
+const require_TemplateService = require('./TemplateService-DRubcvS9.cjs');
+require('./VariableReplacementService-D0QnWKUW.cjs');
+let commander = require("commander");
+commander = require_chunk.__toESM(commander);
+let __agiflowai_aicode_utils = require("@agiflowai/aicode-utils");
+__agiflowai_aicode_utils = require_chunk.__toESM(__agiflowai_aicode_utils);
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let __modelcontextprotocol_sdk_server_index_js = require("@modelcontextprotocol/sdk/server/index.js");
+__modelcontextprotocol_sdk_server_index_js = require_chunk.__toESM(__modelcontextprotocol_sdk_server_index_js);
+let __modelcontextprotocol_sdk_types_js = require("@modelcontextprotocol/sdk/types.js");
+__modelcontextprotocol_sdk_types_js = require_chunk.__toESM(__modelcontextprotocol_sdk_types_js);
+
+//#region package.json
+var name = "@agiflowai/scaffold-mcp";
+var description = "MCP server for scaffolding applications with boilerplate templates";
+var version = "1.0.0";
+var license = "AGPL-3.0";
+var author = "AgiflowIO";
+var repository = {
+	"type": "git",
+	"url": "https://github.com/AgiFlow/aicode-toolkit.git",
+	"directory": "packages/scaffold-mcp"
+};
+var homepage = "https://github.com/AgiFlow/aicode-toolkit#readme";
+var bugs = { "url": "https://github.com/AgiFlow/aicode-toolkit/issues" };
+var keywords = [
+	"mcp",
+	"model-context-protocol",
+	"scaffold",
+	"boilerplate",
+	"template",
+	"code-generation",
+	"nextjs",
+	"react",
+	"vite"
+];
+var bin = { "scaffold-mcp": "./dist/cli.cjs" };
+var main$1 = "./dist/index.cjs";
+var types = "./dist/index.d.cts";
+var module$1 = "./dist/index.js";
+var files = ["dist", "README.md"];
+var scripts = {
+	"dev": "node --loader ts-node/esm src/cli.ts",
+	"build": "tsdown",
+	"test": "vitest --run",
+	"typecheck": "tsc --noEmit"
+};
+var dependencies = {
+	"@agiflowai/aicode-utils": "workspace:*",
+	"@composio/json-schema-to-zod": "0.1.15",
+	"@inquirer/prompts": "^7.8.6",
+	"@modelcontextprotocol/sdk": "1.19.1",
+	"chalk": "5.6.2",
+	"commander": "14.0.1",
+	"execa": "^9.5.2",
+	"express": "^4.21.2",
+	"fs-extra": "11.3.2",
+	"js-yaml": "4.1.0",
+	"liquidjs": "10.21.1",
+	"pino": "^10.0.0",
+	"pino-pretty": "^13.1.1",
+	"zod": "3.25.76"
+};
+var devDependencies = {
+	"@types/express": "^5.0.0",
+	"@types/fs-extra": "^11.0.4",
+	"@types/js-yaml": "^4.0.9",
+	"@types/node": "^22.0.0",
+	"tsdown": "^0.15.6",
+	"typescript": "5.9.3",
+	"unplugin-raw": "^0.6.3"
+};
+var publishConfig = { "access": "public" };
+var type = "module";
+var exports$1 = {
+	".": {
+		"import": "./dist/index.js",
+		"require": "./dist/index.cjs"
+	},
+	"./cli": {
+		"import": "./dist/cli.js",
+		"require": "./dist/cli.cjs"
+	},
+	"./package.json": "./package.json"
+};
+var package_default = {
+	name,
+	description,
+	version,
+	license,
+	author,
+	repository,
+	homepage,
+	bugs,
+	keywords,
+	bin,
+	main: main$1,
+	types,
+	module: module$1,
+	files,
+	scripts,
+	dependencies,
+	devDependencies,
+	publishConfig,
+	type,
+	exports: exports$1
+};
+
+//#endregion
+//#region src/commands/boilerplate.ts
+/**
+* Boilerplate CLI command
+*/
+const boilerplateCommand = new commander.Command("boilerplate").description("Manage boilerplate templates");
+boilerplateCommand.command("list").description("List all available boilerplate templates").action(async () => {
+	try {
+		const { boilerplates } = await new require_stdio.BoilerplateService(await __agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPath()).listBoilerplates();
+		if (boilerplates.length === 0) {
+			__agiflowai_aicode_utils.messages.warning("No boilerplate templates found.");
+			return;
+		}
+		__agiflowai_aicode_utils.print.header(`\n${__agiflowai_aicode_utils.icons.package} Available Boilerplate Templates:\n`);
+		for (const bp of boilerplates) {
+			__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) __agiflowai_aicode_utils.print.debug(`    Required: ${required.join(", ")}`);
+			__agiflowai_aicode_utils.print.newline();
+		}
+	} catch (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("-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 require_stdio.BoilerplateService(await __agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPath());
+		let variables = {};
+		if (options.vars) try {
+			variables = JSON.parse(options.vars);
+		} catch (error) {
+			__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();
+			__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) {
+			__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}>`;
+			__agiflowai_aicode_utils.print.debug(`Example: scaffold-mcp boilerplate create ${boilerplateName} --vars '${JSON.stringify(exampleVars)}'`);
+			process.exit(1);
+		}
+		if (options.verbose) {
+			__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)}`);
+		}
+		__agiflowai_aicode_utils.messages.loading(`Creating project from boilerplate '${boilerplateName}'...`);
+		const result = await boilerplateService.useBoilerplate({
+			boilerplateName,
+			variables,
+			monolith: options.monolith,
+			targetFolderOverride: options.targetFolder
+		});
+		if (result.success) {
+			__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) {
+				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 {
+			__agiflowai_aicode_utils.messages.error(`Failed to create project: ${result.message}`);
+			process.exit(1);
+		}
+	} catch (error) {
+		__agiflowai_aicode_utils.messages.error("Error creating project:", error);
+		if (options.verbose) console.error("Stack trace:", error.stack);
+		process.exit(1);
+	}
+});
+boilerplateCommand.command("info <boilerplateName>").description("Show detailed information about a boilerplate template").action(async (boilerplateName) => {
+	try {
+		const bp = await new require_stdio.BoilerplateService(await __agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPath()).getBoilerplate(boilerplateName);
+		if (!bp) {
+			__agiflowai_aicode_utils.messages.error(`Boilerplate '${boilerplateName}' not found.`);
+			process.exit(1);
+		}
+		__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) __agiflowai_aicode_utils.sections.list(`${__agiflowai_aicode_utils.icons.folder} Included Files:`, bp.includes);
+	} catch (error) {
+		__agiflowai_aicode_utils.messages.error("Error getting boilerplate info:", error);
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/instructions/server.md?raw
+var server_default = "Use this MCP server to {% if isMonolith %}create your monolith project and add features (pages, components, services, etc.){% else %}create new projects and add features (pages, components, services, etc.){% endif %}.\n\n## Workflow:\n{% if not isMonolith %}\n1. **Creating New Project**: Use `list-boilerplates` → `use-boilerplate`\n2. **Adding Features**: Use `list-scaffolding-methods` → `use-scaffold-method`\n{% else %}\n1. **Creating Project**: Use `use-boilerplate` (boilerplateName auto-detected from toolkit.yaml)\n2. **Adding Features**: Use `list-scaffolding-methods` → `use-scaffold-method`\n{% endif %}\n\n## AI Usage Guidelines:\n{% if not isMonolith %}\n- Always call `list-boilerplates` first when creating new projects to see available options\n{% endif %}\n- Always call `list-scaffolding-methods` first when adding features to understand what's available\n- Follow the exact variable schema provided - validation will fail if required fields are missing\n{% if not isMonolith %}\n- Use kebab-case for project names (e.g., \"my-new-app\")\n{% else %}\n- In monolith mode, parameters like `boilerplateName` and `templateName` are auto-detected from toolkit.yaml\n- You only need to provide `variables` when calling `use-boilerplate` or `use-scaffold-method`\n{% endif %}\n- The tools automatically handle file placement, imports, and code generation\n- Check the returned JSON schemas to understand required vs optional variables\n{% if adminEnabled %}\n\n## Admin Mode (Template Generation):\n\nWhen creating custom boilerplate templates for frameworks not yet supported:\n\n1. **Create Boilerplate Configuration**: Use `generate-boilerplate` to add a new boilerplate entry to a template's scaffold.yaml\n   - Specify template name, boilerplate name, description, target folder, and variable schema\n   - This creates the scaffold.yaml structure following the nextjs-15 pattern\n   - Optional: Add detailed instruction about file purposes and design patterns\n\n2. **Create Feature Configuration**: Use `generate-feature-scaffold` to add a new feature entry to a template's scaffold.yaml\n   - Specify template name, feature name, generator, description, and variable schema\n   - This creates the scaffold.yaml structure for feature scaffolds (pages, components, etc.)\n   - Optional: Add detailed instruction about file purposes and design patterns\n   - Optional: Specify patterns to match existing files this feature works with\n\n3. **Create Template Files**: Use `generate-boilerplate-file` to create the actual template files\n   - Create files referenced in the boilerplate's or feature's includes array\n   - Use {{ variableName }} syntax for Liquid variable placeholders\n   - Can copy from existing source files or provide content directly\n   - Files automatically get .liquid extension\n\n4. **Test the Template**: Use `list-boilerplates`/`list-scaffolding-methods` and `use-boilerplate`/`use-scaffold-method` to verify your template works\n\nExample workflow for boilerplate:\n```\n1. generate-boilerplate { templateName: \"react-vite\", boilerplateName: \"scaffold-vite-app\", ... }\n2. generate-boilerplate-file { templateName: \"react-vite\", filePath: \"package.json\", content: \"...\" }\n3. generate-boilerplate-file { templateName: \"react-vite\", filePath: \"src/App.tsx\", content: \"...\" }\n4. list-boilerplates (verify it appears)\n5. use-boilerplate { boilerplateName: \"scaffold-vite-app\", variables: {...} }\n```\n\nExample workflow for feature:\n```\n1. generate-feature-scaffold { templateName: \"nextjs-15\", featureName: \"scaffold-nextjs-component\", generator: \"componentGenerator.ts\", ... }\n2. generate-boilerplate-file { templateName: \"nextjs-15\", filePath: \"src/components/Component.tsx\", content: \"...\" }\n3. list-scaffolding-methods (verify it appears)\n4. use-scaffold-method { scaffoldName: \"scaffold-nextjs-component\", variables: {...} }\n```\n{% endif %}\n";
+
+//#endregion
+//#region src/instructions/prompts/generate-boilerplate.md?raw
+var generate_boilerplate_default = "You are helping create a new boilerplate template configuration using the scaffold-mcp MCP tools.\n\n{% if request %}User request: {{ request }}\n{% endif %}\nYour task:\n\n1. **Gather Information**: Ask for any missing details:\n   - Framework/technology (e.g., \"React Vite\", \"Express API\", \"Next.js 15\")\n   - Template name (kebab-case, e.g., \"react-vite\", \"nextjs-15\")\n   - Boilerplate name (prefixed with \"scaffold-\", e.g., \"scaffold-vite-app\")\n   {% if not isMonolith %}- Target folder (e.g., \"apps\", \"packages\"){% else %}- Target folder (defaults to \".\" for monolith mode){% endif %}\n   - Project type (app, library, service, etc.)\n   - Required variables (at minimum: appName or packageName)\n   - Files to include in the template\n\n2. **Use MCP Tools** in order:\n   - `generate-boilerplate` - Creates the boilerplate configuration\n   - `generate-boilerplate-file` - Creates each template file\n   {% if not isMonolith %}- `list-boilerplates` - Verify it appears{% endif %}\n   - `use-boilerplate` - Test the boilerplate\n\nImportant:\n- Template naming: Use kebab-case (e.g., \"react-vite\", \"express-api\")\n- Boilerplate naming: Prefix with \"scaffold-\" (e.g., \"scaffold-vite-app\")\n{% if not isMonolith %}- Target folder: \"apps\" for applications, \"packages\" for libraries{% else %}- Target folder: \".\" for monolith projects (creates files at workspace root){% endif %}\n- Include files explicitly - avoid wildcards\n- Template syntax: use {{ variableName }}\n\n**Description Field Guidelines (CRITICAL)**:\nThe description should be a comprehensive multi-paragraph overview (3-5 sentences):\n- Paragraph 1: Core technology stack and primary value proposition\n- Paragraph 2: Target use cases and ideal project types\n- Paragraph 3: Key integrations or special features (if applicable)\n\nExample:\n\"A modern React SPA template powered by Vite for lightning-fast HMR, featuring TanStack Router for type-safe routing and TanStack Query for server state management.\nPerfect for building data-driven dashboards, admin panels, and interactive web applications requiring client-side routing and real-time data synchronization.\n\nIncludes Agiflow Config Management System integration with systematic environment variable naming (VITE_{CATEGORY}_{SUBCATEGORY}_{PROPERTY}) and auto-generated configuration templates for cloud deployment.\"\n\n**Instruction Field Guidelines (CRITICAL)**:\nThe instruction should be a detailed multi-section guide that helps AI understand the codebase:\n\n1. **File purposes** section: List each major file/directory with its purpose\n   Format: \"- path/to/file: Description of what this file does\"\n\n2. **How to use the scaffolded code** section: Step-by-step workflows\n   Format: Numbered list with specific examples\n   - How to add routes/pages\n   - How to fetch data\n   - How to handle authentication\n   - How to configure environment variables\n\n3. **Design patterns to follow** section: Key architectural decisions\n   Format: \"- Pattern Name: Explanation and when to use it\"\n   - Routing patterns\n   - State management patterns\n   - Data fetching patterns\n   - Error handling patterns\n   - Performance optimization patterns\n\nExample structure:\n\"[Framework] application template with [key technologies].\n\nFile purposes:\n- package.json: NPM package configuration with [framework] and dependencies\n- src/main.tsx: Application entry point with [setup details]\n- src/routes/: Route definitions following [pattern]\n[... list all major files ...]\n\nHow to use the scaffolded code:\n1. Routes: Create new routes by [specific instructions with example]\n2. Data Fetching: Use [specific pattern] for [use case]\n3. Authentication: Use [specific components/modules] for user management\n[... numbered steps for common tasks ...]\n\nDesign patterns to follow:\n- File-based Routing: Use directory structure in src/routes/ to define URL paths\n- Type-safe Routes: Leverage [framework] type inference for params\n- State Management: Use [library] for server state, [library] for client state\n[... list key patterns with explanations ...]\"\n\nTemplate File Content Guidelines:\n- Keep content MINIMAL and business-agnostic\n- Focus on structure and patterns, not business logic\n- Use placeholder/generic examples only\n- Include essential boilerplate code only\n- Let AI fill in specific logic later\n- Add clear headers with design patterns and coding standards\n";
+
+//#endregion
+//#region src/prompts/GenerateBoilerplatePrompt.ts
+/**
+* Prompt for generating boilerplates
+*/
+var GenerateBoilerplatePrompt = class GenerateBoilerplatePrompt {
+	static PROMPT_NAME = "generate-boilerplate";
+	templateService = new require_TemplateService.TemplateService();
+	constructor(isMonolith = false) {
+		this.isMonolith = isMonolith;
+	}
+	/**
+	* Get the prompt definition for MCP
+	*/
+	getDefinition() {
+		return {
+			name: GenerateBoilerplatePrompt.PROMPT_NAME,
+			description: "Generate a new boilerplate template configuration",
+			arguments: [{
+				name: "request",
+				description: "Describe the boilerplate template you want to create",
+				required: false
+			}]
+		};
+	}
+	/**
+	* Get the prompt messages
+	*/
+	getMessages(args) {
+		const request = args?.request || "";
+		return [{
+			role: "user",
+			content: {
+				type: "text",
+				text: this.templateService.renderString(generate_boilerplate_default, {
+					request,
+					isMonolith: this.isMonolith
+				})
+			}
+		}];
+	}
+};
+
+//#endregion
+//#region src/instructions/prompts/generate-feature-scaffold.md?raw
+var generate_feature_scaffold_default = "You are helping create a new feature scaffold configuration using the scaffold-mcp MCP tools.\n\n{% if request %}User request: {{ request }}\n{% endif %}\nYour task:\n\n1. **Gather Information**: Ask for any missing details:\n   {% if not isMonolith %}- Template name (e.g., \"nextjs-15\", \"react-vite\"){% else %}- Template name (will be auto-detected from toolkit.yaml){% endif %}\n   - Feature name (prefixed with \"scaffold-\", e.g., \"scaffold-nextjs-page\")\n   - Feature type (page, component, service, etc.)\n   - Variables needed\n   - Files to include\n\n2. **Use MCP Tools** in order:\n   - `generate-feature-scaffold` - Creates the feature configuration\n   - `generate-boilerplate-file` - Creates each template file\n   - `list-scaffolding-methods` - Verify it appears\n   - `use-scaffold-method` - Test the feature\n\nImportant:\n- Feature names: prefix with \"scaffold-\"\n- Conditional includes: use \"file.tsx?withLayout=true\"\n- Template syntax: use {{ variableName }}\n{% if isMonolith %}- Template name will be auto-detected from toolkit.yaml{% endif %}\n\n**Description Field Guidelines (CRITICAL)**:\nThe description should explain what the feature scaffold generates (2-3 sentences):\n- Sentence 1: What type of code it generates (component, page, service, etc.)\n- Sentence 2: Key features or capabilities included\n- Sentence 3: Primary use cases or when to use it\n\nExample:\n\"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.\"\n\n**Instruction Field Guidelines (CRITICAL)**:\nThe instruction should provide specific guidance for using the generated feature:\n\n1. **Pattern explanation**: Describe the architectural pattern used\n2. **File organization**: Where files should be placed\n3. **Naming conventions**: How to name things (PascalCase, camelCase, etc.)\n4. **Usage guidelines**: How to use the generated code\n5. **Testing approach**: How to test the feature\n\nExample structure:\n\"[Feature type] follow a [pattern name] pattern with [key characteristics].\n[Explanation of how it works and integrates with the project].\nPlace [files] in [directory].\nFor [features with X], define [Y] in [Z] for better separation of concerns.\n[Feature names] should be [case style] and [suffix/prefix rules].\nWrite comprehensive [tests/docs] for all [public methods/exports].\"\n\nKeep it concise but informative - focus on the patterns and conventions that AI needs to understand to work with the generated code effectively.\n\nTemplate File Content Guidelines:\n- Keep content MINIMAL and business-agnostic\n- Focus on structure and patterns, not business logic\n- Use placeholder/generic examples only\n- Include essential boilerplate code only\n- Let AI fill in specific logic later\n- Add clear headers with design patterns and coding standards\n";
+
+//#endregion
+//#region src/prompts/GenerateFeatureScaffoldPrompt.ts
+/**
+* Prompt for generating feature scaffolds
+*/
+var GenerateFeatureScaffoldPrompt = class GenerateFeatureScaffoldPrompt {
+	static PROMPT_NAME = "generate-feature-scaffold";
+	templateService = new require_TemplateService.TemplateService();
+	constructor(isMonolith = false) {
+		this.isMonolith = isMonolith;
+	}
+	/**
+	* Get the prompt definition for MCP
+	*/
+	getDefinition() {
+		return {
+			name: GenerateFeatureScaffoldPrompt.PROMPT_NAME,
+			description: "Generate a new feature scaffold configuration",
+			arguments: [{
+				name: "request",
+				description: "Describe the feature scaffold you want to create",
+				required: false
+			}]
+		};
+	}
+	/**
+	* Get the prompt messages
+	*/
+	getMessages(args) {
+		const request = args?.request || "";
+		return [{
+			role: "user",
+			content: {
+				type: "text",
+				text: this.templateService.renderString(generate_feature_scaffold_default, {
+					request,
+					isMonolith: this.isMonolith
+				})
+			}
+		}];
+	}
+};
+
+//#endregion
+//#region src/instructions/prompts/scaffold-application.md?raw
+var scaffold_application_default = "You are helping create a new {% if isMonolith %}monolith application{% else %}application{% endif %} using the scaffold-mcp MCP tools.\n\n{% if request %}User request: {{ request }}\n{% endif %}\nYour task is to scaffold a new application by following this workflow:\n\n## Step 1: {% if isMonolith %}Prepare to Create Application{% else %}List Available Boilerplates{% endif %}\n{% if isMonolith %}You will use the `use-boilerplate` tool to create your monolith application. The boilerplate name will be auto-detected from your toolkit.yaml file.{% else %}Use the `list-boilerplates` tool to see all available project templates.\n\n**What to look for:**\n- Boilerplate name (e.g., \"scaffold-nextjs-app\", \"scaffold-vite-app\")\n- Description of what the boilerplate creates\n- Target folder where projects will be created (e.g., \"apps\", \"packages\")\n- Required and optional variables in the variables_schema{% endif %}\n\n## Step 2: Gather Required Information\nBased on the {% if isMonolith %}toolkit.yaml{% else %}selected boilerplate's variables_schema{% endif %}, collect:\n{% if not isMonolith %}- **Project name**: Must be kebab-case (e.g., \"my-new-app\", not \"MyNewApp\")\n{% endif %}- **Required variables**: All variables marked as required: true\n- **Optional variables**: Variables with required: false (ask user if needed)\n\nCommon variables:\n- `appName` or `packageName`: The project name (kebab-case)\n- `description`: Brief description of what the project does\n- `author`: Author name\n\n## Step 3: Execute the Boilerplate\nUse the `use-boilerplate` tool with:\n{% if not isMonolith %}- `boilerplateName`: Exact name from list-boilerplates response\n{% endif %}- `variables`: Object matching the variables_schema exactly\n\n**Example:**\n```json\n{\n{% if not isMonolith %}  \"boilerplateName\": \"scaffold-nextjs-app\",\n{% endif %}  \"variables\": {\n    \"appName\": \"my-dashboard\",\n    \"description\": \"Admin dashboard for managing users\",\n    \"author\": \"John Doe\"\n  }\n}\n```\n\n## Important Guidelines:\n{% if not isMonolith %}- **Always call `list-boilerplates` first** to see available options and their schemas{% else %}- The boilerplate name is auto-detected from toolkit.yaml{% endif %}\n- **Use exact variable names** from the schema (case-sensitive)\n- **Provide all required variables** - the tool will fail if any are missing\n{% if not isMonolith %}- **Use kebab-case for project names** (e.g., \"user-dashboard\", not \"UserDashboard\")\n- The tool will create the project in the appropriate directory automatically{% else %}- The tool will create files at the workspace root{% endif %}\n- After creation, inform the user {% if isMonolith %}what files were created{% else %}where the project was created{% endif %}\n\n## Step 4: Review and Add Features (If Needed)\nAfter the boilerplate is created, **consider if additional features are needed**:\n1. **READ** the generated {% if isMonolith %}application{% else %}project{% endif %} structure to understand what was created\n2. **REVIEW** the user's request to see if they asked for specific features (e.g., \"with tool for X\", \"with prompt for Y\")\n3. **If features are needed**:\n   - Use `list-scaffolding-methods`{% if not isMonolith %} with the new project path{% endif %}\n   - Use `use-scaffold-method` to add tools, services, prompts, etc.\n   - **IMPLEMENT** the actual logic in the scaffolded feature files\n   - **REGISTER** the features in `src/server/index.ts`\n4. **Install dependencies**: Remind user to run `pnpm install`\n5. **Report** the complete setup including any features added\n\n## Example Workflow:\n{% if not isMonolith %}1. Call `list-boilerplates` → See available templates\n2. Ask user which template to use (or infer from request)\n3. Collect required variables based on schema\n4. Call `use-boilerplate` with boilerplateName and variables{% else %}1. Collect required variables based on toolkit.yaml variables_schema\n2. Call `use-boilerplate` with variables (boilerplateName auto-detected){% endif %}\n5. **Review if user requested specific features (tools, prompts, etc.)**\n6. **If features needed**: Add them using `list-scaffolding-methods` and `use-scaffold-method`\n7. **READ and IMPLEMENT** the scaffolded feature files with actual logic\n8. Report success and next steps to the user\n";
+
+//#endregion
+//#region src/prompts/ScaffoldApplicationPrompt.ts
+/**
+* Prompt for scaffolding a new application using boilerplate templates
+*/
+var ScaffoldApplicationPrompt = class ScaffoldApplicationPrompt {
+	static PROMPT_NAME = "scaffold-application";
+	templateService = new require_TemplateService.TemplateService();
+	constructor(isMonolith = false) {
+		this.isMonolith = isMonolith;
+	}
+	/**
+	* Get the prompt definition for MCP
+	*/
+	getDefinition() {
+		return {
+			name: ScaffoldApplicationPrompt.PROMPT_NAME,
+			description: "Scaffold a new application from a boilerplate template",
+			arguments: [{
+				name: "request",
+				description: "Describe the application you want to create (optional)",
+				required: false
+			}]
+		};
+	}
+	/**
+	* Get the prompt messages
+	*/
+	getMessages(args) {
+		const request = args?.request || "";
+		return [{
+			role: "user",
+			content: {
+				type: "text",
+				text: this.templateService.renderString(scaffold_application_default, {
+					request,
+					isMonolith: this.isMonolith
+				})
+			}
+		}];
+	}
+};
+
+//#endregion
+//#region src/instructions/prompts/scaffold-feature.md?raw
+var scaffold_feature_default = "You are helping add a new feature to an existing project using the scaffold-mcp MCP tools.\n\n{% if request %}User request: {{ request }}\n{% endif %}{% if projectPath %}Project path: {{ projectPath }}\n{% endif %}\nYour task is to scaffold a new feature by following this workflow:\n\n## Step 1: Identify the Project\nDetermine the project path where the feature will be added:\n- If projectPath is provided, use it\n- Otherwise, ask the user or infer from context (e.g., \"apps/my-app\", \"packages/my-lib\")\n{% if isMonolith %}- In monolith mode, you can use the current working directory (no projectPath needed){% else %}- The path should point to a directory containing a `project.json` file{% endif %}\n\n## Step 2: List Available Scaffolding Methods\nUse the `list-scaffolding-methods` tool{% if not isMonolith %} with the projectPath{% endif %}.\n\n**What to look for:**\n- Feature name (e.g., \"scaffold-nextjs-page\", \"scaffold-react-component\")\n- Description of what files/code it generates\n- Required and optional variables in the variables_schema\n- The template type (derived from project's sourceTemplate)\n\n**Example:**\n```json\n{% if isMonolith %}{}{% else %}{\n  \"projectPath\": \"apps/my-dashboard\"\n}{% endif %}\n```\n\n## Step 3: Gather Required Information\nBased on the selected scaffolding method's variables_schema, collect:\n- **Feature-specific variables**: Name, path, type, etc.\n- **Required variables**: All variables marked as required: true\n- **Optional variables**: Variables with required: false (ask user if needed)\n\nCommon variables:\n- `componentName` / `pageName` / `serviceName`: Name in PascalCase\n- `componentPath` / `pagePath`: Where to place the file (may use kebab-case)\n- Boolean flags: `withTests`, `withLayout`, `withStyles`, etc.\n\n## Step 4: Execute the Scaffolding Method\nUse the `use-scaffold-method` tool with:\n{% if not isMonolith %}- `projectPath`: Same path from step 1\n{% endif %}- `scaffold_feature_name`: Exact name from list-scaffolding-methods response\n- `variables`: Object matching the variables_schema exactly\n\n**Example:**\n```json\n{\n{% if not isMonolith %}  \"projectPath\": \"apps/my-dashboard\",\n{% endif %}  \"scaffold_feature_name\": \"scaffold-nextjs-page\",\n  \"variables\": {\n    \"pageName\": \"UserProfile\",\n    \"pagePath\": \"user/profile\",\n    \"withLayout\": true,\n    \"withTests\": false\n  }\n}\n```\n\n## Important Guidelines:\n- **Always call `list-scaffolding-methods` first**{% if not isMonolith %} with the projectPath{% endif %}\n- **Use exact variable names** from the schema (case-sensitive)\n- **Provide all required variables** - the tool will fail if any are missing\n- **Follow naming conventions**:\n  - Component/Page/Service names: PascalCase (e.g., \"UserProfile\")\n  - File paths: kebab-case or as specified in schema (e.g., \"user/profile\")\n- **Conditional files**: Files with `?condition=true` are only included when the variable is true\n- The tool will create files in the appropriate locations automatically\n- After creation, inform the user what files were created\n\n## Step 5: Review and Implement Generated Files\nAfter scaffolding completes, **you MUST**:\n1. **READ** all generated files to understand their structure\n2. **IMPLEMENT** the actual business logic:\n   - Replace TODO comments with real code\n   - Replace template placeholders with actual implementation\n   - Add the specific functionality described in the user's request\n3. **REGISTER** the feature in appropriate files:\n   - Import and register tools in `src/server/index.ts`\n   - Export new modules from `index.ts` files\n   - Update any necessary configuration files\n4. **TEST** to ensure the implementation works correctly\n5. **DO NOT SKIP** this step - scaffolded files are templates that need actual code\n\n## Example Workflow:\n1. Identify project path (provided or ask user){% if not isMonolith %}\n2. Call `list-scaffolding-methods` → See available features for this project{% else %}\n2. Call `list-scaffolding-methods` → See available features for your template{% endif %}\n3. Ask user which feature to add (or infer from request)\n4. Collect required variables based on schema\n5. Call `use-scaffold-method` with {% if not isMonolith %}projectPath, {% endif %}scaffold_feature_name, and variables\n6. **READ the generated files and IMPLEMENT the actual logic**\n7. **REGISTER the feature in server/index.ts and other config files**\n8. Report success and list created files with implementation details\n";
+
+//#endregion
+//#region src/prompts/ScaffoldFeaturePrompt.ts
+/**
+* Prompt for scaffolding a new feature in an existing project
+*/
+var ScaffoldFeaturePrompt = class ScaffoldFeaturePrompt {
+	static PROMPT_NAME = "scaffold-feature";
+	templateService = new require_TemplateService.TemplateService();
+	constructor(isMonolith = false) {
+		this.isMonolith = isMonolith;
+	}
+	/**
+	* Get the prompt definition for MCP
+	*/
+	getDefinition() {
+		return {
+			name: ScaffoldFeaturePrompt.PROMPT_NAME,
+			description: "Scaffold a new feature (page, component, service, etc.) in an existing project",
+			arguments: [{
+				name: "request",
+				description: "Describe the feature you want to add (optional)",
+				required: false
+			}, {
+				name: "projectPath",
+				description: "Path to the project (e.g., \"apps/my-app\") - optional if can be inferred",
+				required: false
+			}]
+		};
+	}
+	/**
+	* Get the prompt messages
+	*/
+	getMessages(args) {
+		const request = args?.request || "";
+		const projectPath = args?.projectPath || "";
+		return [{
+			role: "user",
+			content: {
+				type: "text",
+				text: this.templateService.renderString(scaffold_feature_default, {
+					request,
+					projectPath,
+					isMonolith: this.isMonolith
+				})
+			}
+		}];
+	}
+};
+
+//#endregion
+//#region src/server/index.ts
+function createServer(options = {}) {
+	const { adminEnabled = false, isMonolith = false } = options;
+	const templatesPath = __agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPathSync();
+	const listBoilerplatesTool = !isMonolith ? new require_stdio.ListBoilerplatesTool(templatesPath, isMonolith) : null;
+	const useBoilerplateTool = !isMonolith ? new require_stdio.UseBoilerplateTool(templatesPath, isMonolith) : null;
+	const listScaffoldingMethodsTool = new require_stdio.ListScaffoldingMethodsTool(templatesPath, isMonolith);
+	const useScaffoldMethodTool = new require_stdio.UseScaffoldMethodTool(templatesPath, isMonolith);
+	const writeToFileTool = new require_stdio.WriteToFileTool();
+	const generateBoilerplateTool = adminEnabled ? new require_stdio.GenerateBoilerplateTool(templatesPath, isMonolith) : null;
+	const generateBoilerplateFileTool = adminEnabled ? new require_stdio.GenerateBoilerplateFileTool(templatesPath, isMonolith) : null;
+	const generateFeatureScaffoldTool = adminEnabled ? new require_stdio.GenerateFeatureScaffoldTool(templatesPath, isMonolith) : null;
+	const generateBoilerplatePrompt = adminEnabled ? new GenerateBoilerplatePrompt(isMonolith) : null;
+	const generateFeatureScaffoldPrompt = adminEnabled ? new GenerateFeatureScaffoldPrompt(isMonolith) : null;
+	const scaffoldApplicationPrompt = new ScaffoldApplicationPrompt(isMonolith);
+	const scaffoldFeaturePrompt = new ScaffoldFeaturePrompt(isMonolith);
+	const instructions = new require_TemplateService.TemplateService().renderString(server_default, {
+		adminEnabled,
+		isMonolith
+	});
+	const server = new __modelcontextprotocol_sdk_server_index_js.Server({
+		name: "scaffold-mcp",
+		version: package_default.version
+	}, {
+		instructions,
+		capabilities: {
+			tools: {},
+			prompts: {}
+		}
+	});
+	server.setRequestHandler(__modelcontextprotocol_sdk_types_js.ListToolsRequestSchema, async () => {
+		const tools = [
+			listScaffoldingMethodsTool.getDefinition(),
+			useScaffoldMethodTool.getDefinition(),
+			writeToFileTool.getDefinition()
+		];
+		if (!isMonolith) {
+			if (listBoilerplatesTool) tools.unshift(listBoilerplatesTool.getDefinition());
+			if (useBoilerplateTool) tools.splice(1, 0, useBoilerplateTool.getDefinition());
+		}
+		if (adminEnabled) {
+			if (generateBoilerplateTool) tools.push(generateBoilerplateTool.getDefinition());
+			if (generateBoilerplateFileTool) tools.push(generateBoilerplateFileTool.getDefinition());
+			if (generateFeatureScaffoldTool) tools.push(generateFeatureScaffoldTool.getDefinition());
+		}
+		return { tools };
+	});
+	server.setRequestHandler(__modelcontextprotocol_sdk_types_js.CallToolRequestSchema, async (request) => {
+		const { name: name$1, arguments: args } = request.params;
+		if (name$1 === require_stdio.ListBoilerplatesTool.TOOL_NAME) {
+			if (isMonolith || !listBoilerplatesTool) throw new Error("Boilerplate tools are not available for monolith projects");
+			return await listBoilerplatesTool.execute(args || {});
+		}
+		if (name$1 === require_stdio.UseBoilerplateTool.TOOL_NAME) {
+			if (isMonolith || !useBoilerplateTool) throw new Error("Boilerplate tools are not available for monolith projects");
+			return await useBoilerplateTool.execute(args || {});
+		}
+		if (name$1 === require_stdio.ListScaffoldingMethodsTool.TOOL_NAME) return await listScaffoldingMethodsTool.execute(args || {});
+		if (name$1 === require_stdio.UseScaffoldMethodTool.TOOL_NAME) return await useScaffoldMethodTool.execute(args || {});
+		if (name$1 === require_stdio.WriteToFileTool.TOOL_NAME) return await writeToFileTool.execute(args || {});
+		if (name$1 === require_stdio.GenerateBoilerplateTool.TOOL_NAME) {
+			if (!adminEnabled || !generateBoilerplateTool) throw new Error("Admin tools are not enabled. Use --admin-enable flag to enable.");
+			return await generateBoilerplateTool.execute(args);
+		}
+		if (name$1 === require_stdio.GenerateBoilerplateFileTool.TOOL_NAME) {
+			if (!adminEnabled || !generateBoilerplateFileTool) throw new Error("Admin tools are not enabled. Use --admin-enable flag to enable.");
+			return await generateBoilerplateFileTool.execute(args);
+		}
+		if (name$1 === require_stdio.GenerateFeatureScaffoldTool.TOOL_NAME) {
+			if (!adminEnabled || !generateFeatureScaffoldTool) throw new Error("Admin tools are not enabled. Use --admin-enable flag to enable.");
+			return await generateFeatureScaffoldTool.execute(args);
+		}
+		throw new Error(`Unknown tool: ${name$1}`);
+	});
+	server.setRequestHandler(__modelcontextprotocol_sdk_types_js.ListPromptsRequestSchema, async () => {
+		const prompts = [];
+		prompts.push(scaffoldApplicationPrompt.getDefinition());
+		prompts.push(scaffoldFeaturePrompt.getDefinition());
+		if (adminEnabled) {
+			if (generateBoilerplatePrompt) prompts.push(generateBoilerplatePrompt.getDefinition());
+			if (generateFeatureScaffoldPrompt) prompts.push(generateFeatureScaffoldPrompt.getDefinition());
+		}
+		return { prompts };
+	});
+	server.setRequestHandler(__modelcontextprotocol_sdk_types_js.GetPromptRequestSchema, async (request) => {
+		const { name: name$1, arguments: args } = request.params;
+		if (name$1 === ScaffoldApplicationPrompt.PROMPT_NAME) return { messages: scaffoldApplicationPrompt.getMessages(args) };
+		if (name$1 === ScaffoldFeaturePrompt.PROMPT_NAME) return { messages: scaffoldFeaturePrompt.getMessages(args) };
+		if (name$1 === GenerateBoilerplatePrompt.PROMPT_NAME) {
+			if (!generateBoilerplatePrompt) throw new Error("Prompt not available");
+			return { messages: generateBoilerplatePrompt.getMessages(args) };
+		}
+		if (name$1 === GenerateFeatureScaffoldPrompt.PROMPT_NAME) {
+			if (!generateFeatureScaffoldPrompt) throw new Error("Prompt not available");
+			return { messages: generateFeatureScaffoldPrompt.getMessages(args) };
+		}
+		throw new Error(`Unknown prompt: ${name$1}`);
+	});
+	return server;
+}
+
+//#endregion
+//#region src/transports/types.ts
+/**
+* Transport mode types
+*/
+let TransportMode = /* @__PURE__ */ function(TransportMode$1) {
+	TransportMode$1["STDIO"] = "stdio";
+	TransportMode$1["HTTP"] = "http";
+	TransportMode$1["SSE"] = "sse";
+	TransportMode$1["CLI"] = "cli";
+	return TransportMode$1;
+}({});
+
+//#endregion
+//#region src/commands/mcp-serve.ts
+/**
+* Start MCP server with given transport handler
+*/
+async function startServer(handler) {
+	await handler.start();
+	const shutdown = async (signal) => {
+		console.error(`\nReceived ${signal}, shutting down gracefully...`);
+		try {
+			await handler.stop();
+			process.exit(0);
+		} catch (error) {
+			console.error("Error during shutdown:", error);
+			process.exit(1);
+		}
+	};
+	process.on("SIGINT", () => shutdown("SIGINT"));
+	process.on("SIGTERM", () => shutdown("SIGTERM"));
+}
+/**
+* MCP Serve command
+*/
+const mcpServeCommand = new commander.Command("mcp-serve").description("Start MCP server with specified transport").option("-t, --type <type>", "Transport type: stdio, http, or sse", "stdio").option("-p, --port <port>", "Port to listen on (http/sse only)", (val) => parseInt(val, 10), 3e3).option("--host <host>", "Host to bind to (http/sse only)", "localhost").option("--admin-enable", "Enable admin tools (generate-boilerplate)", false).action(async (options) => {
+	try {
+		const transportType = options.type.toLowerCase();
+		let isMonolith = false;
+		try {
+			isMonolith = (await __agiflowai_aicode_utils.ProjectConfigResolver.resolveProjectConfig(process.cwd())).type === "monolith";
+		} catch {
+			isMonolith = false;
+		}
+		const serverOptions = {
+			adminEnabled: options.adminEnable,
+			isMonolith
+		};
+		if (transportType === "stdio") await startServer(new require_stdio.StdioTransportHandler(createServer(serverOptions)));
+		else if (transportType === "http") await startServer(new require_stdio.HttpTransportHandler(() => createServer(serverOptions), {
+			mode: TransportMode.HTTP,
+			port: options.port || Number(process.env.MCP_PORT) || 3e3,
+			host: options.host || process.env.MCP_HOST || "localhost"
+		}));
+		else if (transportType === "sse") await startServer(new require_stdio.SseTransportHandler(() => createServer(serverOptions), {
+			mode: TransportMode.SSE,
+			port: options.port || Number(process.env.MCP_PORT) || 3e3,
+			host: options.host || process.env.MCP_HOST || "localhost"
+		}));
+		else {
+			console.error(`Unknown transport type: ${transportType}. Use: stdio, http, or sse`);
+			process.exit(1);
+		}
+	} catch (error) {
+		console.error("Failed to start MCP server:", error);
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/commands/scaffold.ts
+/**
+* Scaffold CLI command
+*/
+const scaffoldCommand = new commander.Command("scaffold").description("Add features to existing projects");
+scaffoldCommand.command("list [projectPath]").description("List available scaffolding methods for a project or template").option("-t, --template <name>", "Template name (e.g., nextjs-15, typescript-mcp-package)").action(async (projectPath, options) => {
+	try {
+		if (!projectPath && !options.template) {
+			__agiflowai_aicode_utils.messages.error("Either projectPath or --template option must be provided");
+			__agiflowai_aicode_utils.messages.hint("Examples:");
+			__agiflowai_aicode_utils.print.debug("  scaffold-mcp scaffold list ./my-project");
+			__agiflowai_aicode_utils.print.debug("  scaffold-mcp scaffold list --template nextjs-15");
+			process.exit(1);
+		}
+		const templatesDir = await __agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPath();
+		const scaffoldingMethodsService = new require_stdio.ScaffoldingMethodsService(new require_stdio.FileSystemService(), templatesDir);
+		let result;
+		let displayName;
+		if (projectPath) {
+			const absolutePath = node_path.default.resolve(projectPath);
+			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\nOr use --template option to list methods for a specific template");
+				process.exit(1);
+			}
+			result = await scaffoldingMethodsService.listScaffoldingMethods(absolutePath);
+			displayName = projectPath;
+		} else {
+			result = await scaffoldingMethodsService.listScaffoldingMethodsByTemplate(options.template);
+			displayName = `template: ${options.template}`;
+		}
+		const methods = result.methods;
+		if (methods.length === 0) {
+			__agiflowai_aicode_utils.messages.warning(`No scaffolding methods available for ${displayName}.`);
+			return;
+		}
+		__agiflowai_aicode_utils.print.header(`\n${__agiflowai_aicode_utils.icons.wrench} Available Scaffolding Methods for ${displayName}:\n`);
+		for (const method of methods) {
+			__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) {
+		__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 (!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) {
+			__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();
+		const scaffoldingMethodsService = new require_stdio.ScaffoldingMethodsService(new require_stdio.FileSystemService(), templatesDir);
+		const methods = (await scaffoldingMethodsService.listScaffoldingMethods(projectPath)).methods;
+		const method = methods.find((m) => m.name === featureName);
+		if (!method) {
+			__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) {
+			__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}>`;
+			__agiflowai_aicode_utils.print.debug(`Example: scaffold-mcp scaffold add ${featureName} --project ${options.project} --vars '${JSON.stringify(exampleVars)}'`);
+			process.exit(1);
+		}
+		if (options.verbose) {
+			__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}`);
+		}
+		__agiflowai_aicode_utils.print.info(`🚀 Adding '${featureName}' to project...`);
+		const result = await scaffoldingMethodsService.useScaffoldMethod({
+			projectPath,
+			scaffold_feature_name: featureName,
+			variables
+		});
+		if (result.success) {
+			__agiflowai_aicode_utils.messages.success("✅ Feature added successfully!");
+			if (result.createdFiles && result.createdFiles.length > 0) {
+				__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) {
+				__agiflowai_aicode_utils.messages.warning("\n⚠️  Warnings:");
+				result.warnings.forEach((warning) => __agiflowai_aicode_utils.print.debug(`   - ${warning}`));
+			}
+			__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 {
+			__agiflowai_aicode_utils.messages.error(`❌ Failed to add feature: ${result.message}`);
+			process.exit(1);
+		}
+	} catch (error) {
+		__agiflowai_aicode_utils.messages.error(`❌ Error adding feature: ${error.message}`);
+		process.exit(1);
+	}
+});
+scaffoldCommand.command("info <featureName>").description("Show detailed information about a scaffold method").option("-p, --project <path>", "Project path").option("-t, --template <name>", "Template name (e.g., nextjs-15, typescript-mcp-package)").action(async (featureName, options) => {
+	try {
+		if (!options.project && !options.template) {
+			__agiflowai_aicode_utils.messages.error("Either --project or --template option must be provided");
+			__agiflowai_aicode_utils.messages.hint("Examples:");
+			__agiflowai_aicode_utils.print.debug("  scaffold-mcp scaffold info scaffold-route --project ./my-app");
+			__agiflowai_aicode_utils.print.debug("  scaffold-mcp scaffold info scaffold-route --template nextjs-15");
+			process.exit(1);
+		}
+		const templatesDir = await __agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPath();
+		const scaffoldingMethodsService = new require_stdio.ScaffoldingMethodsService(new require_stdio.FileSystemService(), templatesDir);
+		let result;
+		if (options.project) {
+			const projectPath = node_path.default.resolve(options.project);
+			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\nOr use --template option to view info for a specific template");
+				process.exit(1);
+			}
+			result = await scaffoldingMethodsService.listScaffoldingMethods(projectPath);
+		} else result = await scaffoldingMethodsService.listScaffoldingMethodsByTemplate(options.template);
+		const method = result.methods.find((m) => m.name === featureName);
+		if (!method) {
+			__agiflowai_aicode_utils.messages.error(`❌ Scaffold method '${featureName}' not found.`);
+			process.exit(1);
+		}
+		__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:");
+		__agiflowai_aicode_utils.print.debug(JSON.stringify(method.variables_schema, null, 2));
+		const includes = "includes" in method ? method.includes : [];
+		if (includes && includes.length > 0) {
+			__agiflowai_aicode_utils.print.header("\n📁 Files to be created:");
+			includes.forEach((include) => {
+				const parts = include.split(">>");
+				if (parts.length === 2) __agiflowai_aicode_utils.print.debug(`  - ${parts[1].trim()}`);
+				else __agiflowai_aicode_utils.print.debug(`  - ${include}`);
+			});
+		}
+	} catch (error) {
+		__agiflowai_aicode_utils.messages.error(`❌ Error getting scaffold info: ${error.message}`);
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/cli.ts
+/**
+* Main entry point
+*/
+async function main() {
+	const program = new commander.Command();
+	program.name("scaffold-mcp").description("MCP server for scaffolding applications with boilerplate templates").version(package_default.version);
+	program.addCommand(mcpServeCommand);
+	program.addCommand(boilerplateCommand);
+	program.addCommand(scaffoldCommand);
+	await program.parseAsync(process.argv);
+}
+main();
+
+//#endregion