@agiflowai/scaffold-mcp 1.0.27 → 1.2.0

package/dist/cli.cjs

@@ -1,14 +1,54 @@
 #!/usr/bin/env node
-const require_ListScaffoldingMethodsTool = require('./ListScaffoldingMethodsTool-DBwZzJTA.cjs');
-const require_src = require('./src-DuOmlC4n.cjs');
-const require_tools = require('./tools-DsnQImJ1.cjs');
-let __agiflowai_aicode_utils = require("@agiflowai/aicode-utils");
+const require_ListScaffoldingMethodsTool = require("./ListScaffoldingMethodsTool-CYZtpU-W.cjs");
+const require_src = require("./src-BG_X82dw.cjs");
+const require_tools = require("./tools-COb9iBtt.cjs");
+let _agiflowai_aicode_utils = require("@agiflowai/aicode-utils");
 let node_path = require("node:path");
-node_path = require_ListScaffoldingMethodsTool.__toESM(node_path);
+node_path = require_ListScaffoldingMethodsTool.__toESM(node_path, 1);
 let commander = require("commander");
-let __agiflowai_coding_agent_bridge = require("@agiflowai/coding-agent-bridge");
-let __agiflowai_hooks_adapter = require("@agiflowai/hooks-adapter");
-
+let _agiflowai_coding_agent_bridge = require("@agiflowai/coding-agent-bridge");
+let _agiflowai_hooks_adapter = require("@agiflowai/hooks-adapter");
+//#region src/commands/utils.ts
+function parseJsonOption(value, flagName) {
+	if (!value) throw new Error(`${flagName} is required`);
+	try {
+		return JSON.parse(value);
+	} catch (error) {
+		throw new Error(`Invalid JSON for ${flagName}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+async function resolveTemplatesPath() {
+	const templatesDir = await _agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPath();
+	if (!templatesDir) throw new Error("Templates folder not found. Create a templates folder or specify templatesPath in toolkit.yaml");
+	return templatesDir;
+}
+async function detectMonolithMode() {
+	try {
+		return (await _agiflowai_aicode_utils.ProjectConfigResolver.resolveProjectConfig(process.cwd())).type === "monolith";
+	} catch {
+		return false;
+	}
+}
+async function loadTextOption(config) {
+	const { value, filePath, valueFlag, fileFlag, required = false } = config;
+	if (value !== void 0 && filePath !== void 0) throw new Error(`Use only one of ${valueFlag} or ${fileFlag}`);
+	if (filePath !== void 0) return (0, _agiflowai_aicode_utils.readFile)(filePath, "utf-8");
+	if (value !== void 0) return value;
+	if (required) throw new Error(`${valueFlag} or ${fileFlag} is required`);
+}
+function collectOption(value, previous = []) {
+	return [...previous, value];
+}
+function firstTextContent(result) {
+	const firstContent = result.content[0];
+	return firstContent?.type === "text" ? firstContent.text : "";
+}
+function assertToolSuccess(result) {
+	const text = firstTextContent(result);
+	if (result.isError) throw new Error(text || "Tool execution failed");
+	return text;
+}
+//#endregion
 //#region src/commands/boilerplate.ts
 /**
 * Boilerplate CLI command
@@ -16,40 +56,40 @@ let __agiflowai_hooks_adapter = require("@agiflowai/hooks-adapter");
 const boilerplateCommand = new commander.Command("boilerplate").description("Manage boilerplate templates");
 boilerplateCommand.command("list").description("List all available boilerplate templates").option("-c, --cursor <cursor>", "Pagination cursor for next page").action(async (options) => {
 	try {
-		const templatesDir = await __agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPath();
+		const templatesDir = await _agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPath();
 		if (!templatesDir) {
-			__agiflowai_aicode_utils.messages.error("Templates folder not found. Create a templates folder or specify templatesPath in toolkit.yaml");
+			_agiflowai_aicode_utils.messages.error("Templates folder not found. Create a templates folder or specify templatesPath in toolkit.yaml");
 			process.exit(1);
 		}
 		const { boilerplates, nextCursor } = await new require_tools.BoilerplateService(templatesDir).listBoilerplates(options.cursor);
 		if (boilerplates.length === 0) {
-			__agiflowai_aicode_utils.messages.warning("No boilerplate templates found.");
+			_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`);
+		_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}`);
+			_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();
+			if (required && required.length > 0) _agiflowai_aicode_utils.print.debug(`    Required: ${required.join(", ")}`);
+			_agiflowai_aicode_utils.print.newline();
 		}
 		if (nextCursor) {
-			__agiflowai_aicode_utils.print.newline();
-			__agiflowai_aicode_utils.print.info(`${__agiflowai_aicode_utils.icons.info} More results available. Use --cursor to fetch next page:`);
-			__agiflowai_aicode_utils.print.debug(`  scaffold-mcp boilerplate list --cursor "${nextCursor}"`);
+			_agiflowai_aicode_utils.print.newline();
+			_agiflowai_aicode_utils.print.info(`${_agiflowai_aicode_utils.icons.info} More results available. Use --cursor to fetch next page:`);
+			_agiflowai_aicode_utils.print.debug(`  scaffold-mcp boilerplate list --cursor "${nextCursor}"`);
 		}
 	} catch (error) {
-		__agiflowai_aicode_utils.messages.error("Error listing boilerplates:", error);
+		_agiflowai_aicode_utils.messages.error("Error listing boilerplates:", error);
 		process.exit(1);
 	}
 });
-boilerplateCommand.command("create <boilerplateName>").description("Create a new project from a boilerplate template").option("-v, --vars <json>", "JSON string containing variables for the boilerplate").option("-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) => {
+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("--marker <tag>", "Custom scaffold marker tag to inject into generated code files").option("--verbose", "Enable verbose logging").action(async (boilerplateName, options) => {
 	try {
-		const templatesDir = await __agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPath();
+		const templatesDir = await _agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPath();
 		if (!templatesDir) {
-			__agiflowai_aicode_utils.messages.error("Templates folder not found. Create a templates folder or specify templatesPath in toolkit.yaml");
+			_agiflowai_aicode_utils.messages.error("Templates folder not found. Create a templates folder or specify templatesPath in toolkit.yaml");
 			process.exit(1);
 		}
 		const boilerplateService = new require_tools.BoilerplateService(templatesDir);
@@ -57,8 +97,8 @@ boilerplateCommand.command("create <boilerplateName>").description("Create a new
 		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\"}'");
+			_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);
@@ -66,41 +106,42 @@ boilerplateCommand.command("create <boilerplateName>").description("Create a new
 			let allBoilerplates = [];
 			let cursor;
 			do {
-				const result$1 = await boilerplateService.listBoilerplates(cursor);
-				allBoilerplates = allBoilerplates.concat(result$1.boilerplates);
-				cursor = result$1.nextCursor;
+				const result = await boilerplateService.listBoilerplates(cursor);
+				allBoilerplates = allBoilerplates.concat(result.boilerplates);
+				cursor = result.nextCursor;
 			} while (cursor);
-			__agiflowai_aicode_utils.messages.error(`Boilerplate '${boilerplateName}' not found.`);
-			__agiflowai_aicode_utils.print.warning(`Available boilerplates: ${allBoilerplates.map((b) => b.name).join(", ")}`);
+			_agiflowai_aicode_utils.messages.error(`Boilerplate '${boilerplateName}' not found.`);
+			_agiflowai_aicode_utils.print.warning(`Available boilerplates: ${allBoilerplates.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(", ")}`);
+			_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)}'`);
+			_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.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}'...`);
+		_agiflowai_aicode_utils.messages.loading(`Creating project from boilerplate '${boilerplateName}'...`);
 		const result = await boilerplateService.useBoilerplate({
 			boilerplateName,
 			variables,
 			monolith: options.monolith,
-			targetFolderOverride: options.targetFolder
+			targetFolderOverride: options.targetFolder,
+			marker: options.marker
 		});
 		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);
+			_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);
@@ -110,43 +151,100 @@ boilerplateCommand.command("create <boilerplateName>").description("Create a new
 					"pnpm install",
 					"pnpm dev"
 				];
-				__agiflowai_aicode_utils.sections.nextSteps(steps);
+				_agiflowai_aicode_utils.sections.nextSteps(steps);
 			}
 		} else {
-			__agiflowai_aicode_utils.messages.error(`Failed to create project: ${result.message}`);
+			_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);
+		_agiflowai_aicode_utils.messages.error("Error creating project:", error);
 		if (options.verbose) console.error("Stack trace:", error.stack);
 		process.exit(1);
 	}
 });
+boilerplateCommand.command("generate <boilerplateName>").description("Create a new boilerplate configuration in a template's scaffold.yaml").option("-t, --template <name>", "Template name (optional in monolith mode)").option("--description <text>", "Boilerplate description").option("--description-file <path>", "Read boilerplate description from a file").option("--instruction <text>", "Detailed boilerplate instructions").option("--instruction-file <path>", "Read detailed boilerplate instructions from a file").option("--target-folder <path>", "Target folder for generated projects").option("--variables <json>", "JSON array of variable definitions: [{\"name\":\"appName\",\"description\":\"App name\",\"type\":\"string\",\"required\":true}]").option("-i, --include <path>", "Template include path (repeatable)", collectOption, []).action(async (boilerplateName, options) => {
+	try {
+		const templatesPath = await resolveTemplatesPath();
+		const isMonolith = await detectMonolithMode();
+		const description = await loadTextOption({
+			value: options.description,
+			filePath: options.descriptionFile,
+			valueFlag: "--description",
+			fileFlag: "--description-file",
+			required: true
+		});
+		const instruction = await loadTextOption({
+			value: options.instruction,
+			filePath: options.instructionFile,
+			valueFlag: "--instruction",
+			fileFlag: "--instruction-file"
+		});
+		const variables = parseJsonOption(options.variables, "--variables");
+		if (!Array.isArray(variables)) throw new Error("--variables must be a JSON array");
+		const targetFolder = options.targetFolder ?? (isMonolith ? "." : void 0);
+		if (!targetFolder) throw new Error("--target-folder is required outside monolith mode");
+		const result = await new require_tools.GenerateBoilerplateTool(templatesPath, isMonolith).execute({
+			templateName: options.template,
+			boilerplateName,
+			description: description ?? "",
+			instruction,
+			targetFolder,
+			variables,
+			includes: options.include ?? []
+		});
+		_agiflowai_aicode_utils.print.info(assertToolSuccess(result));
+	} catch (error) {
+		_agiflowai_aicode_utils.print.error("Error generating boilerplate:", error instanceof Error ? error.message : String(error));
+		process.exit(1);
+	}
+});
 boilerplateCommand.command("info <boilerplateName>").description("Show detailed information about a boilerplate template").action(async (boilerplateName) => {
 	try {
-		const templatesDir = await __agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPath();
+		const templatesDir = await _agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPath();
 		if (!templatesDir) {
-			__agiflowai_aicode_utils.messages.error("Templates folder not found. Create a templates folder or specify templatesPath in toolkit.yaml");
+			_agiflowai_aicode_utils.messages.error("Templates folder not found. Create a templates folder or specify templatesPath in toolkit.yaml");
 			process.exit(1);
 		}
 		const bp = await new require_tools.BoilerplateService(templatesDir).getBoilerplate(boilerplateName);
 		if (!bp) {
-			__agiflowai_aicode_utils.messages.error(`Boilerplate '${boilerplateName}' not found.`);
+			_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:`);
+		_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);
+		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/commands/file.ts
+const fileCommand$1 = new commander.Command("file").description("Workspace file utilities");
+fileCommand$1.command("write <filePath>").description("Write content to a file inside the current workspace").option("--content <text>", "Content to write").option("--content-file <path>", "Read content to write from a file").action(async (filePath, options) => {
+	try {
+		const content = await loadTextOption({
+			value: options.content,
+			filePath: options.contentFile,
+			valueFlag: "--content",
+			fileFlag: "--content-file",
+			required: true
+		});
+		const result = await new require_tools.WriteToFileTool().execute({
+			file_path: filePath,
+			content
+		});
+		_agiflowai_aicode_utils.print.info(assertToolSuccess(result));
 	} catch (error) {
-		__agiflowai_aicode_utils.messages.error("Error getting boilerplate info:", error);
+		_agiflowai_aicode_utils.print.error("Error writing file:", error instanceof Error ? error.message : String(error));
 		process.exit(1);
 	}
 });
-
 //#endregion
 //#region src/commands/mcp-serve.ts
 /**
@@ -180,7 +278,7 @@ function isRecord(value) {
 */
 function parseLlmToolOption(value, flagName) {
 	if (!value) return void 0;
-	if (!(0, __agiflowai_coding_agent_bridge.isValidLlmTool)(value)) throw new Error(`Invalid ${flagName}: ${value}. Supported: ${__agiflowai_coding_agent_bridge.SUPPORTED_LLM_TOOLS.join(", ")}`);
+	if (!(0, _agiflowai_coding_agent_bridge.isValidLlmTool)(value)) throw new Error(`Invalid ${flagName}: ${value}. Supported: ${_agiflowai_coding_agent_bridge.SUPPORTED_LLM_TOOLS.join(", ")}`);
 	return value;
 }
 /**
@@ -217,12 +315,12 @@ async function startServer(handler) {
 		throw new Error(`Failed to start transport: ${error instanceof Error ? error.message : String(error)}`);
 	}
 	const shutdown = async (signal) => {
-		__agiflowai_aicode_utils.print.error(`\nReceived ${signal}, shutting down gracefully...`);
+		_agiflowai_aicode_utils.print.error(`\nReceived ${signal}, shutting down gracefully...`);
 		try {
 			await handler.stop();
 			process.exit(0);
 		} catch (error) {
-			__agiflowai_aicode_utils.print.error("Error during shutdown:", error instanceof Error ? error : String(error));
+			_agiflowai_aicode_utils.print.error("Error during shutdown:", error instanceof Error ? error : String(error));
 			process.exit(1);
 		}
 	};
@@ -230,23 +328,23 @@ async function startServer(handler) {
 		try {
 			await shutdown("SIGINT");
 		} catch (error) {
-			__agiflowai_aicode_utils.print.error("Unexpected shutdown error:", error instanceof Error ? error : String(error));
+			_agiflowai_aicode_utils.print.error("Unexpected shutdown error:", error instanceof Error ? error : String(error));
 		}
 	});
 	process.on("SIGTERM", async () => {
 		try {
 			await shutdown("SIGTERM");
 		} catch (error) {
-			__agiflowai_aicode_utils.print.error("Unexpected shutdown error:", error instanceof Error ? error : String(error));
+			_agiflowai_aicode_utils.print.error("Unexpected shutdown error:", error instanceof Error ? error : String(error));
 		}
 	});
 }
 /**
 * 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").option("-p, --port <port>", "Port to listen on (http/sse only)", (val) => parseInt(val, 10)).option("--host <host>", "Host to bind to (http/sse only)").option("--admin-enable", "Enable admin tools (generate-boilerplate)", false).option("--prompt-as-skill", "Render prompts with skill front matter for Claude Code skills", false).option("--fallback-tool <tool>", `Fallback LLM tool for scaffold operations. Supported: ${__agiflowai_coding_agent_bridge.SUPPORTED_LLM_TOOLS.join(", ")}`).option("--fallback-tool-config <json>", "JSON config for fallback tool (e.g., '{\"model\":\"claude-sonnet-4-6\"}')").action(async (options) => {
+const mcpServeCommand = new commander.Command("mcp-serve").description("Start MCP server with specified transport").option("-t, --type <type>", "Transport type: stdio, http, or sse").option("-p, --port <port>", "Port to listen on (http/sse only)", (val) => parseInt(val, 10)).option("--host <host>", "Host to bind to (http/sse only)").option("--admin-enable", "Enable admin tools (generate-boilerplate)", false).option("--prompt-as-skill", "Render prompts with skill front matter for Claude Code skills", false).option("--fallback-tool <tool>", `Fallback LLM tool for scaffold operations. Supported: ${_agiflowai_coding_agent_bridge.SUPPORTED_LLM_TOOLS.join(", ")}`).option("--fallback-tool-config <json>", "JSON config for fallback tool (e.g., '{\"model\":\"claude-sonnet-4-6\"}')").action(async (options) => {
 	try {
-		const fileConfig = (await __agiflowai_aicode_utils.TemplatesManagerService.readToolkitConfig())?.["scaffold-mcp"]?.["mcp-serve"] ?? {};
+		const fileConfig = (await _agiflowai_aicode_utils.TemplatesManagerService.readToolkitConfig())?.["scaffold-mcp"]?.["mcp-serve"] ?? {};
 		const transportType = (options.type ?? fileConfig.type ?? "stdio").toLowerCase();
 		const adminEnable = options.adminEnable || fileConfig.adminEnable || false;
 		const promptAsSkill = options.promptAsSkill || fileConfig.promptAsSkill || false;
@@ -255,9 +353,9 @@ const mcpServeCommand = new commander.Command("mcp-serve").description("Start MC
 		const fallbackToolConfig = options.fallbackToolConfig ? parseJsonConfig(options.fallbackToolConfig, "--fallback-tool-config") : configuredFallback.config;
 		let isMonolith = false;
 		try {
-			isMonolith = (await __agiflowai_aicode_utils.ProjectConfigResolver.resolveProjectConfig(process.cwd())).type === "monolith";
+			isMonolith = (await _agiflowai_aicode_utils.ProjectConfigResolver.resolveProjectConfig(process.cwd())).type === "monolith";
 		} catch (error) {
-			__agiflowai_aicode_utils.print.info(`No project config found, defaulting to monorepo mode: ${error instanceof Error ? error.message : String(error)}`);
+			_agiflowai_aicode_utils.print.info(`No project config found, defaulting to monorepo mode: ${error instanceof Error ? error.message : String(error)}`);
 			isMonolith = false;
 		}
 		const serverOptions = {
@@ -285,15 +383,14 @@ const mcpServeCommand = new commander.Command("mcp-serve").description("Start MC
 				host
 			}));
 		} else {
-			__agiflowai_aicode_utils.print.error(`Unknown transport type: ${transportType}. Use: stdio, http, or sse`);
+			_agiflowai_aicode_utils.print.error(`Unknown transport type: ${transportType}. Use: stdio, http, or sse`);
 			process.exit(1);
 		}
 	} catch (error) {
-		__agiflowai_aicode_utils.print.error("Failed to start MCP server:", error instanceof Error ? error : String(error));
+		_agiflowai_aicode_utils.print.error("Failed to start MCP server:", error instanceof Error ? error : String(error));
 		process.exit(1);
 	}
 });
-
 //#endregion
 //#region src/commands/scaffold.ts
 /**
@@ -302,77 +399,71 @@ const mcpServeCommand = new commander.Command("mcp-serve").description("Start MC
 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)").option("-c, --cursor <cursor>", "Pagination cursor for next page").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 templatesDir = await _agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPath();
 		if (!templatesDir) {
-			__agiflowai_aicode_utils.messages.error("Templates folder not found. Create a templates folder or specify templatesPath in toolkit.yaml");
+			_agiflowai_aicode_utils.messages.error("Templates folder not found. Create a templates folder or specify templatesPath in toolkit.yaml");
 			process.exit(1);
 		}
 		const scaffoldingMethodsService = new require_ListScaffoldingMethodsTool.ScaffoldingMethodsService(new require_ListScaffoldingMethodsTool.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");
+		if (projectPath || !options.template) {
+			const inputProjectPath = projectPath ?? process.cwd();
+			const absolutePath = node_path.default.resolve(inputProjectPath);
+			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, options.cursor);
-			displayName = projectPath;
+			displayName = projectPath ?? absolutePath;
 		} else {
 			result = await scaffoldingMethodsService.listScaffoldingMethodsByTemplate(options.template, options.cursor);
 			displayName = `template: ${options.template}`;
 		}
 		const methods = result.methods;
 		if (methods.length === 0) {
-			__agiflowai_aicode_utils.messages.warning(`No scaffolding methods available for ${displayName}.`);
+			_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`);
+		_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();
+			_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();
 		}
 		if (result.nextCursor) {
-			__agiflowai_aicode_utils.print.newline();
-			__agiflowai_aicode_utils.print.info(`${__agiflowai_aicode_utils.icons.info} More results available. Use --cursor to fetch next page:`);
+			_agiflowai_aicode_utils.print.newline();
+			_agiflowai_aicode_utils.print.info(`${_agiflowai_aicode_utils.icons.info} More results available. Use --cursor to fetch next page:`);
 			const cursorOption = `--cursor "${result.nextCursor}"`;
-			if (projectPath) __agiflowai_aicode_utils.print.debug(`  scaffold-mcp scaffold list ${projectPath} ${cursorOption}`);
-			else __agiflowai_aicode_utils.print.debug(`  scaffold-mcp scaffold list --template ${options.template} ${cursorOption}`);
+			if (projectPath) _agiflowai_aicode_utils.print.debug(`  scaffold-mcp scaffold list ${projectPath} ${cursorOption}`);
+			else _agiflowai_aicode_utils.print.debug(`  scaffold-mcp scaffold list --template ${options.template} ${cursorOption}`);
 		}
 	} catch (error) {
-		__agiflowai_aicode_utils.messages.error("Error listing scaffolding methods:", error);
+		_agiflowai_aicode_utils.messages.error("Error listing scaffolding methods:", error);
 		process.exit(1);
 	}
 });
-scaffoldCommand.command("add <featureName>").description("Add a feature to an existing project").option("-p, --project <path>", "Project path", process.cwd()).option("-v, --vars <json>", "JSON string containing variables for the feature").option("--verbose", "Enable verbose logging").action(async (featureName, options) => {
+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("--marker <tag>", "Custom scaffold marker tag to inject into generated code files").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");
+		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\"}'");
+			_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 templatesDir = await _agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPath();
 		if (!templatesDir) {
-			__agiflowai_aicode_utils.messages.error("Templates folder not found. Create a templates folder or specify templatesPath in toolkit.yaml");
+			_agiflowai_aicode_utils.messages.error("Templates folder not found. Create a templates folder or specify templatesPath in toolkit.yaml");
 			process.exit(1);
 		}
 		const scaffoldingMethodsService = new require_ListScaffoldingMethodsTool.ScaffoldingMethodsService(new require_ListScaffoldingMethodsTool.FileSystemService(), templatesDir);
@@ -385,73 +476,116 @@ scaffoldCommand.command("add <featureName>").description("Add a feature to an ex
 		} while (cursor);
 		const method = allMethods.find((m) => m.name === featureName);
 		if (!method) {
-			__agiflowai_aicode_utils.messages.error(`Scaffold method '${featureName}' not found.`);
-			__agiflowai_aicode_utils.print.warning(`Available methods: ${allMethods.map((m) => m.name).join(", ")}`);
-			__agiflowai_aicode_utils.print.debug(`Run 'scaffold-mcp scaffold list ${options.project}' to see all available methods`);
+			_agiflowai_aicode_utils.messages.error(`Scaffold method '${featureName}' not found.`);
+			_agiflowai_aicode_utils.print.warning(`Available methods: ${allMethods.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(", ")}`);
+			_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)}'`);
+			_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(`🔧 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...`);
+		_agiflowai_aicode_utils.print.info(`🚀 Adding '${featureName}' to project...`);
 		const result = await scaffoldingMethodsService.useScaffoldMethod({
 			projectPath,
 			scaffold_feature_name: featureName,
-			variables
+			variables,
+			marker: options.marker
 		});
 		if (result.success) {
-			__agiflowai_aicode_utils.messages.success("✅ Feature added successfully!");
+			const scaffoldId = (0, _agiflowai_aicode_utils.generateStableId)(6);
+			if (result.createdFiles && result.createdFiles.length > 0) await require_tools.writePendingScaffoldLog({
+				scaffoldId,
+				projectPath,
+				featureName,
+				generatedFiles: result.createdFiles
+			});
+			_agiflowai_aicode_utils.messages.success("✅ Feature added successfully!");
 			if (result.createdFiles && result.createdFiles.length > 0) {
-				__agiflowai_aicode_utils.print.header("\n📁 Created files:");
+				_agiflowai_aicode_utils.print.header("\n📁 Created files:");
 				result.createdFiles.forEach((file) => {
-					__agiflowai_aicode_utils.print.debug(`   - ${file}`);
+					_agiflowai_aicode_utils.print.debug(`   - ${file}`);
 				});
 			}
 			if (result.warnings && result.warnings.length > 0) {
-				__agiflowai_aicode_utils.messages.warning("\n⚠️  Warnings:");
+				_agiflowai_aicode_utils.messages.warning("\n⚠️  Warnings:");
 				result.warnings.forEach((warning) => {
-					__agiflowai_aicode_utils.print.debug(`   - ${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");
+			_agiflowai_aicode_utils.print.debug(`\nSCAFFOLD_ID:${scaffoldId}`);
+			_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}`);
+			_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}`);
+		_agiflowai_aicode_utils.messages.error(`❌ Error adding feature: ${error.message}`);
+		process.exit(1);
+	}
+});
+scaffoldCommand.command("generate <featureName>").description("Create a new feature scaffold configuration in a template's scaffold.yaml").option("-t, --template <name>", "Template name (optional in monolith mode)").option("--description <text>", "Feature description").option("--description-file <path>", "Read feature description from a file").option("--instruction <text>", "Detailed feature instructions").option("--instruction-file <path>", "Read detailed feature instructions from a file").option("--variables <json>", "JSON array of variable definitions: [{\"name\":\"featureName\",\"description\":\"Feature name\",\"type\":\"string\",\"required\":true}]").option("-i, --include <path>", "Template include path (repeatable)", collectOption, []).option("--pattern <glob>", "File pattern this scaffold applies to (repeatable)", collectOption, []).action(async (featureName, options) => {
+	try {
+		const templatesPath = await resolveTemplatesPath();
+		const isMonolith = await detectMonolithMode();
+		const description = await loadTextOption({
+			value: options.description,
+			filePath: options.descriptionFile,
+			valueFlag: "--description",
+			fileFlag: "--description-file",
+			required: true
+		});
+		const instruction = await loadTextOption({
+			value: options.instruction,
+			filePath: options.instructionFile,
+			valueFlag: "--instruction",
+			fileFlag: "--instruction-file"
+		});
+		const variables = parseJsonOption(options.variables, "--variables");
+		if (!Array.isArray(variables)) throw new Error("--variables must be a JSON array");
+		const result = await new require_tools.GenerateFeatureScaffoldTool(templatesPath, isMonolith).execute({
+			templateName: options.template,
+			featureName,
+			description: description ?? "",
+			instruction,
+			variables,
+			includes: options.include ?? [],
+			patterns: options.pattern ?? []
+		});
+		_agiflowai_aicode_utils.print.info(assertToolSuccess(result));
+	} catch (error) {
+		_agiflowai_aicode_utils.print.error("Error generating feature scaffold:", error instanceof Error ? error.message : String(error));
 		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");
+			_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 templatesDir = await _agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPath();
 		if (!templatesDir) {
-			__agiflowai_aicode_utils.messages.error("Templates folder not found. Create a templates folder or specify templatesPath in toolkit.yaml");
+			_agiflowai_aicode_utils.messages.error("Templates folder not found. Create a templates folder or specify templatesPath in toolkit.yaml");
 			process.exit(1);
 		}
 		const scaffoldingMethodsService = new require_ListScaffoldingMethodsTool.ScaffoldingMethodsService(new require_ListScaffoldingMethodsTool.FileSystemService(), templatesDir);
@@ -459,9 +593,9 @@ scaffoldCommand.command("info <featureName>").description("Show detailed informa
 		let cursor;
 		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");
+			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);
 			}
 			do {
@@ -476,28 +610,27 @@ scaffoldCommand.command("info <featureName>").description("Show detailed informa
 		} while (cursor);
 		const method = allMethods.find((m) => m.name === featureName);
 		if (!method) {
-			__agiflowai_aicode_utils.messages.error(`❌ Scaffold method '${featureName}' not found.`);
+			_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));
+		_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:");
+			_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}`);
+				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}`);
+		_agiflowai_aicode_utils.messages.error(`❌ Error getting scaffold info: ${error.message}`);
 		process.exit(1);
 	}
 });
-
 //#endregion
 //#region src/commands/hook.ts
 /**
@@ -563,23 +696,23 @@ function resolveFallbackConfig(config) {
 /**
 * Hook command for executing scaffold hooks
 */
-const hookCommand = new commander.Command("hook").description("Execute scaffold hooks for AI agent integrations").option("--type <agentAndMethod>", "Hook type: <agent>.<method> (e.g., claude-code.postToolUse, gemini-cli.postToolUse)").option("--marker <tag>", "Scaffold marker tag to scan for in phantom code check").option("--fallback-tool <tool>", `Fallback LLM tool for scaffold operations. Supported: ${__agiflowai_coding_agent_bridge.SUPPORTED_LLM_TOOLS.join(", ")}`).option("--fallback-tool-config <json>", "JSON config for the fallback tool (e.g., '{\"model\":\"claude-sonnet-4-6\"}')").action(async (options) => {
+const hookCommand = new commander.Command("hook").description("Execute scaffold hooks for AI agent integrations").option("--type <agentAndMethod>", "Hook type: <agent>.<method> (e.g., claude-code.postToolUse, gemini-cli.postToolUse)").option("--marker <tag>", "Scaffold marker tag to scan for in phantom code check").option("--fallback-tool <tool>", `Fallback LLM tool for scaffold operations. Supported: ${_agiflowai_coding_agent_bridge.SUPPORTED_LLM_TOOLS.join(", ")}`).option("--fallback-tool-config <json>", "JSON config for the fallback tool (e.g., '{\"model\":\"claude-sonnet-4-6\"}')").action(async (options) => {
 	try {
 		if (!options.type) throw new Error("--type option is required. Examples: claude-code.preToolUse, claude-code.postToolUse, gemini-cli.postToolUse");
-		const { agent, hookMethod } = (0, __agiflowai_hooks_adapter.parseHookType)(options.type);
-		const methodConfig = ((await __agiflowai_aicode_utils.TemplatesManagerService.readToolkitConfig())?.["scaffold-mcp"]?.hook)?.[agent]?.[hookMethod];
+		const { agent, hookMethod } = (0, _agiflowai_hooks_adapter.parseHookType)(options.type);
+		const methodConfig = ((await _agiflowai_aicode_utils.TemplatesManagerService.readToolkitConfig())?.["scaffold-mcp"]?.hook)?.[agent]?.[hookMethod];
 		const marker = options.marker ?? "@scaffold-generated";
 		const configuredFallback = resolveFallbackConfig(methodConfig);
 		const fallbackToolStr = options.fallbackTool ?? methodConfig?.["fallback-tool"] ?? methodConfig?.["llm-tool"] ?? configuredFallback.tool;
 		const fallbackToolConfig = options.fallbackToolConfig ? parseJsonConfigOption(options.fallbackToolConfig, "--fallback-tool-config") : methodConfig?.["fallback-tool-config"] ?? methodConfig?.["tool-config"] ?? configuredFallback.config;
-		if (fallbackToolStr && !(0, __agiflowai_coding_agent_bridge.isValidLlmTool)(fallbackToolStr)) throw new Error(`Invalid --fallback-tool: ${fallbackToolStr}. Supported: ${__agiflowai_coding_agent_bridge.SUPPORTED_LLM_TOOLS.join(", ")}`);
+		if (fallbackToolStr && !(0, _agiflowai_coding_agent_bridge.isValidLlmTool)(fallbackToolStr)) throw new Error(`Invalid --fallback-tool: ${fallbackToolStr}. Supported: ${_agiflowai_coding_agent_bridge.SUPPORTED_LLM_TOOLS.join(", ")}`);
 		const adapterConfig = {};
 		if (fallbackToolConfig) adapterConfig.tool_config = fallbackToolConfig;
 		if (fallbackToolStr) adapterConfig.llm_tool = fallbackToolStr;
 		const resolvedAdapterConfig = Object.keys(adapterConfig).length > 0 ? adapterConfig : void 0;
 		if (!isHookMethod(hookMethod)) process.exit(0);
-		if (agent === __agiflowai_coding_agent_bridge.CLAUDE_CODE) {
-			const hookModule = await Promise.resolve().then(() => require("./claudeCode-B6CWgRYJ.cjs"));
+		if (agent === _agiflowai_coding_agent_bridge.CLAUDE_CODE) {
+			const hookModule = await Promise.resolve().then(() => require("./claudeCode-g1eRidPR.cjs"));
 			const claudeCallbacks = [];
 			if (hookModule.UseScaffoldMethodHook) {
 				const hookInstance = new hookModule.UseScaffoldMethodHook();
@@ -592,9 +725,9 @@ const hookCommand = new commander.Command("hook").description("Execute scaffold
 				if (hookFn) claudeCallbacks.push(hookFn.bind(hookInstance));
 			}
 			if (claudeCallbacks.length === 0) process.exit(0);
-			await new __agiflowai_hooks_adapter.ClaudeCodeAdapter().executeMultiple(claudeCallbacks, resolvedAdapterConfig);
-		} else if (agent === __agiflowai_coding_agent_bridge.GEMINI_CLI) {
-			const hookModule = await Promise.resolve().then(() => require("./geminiCli-COS3X1P7.cjs"));
+			await new _agiflowai_hooks_adapter.ClaudeCodeAdapter().executeMultiple(claudeCallbacks, resolvedAdapterConfig);
+		} else if (agent === _agiflowai_coding_agent_bridge.GEMINI_CLI) {
+			const hookModule = await Promise.resolve().then(() => require("./geminiCli--s1Qy7ZP.cjs"));
 			const geminiCallbacks = [];
 			if (hookModule.UseScaffoldMethodHook) {
 				const hookInstance = new hookModule.UseScaffoldMethodHook();
@@ -602,14 +735,52 @@ const hookCommand = new commander.Command("hook").description("Execute scaffold
 				if (hookFn) geminiCallbacks.push(hookFn.bind(hookInstance));
 			}
 			if (geminiCallbacks.length === 0) process.exit(0);
-			await new __agiflowai_hooks_adapter.GeminiCliAdapter().executeMultiple(geminiCallbacks, resolvedAdapterConfig);
-		} else throw new Error(`Unsupported agent: ${agent}. Supported: ${__agiflowai_coding_agent_bridge.CLAUDE_CODE}, ${__agiflowai_coding_agent_bridge.GEMINI_CLI}`);
+			await new _agiflowai_hooks_adapter.GeminiCliAdapter().executeMultiple(geminiCallbacks, resolvedAdapterConfig);
+		} else throw new Error(`Unsupported agent: ${agent}. Supported: ${_agiflowai_coding_agent_bridge.CLAUDE_CODE}, ${_agiflowai_coding_agent_bridge.GEMINI_CLI}`);
+	} catch (error) {
+		_agiflowai_aicode_utils.print.error(`Hook error: ${error instanceof Error ? error.message : String(error)}`);
+		process.exit(1);
+	}
+});
+//#endregion
+//#region src/commands/template.ts
+const templateCommand = new commander.Command("template").description("Manage scaffold template authoring assets");
+const fileCommand = new commander.Command("file").description("Manage template files");
+fileCommand.command("create <filePath>").description("Create or update a Liquid template file for a boilerplate or feature").option("-t, --template <name>", "Template name (optional in monolith mode)").option("--content <text>", "Template file content").option("--content-file <path>", "Read template file content from a file").option("--source-file <path>", "Copy content from an existing source file").option("--header <text>", "Header comment to prepend to the template file").option("--header-file <path>", "Read header comment from a file").action(async (filePath, options) => {
+	try {
+		if ([
+			options.content !== void 0,
+			options.contentFile !== void 0,
+			options.sourceFile !== void 0
+		].filter(Boolean).length !== 1) throw new Error("Use exactly one of --content, --content-file, or --source-file");
+		const templatesPath = await resolveTemplatesPath();
+		const isMonolith = await detectMonolithMode();
+		const content = await loadTextOption({
+			value: options.content,
+			filePath: options.contentFile,
+			valueFlag: "--content",
+			fileFlag: "--content-file"
+		});
+		const header = await loadTextOption({
+			value: options.header,
+			filePath: options.headerFile,
+			valueFlag: "--header",
+			fileFlag: "--header-file"
+		});
+		const result = await new require_tools.GenerateBoilerplateFileTool(templatesPath, isMonolith).execute({
+			templateName: options.template,
+			filePath,
+			content,
+			sourceFile: options.sourceFile,
+			header
+		});
+		_agiflowai_aicode_utils.print.info(assertToolSuccess(result));
 	} catch (error) {
-		__agiflowai_aicode_utils.print.error(`Hook error: ${error instanceof Error ? error.message : String(error)}`);
+		_agiflowai_aicode_utils.print.error("Error creating template file:", error instanceof Error ? error.message : String(error));
 		process.exit(1);
 	}
 });
-
+templateCommand.addCommand(fileCommand);
 //#endregion
 //#region src/cli.ts
 /**
@@ -621,9 +792,10 @@ async function main() {
 	program.addCommand(mcpServeCommand);
 	program.addCommand(boilerplateCommand);
 	program.addCommand(scaffoldCommand);
+	program.addCommand(templateCommand);
+	program.addCommand(fileCommand$1);
 	program.addCommand(hookCommand);
 	await program.parseAsync(process.argv);
 }
 main();
-
-//#endregion
+//#endregion