@agiflowai/scaffold-mcp 1.0.6 → 1.0.8

package/dist/ListScaffoldingMethodsTool-BuxKRbwi.cjs

@@ -0,0 +1,376 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const require_TemplateService = require('./TemplateService-CAD8jkoO.cjs');
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let __agiflowai_aicode_utils = require("@agiflowai/aicode-utils");
+let js_yaml = require("js-yaml");
+js_yaml = require_chunk.__toESM(js_yaml);
+
+//#region src/utils/pagination.ts
+var PaginationHelper = class PaginationHelper {
+	/**
+	* Default page size for pagination
+	*/
+	static DEFAULT_PAGE_SIZE = 10;
+	/**
+	* Decodes a cursor string to extract the start index
+	* @param cursor - String representing the start index (e.g., "10")
+	* @returns Start index or 0 if invalid/undefined
+	*/
+	static decodeCursor(cursor) {
+		if (!cursor) return 0;
+		const index = Number.parseInt(cursor, 10);
+		if (Number.isNaN(index) || index < 0) return 0;
+		return index;
+	}
+	/**
+	* Encodes an index into a cursor string
+	* @param index - Start index to encode
+	* @returns Cursor string (e.g., "10")
+	*/
+	static encodeCursor(index) {
+		return index.toString();
+	}
+	/**
+	* Paginates an array of items
+	* @param items - All items to paginate
+	* @param cursor - Optional cursor representing the start index
+	* @param pageSize - Number of items per page (default: 10)
+	* @param includeMeta - Whether to include metadata in response (default: true)
+	* @returns Paginated result with items and optional nextCursor
+	*/
+	static paginate(items, cursor, pageSize = PaginationHelper.DEFAULT_PAGE_SIZE, includeMeta = true) {
+		const startIndex = PaginationHelper.decodeCursor(cursor);
+		const endIndex = startIndex + pageSize;
+		const result = {
+			items: items.slice(startIndex, endIndex),
+			nextCursor: endIndex < items.length ? PaginationHelper.encodeCursor(endIndex) : void 0
+		};
+		if (includeMeta) result._meta = {
+			total: items.length,
+			offset: startIndex,
+			limit: pageSize
+		};
+		return result;
+	}
+};
+
+//#endregion
+//#region src/services/FileSystemService.ts
+var FileSystemService = class {
+	async pathExists(path$1) {
+		return (0, __agiflowai_aicode_utils.pathExists)(path$1);
+	}
+	async readFile(path$1, encoding = "utf8") {
+		return (0, __agiflowai_aicode_utils.readFile)(path$1, encoding);
+	}
+	async readJson(path$1) {
+		return (0, __agiflowai_aicode_utils.readJson)(path$1);
+	}
+	async writeFile(path$1, content, encoding = "utf8") {
+		return (0, __agiflowai_aicode_utils.writeFile)(path$1, content, encoding);
+	}
+	async ensureDir(path$1) {
+		return (0, __agiflowai_aicode_utils.ensureDir)(path$1);
+	}
+	async copy(src, dest) {
+		return (0, __agiflowai_aicode_utils.copy)(src, dest);
+	}
+	async readdir(path$1) {
+		return (0, __agiflowai_aicode_utils.readdir)(path$1);
+	}
+	async stat(path$1) {
+		return (0, __agiflowai_aicode_utils.stat)(path$1);
+	}
+};
+
+//#endregion
+//#region src/services/ScaffoldingMethodsService.ts
+var ScaffoldingMethodsService = class {
+	templateService;
+	constructor(fileSystem, templatesRootPath) {
+		this.fileSystem = fileSystem;
+		this.templatesRootPath = templatesRootPath;
+		this.templateService = new require_TemplateService.TemplateService();
+	}
+	async listScaffoldingMethods(projectPath, cursor) {
+		const absoluteProjectPath = node_path.default.resolve(projectPath);
+		const sourceTemplate = (await __agiflowai_aicode_utils.ProjectConfigResolver.resolveProjectConfig(absoluteProjectPath)).sourceTemplate;
+		return this.listScaffoldingMethodsByTemplate(sourceTemplate, cursor);
+	}
+	async listScaffoldingMethodsByTemplate(templateName, cursor) {
+		const templatePath = await this.findTemplatePath(templateName);
+		if (!templatePath) throw new Error(`Template not found for sourceTemplate: ${templateName}`);
+		const fullTemplatePath = node_path.default.join(this.templatesRootPath, templatePath);
+		const scaffoldYamlPath = node_path.default.join(fullTemplatePath, "scaffold.yaml");
+		if (!await this.fileSystem.pathExists(scaffoldYamlPath)) throw new Error(`scaffold.yaml not found at ${scaffoldYamlPath}`);
+		const scaffoldContent = await this.fileSystem.readFile(scaffoldYamlPath, "utf8");
+		const architectConfig = js_yaml.default.load(scaffoldContent);
+		const methods = [];
+		if (architectConfig.features && Array.isArray(architectConfig.features)) architectConfig.features.forEach((feature) => {
+			const featureName = feature.name || `scaffold-${templateName}`;
+			methods.push({
+				name: featureName,
+				description: feature.description || "",
+				instruction: feature.instruction || "",
+				variables_schema: feature.variables_schema || {
+					type: "object",
+					properties: {},
+					required: [],
+					additionalProperties: false
+				},
+				generator: feature.generator
+			});
+		});
+		const paginatedResult = PaginationHelper.paginate(methods, cursor);
+		return {
+			sourceTemplate: templateName,
+			templatePath,
+			methods: paginatedResult.items,
+			nextCursor: paginatedResult.nextCursor,
+			_meta: paginatedResult._meta
+		};
+	}
+	/**
+	* Gets scaffolding methods with instructions rendered using provided variables
+	*/
+	async listScaffoldingMethodsWithVariables(projectPath, variables, cursor) {
+		const result = await this.listScaffoldingMethods(projectPath, cursor);
+		const processedMethods = result.methods.map((method) => ({
+			...method,
+			instruction: method.instruction ? this.processScaffoldInstruction(method.instruction, variables) : void 0
+		}));
+		return {
+			...result,
+			methods: processedMethods
+		};
+	}
+	/**
+	* Processes scaffold instruction with template service
+	*/
+	processScaffoldInstruction(instruction, variables) {
+		if (this.templateService.containsTemplateVariables(instruction)) return this.templateService.renderString(instruction, variables);
+		return instruction;
+	}
+	async findTemplatePath(sourceTemplate) {
+		const templateDirs = await this.discoverTemplateDirs();
+		if (templateDirs.includes(sourceTemplate)) return sourceTemplate;
+		for (const templateDir of templateDirs) {
+			const templatePath = node_path.default.join(this.templatesRootPath, templateDir);
+			const scaffoldYamlPath = node_path.default.join(templatePath, "scaffold.yaml");
+			if (await this.fileSystem.pathExists(scaffoldYamlPath)) try {
+				const scaffoldContent = await this.fileSystem.readFile(scaffoldYamlPath, "utf8");
+				const architectConfig = js_yaml.default.load(scaffoldContent);
+				if (architectConfig.boilerplate && Array.isArray(architectConfig.boilerplate)) {
+					for (const boilerplate of architectConfig.boilerplate) if (boilerplate.name?.includes(sourceTemplate)) return templateDir;
+				}
+			} catch (error) {
+				__agiflowai_aicode_utils.log.warn(`Failed to read scaffold.yaml at ${scaffoldYamlPath}:`, error);
+			}
+		}
+		return null;
+	}
+	/**
+	* Resolves the project path, handling both monorepo and monolith cases
+	* Uses ProjectConfigResolver to find the correct workspace/project root
+	*/
+	async resolveProjectPath(projectPath) {
+		const absolutePath = node_path.default.resolve(projectPath);
+		return (await __agiflowai_aicode_utils.ProjectConfigResolver.resolveProjectConfig(absolutePath)).workspaceRoot || absolutePath;
+	}
+	/**
+	* Dynamically discovers all template directories
+	* Supports both flat structure (templates/nextjs-15) and nested structure (templates/apps/nextjs-15)
+	**/
+	async discoverTemplateDirs() {
+		const templateDirs = [];
+		try {
+			const items = await this.fileSystem.readdir(this.templatesRootPath);
+			for (const item of items) {
+				const itemPath = node_path.default.join(this.templatesRootPath, item);
+				if (!(await this.fileSystem.stat(itemPath)).isDirectory()) continue;
+				const scaffoldYamlPath = node_path.default.join(itemPath, "scaffold.yaml");
+				if (await this.fileSystem.pathExists(scaffoldYamlPath)) {
+					templateDirs.push(item);
+					continue;
+				}
+				try {
+					const subItems = await this.fileSystem.readdir(itemPath);
+					for (const subItem of subItems) {
+						const subItemPath = node_path.default.join(itemPath, subItem);
+						if (!(await this.fileSystem.stat(subItemPath)).isDirectory()) continue;
+						const subScaffoldYamlPath = node_path.default.join(subItemPath, "scaffold.yaml");
+						if (await this.fileSystem.pathExists(subScaffoldYamlPath)) {
+							const relativePath = node_path.default.join(item, subItem);
+							templateDirs.push(relativePath);
+						}
+					}
+				} catch (error) {
+					__agiflowai_aicode_utils.log.warn(`Failed to read subdirectories in ${itemPath}:`, error);
+				}
+			}
+		} catch (error) {
+			__agiflowai_aicode_utils.log.warn(`Failed to read templates root directory ${this.templatesRootPath}:`, error);
+		}
+		return templateDirs;
+	}
+	async useScaffoldMethod(request) {
+		const { projectPath, scaffold_feature_name, variables, sessionId } = request;
+		const absoluteProjectPath = await this.resolveProjectPath(projectPath);
+		const scaffoldingMethods = await this.listScaffoldingMethods(absoluteProjectPath);
+		const method = scaffoldingMethods.methods.find((m) => m.name === scaffold_feature_name);
+		if (!method) {
+			const availableMethods = scaffoldingMethods.methods.map((m) => m.name).join(", ");
+			throw new Error(`Scaffold method '${scaffold_feature_name}' not found. Available methods: ${availableMethods}`);
+		}
+		const ScaffoldService = (await Promise.resolve().then(() => require("./ScaffoldService-Bhzxp5-C.cjs"))).ScaffoldService;
+		const ScaffoldConfigLoader = (await Promise.resolve().then(() => require("./ScaffoldConfigLoader-BB4_YUFL.cjs"))).ScaffoldConfigLoader;
+		const VariableReplacementService = (await Promise.resolve().then(() => require("./VariableReplacementService-CNimgwaq.cjs"))).VariableReplacementService;
+		const TemplateService$1 = (await Promise.resolve().then(() => require("./TemplateService-BrJGDvQt.cjs"))).TemplateService;
+		const templateService = new TemplateService$1();
+		const scaffoldConfigLoader = new ScaffoldConfigLoader(this.fileSystem, templateService);
+		const variableReplacer = new VariableReplacementService(this.fileSystem, templateService);
+		const scaffoldService = new ScaffoldService(this.fileSystem, scaffoldConfigLoader, variableReplacer, this.templatesRootPath);
+		const projectName = node_path.default.basename(absoluteProjectPath);
+		const result = await scaffoldService.useFeature({
+			projectPath: absoluteProjectPath,
+			templateFolder: scaffoldingMethods.templatePath,
+			featureName: scaffold_feature_name,
+			variables: {
+				...variables,
+				appPath: absoluteProjectPath,
+				appName: projectName
+			}
+		});
+		if (!result.success) throw new Error(result.message);
+		if (sessionId && result.createdFiles && result.createdFiles.length > 0) try {
+			const { ExecutionLogService, DECISION_ALLOW } = await import("@agiflowai/hooks-adapter");
+			await new ExecutionLogService(sessionId).logExecution({
+				filePath: absoluteProjectPath,
+				operation: "scaffold",
+				decision: DECISION_ALLOW,
+				generatedFiles: result.createdFiles
+			});
+		} catch (error) {
+			__agiflowai_aicode_utils.log.warn("Failed to log scaffold execution:", error);
+		}
+		return {
+			success: true,
+			message: `
+Successfully scaffolded ${scaffold_feature_name} in ${projectPath}.
+Please follow this **instruction**: \n ${method.instruction ? this.processScaffoldInstruction(method.instruction, variables) : ""}.
+-> Create or update the plan based on the instruction.
+`,
+			warnings: result.warnings,
+			createdFiles: result.createdFiles,
+			existingFiles: result.existingFiles
+		};
+	}
+};
+
+//#endregion
+//#region src/instructions/tools/list-scaffolding-methods/description.md?raw
+var description_default = "Lists all available scaffolding methods (features) that can be added to an existing project{% if not isMonolith %} or for a specific template{% endif %}.\n\nThis tool:\n{% if isMonolith %}\n- Reads your project's sourceTemplate from toolkit.yaml at workspace root\n{% else %}\n- Reads the project's sourceTemplate from project.json (monorepo) or toolkit.yaml (monolith), OR\n- Directly uses the provided templateName to list available features\n{% endif %}\n- Returns available features for that template type\n- Provides variable schemas for each scaffolding method\n- Shows descriptions of what each method creates\n\nUse this FIRST when adding features to understand:\n- What scaffolding methods are available\n- What variables each method requires\n- What files/features will be generated\n\nExample methods might include:\n- Adding new React routes (for React apps)\n- Creating API endpoints (for backend projects)\n- Adding new components (for frontend projects)\n- Setting up database models (for API projects)\n";
+
+//#endregion
+//#region src/tools/ListScaffoldingMethodsTool.ts
+var ListScaffoldingMethodsTool = class ListScaffoldingMethodsTool {
+	static TOOL_NAME = "list-scaffolding-methods";
+	fileSystemService;
+	scaffoldingMethodsService;
+	templateService;
+	isMonolith;
+	constructor(templatesPath, isMonolith = false) {
+		this.fileSystemService = new FileSystemService();
+		this.scaffoldingMethodsService = new ScaffoldingMethodsService(this.fileSystemService, templatesPath);
+		this.templateService = new require_TemplateService.TemplateService();
+		this.isMonolith = isMonolith;
+	}
+	/**
+	* Get the tool definition for MCP
+	*/
+	getDefinition() {
+		const description = this.templateService.renderString(description_default, { isMonolith: this.isMonolith });
+		const properties = { cursor: {
+			type: "string",
+			description: "Optional pagination cursor to fetch the next page of results. Omit to fetch the first page."
+		} };
+		if (!this.isMonolith) {
+			properties.projectPath = {
+				type: "string",
+				description: "Absolute path to the project directory (for monorepo: containing project.json; for monolith: workspace root with toolkit.yaml). Either projectPath or templateName is required."
+			};
+			properties.templateName = {
+				type: "string",
+				description: "Name of the template to list scaffolding methods for (e.g., \"nextjs-15\", \"typescript-mcp-package\"). Either projectPath or templateName is required."
+			};
+		}
+		return {
+			name: ListScaffoldingMethodsTool.TOOL_NAME,
+			description: description.trim(),
+			inputSchema: {
+				type: "object",
+				properties,
+				additionalProperties: false
+			}
+		};
+	}
+	/**
+	* Execute the tool
+	*/
+	async execute(args) {
+		try {
+			const { projectPath, templateName, cursor } = args;
+			let result;
+			if (this.isMonolith) try {
+				const resolvedTemplateName = (await __agiflowai_aicode_utils.ProjectConfigResolver.resolveProjectConfig(process.cwd())).sourceTemplate;
+				result = await this.scaffoldingMethodsService.listScaffoldingMethodsByTemplate(resolvedTemplateName, cursor);
+			} catch (error) {
+				throw new Error(`Failed to read template name from configuration: ${error instanceof Error ? error.message : String(error)}`);
+			}
+			else {
+				if (!projectPath && !templateName) throw new Error("Either projectPath or templateName must be provided");
+				if (projectPath) result = await this.scaffoldingMethodsService.listScaffoldingMethods(projectPath, cursor);
+				else result = await this.scaffoldingMethodsService.listScaffoldingMethodsByTemplate(templateName, cursor);
+			}
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error listing scaffolding methods: ${error instanceof Error ? error.message : String(error)}`
+				}],
+				isError: true
+			};
+		}
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'FileSystemService', {
+  enumerable: true,
+  get: function () {
+    return FileSystemService;
+  }
+});
+Object.defineProperty(exports, 'ListScaffoldingMethodsTool', {
+  enumerable: true,
+  get: function () {
+    return ListScaffoldingMethodsTool;
+  }
+});
+Object.defineProperty(exports, 'PaginationHelper', {
+  enumerable: true,
+  get: function () {
+    return PaginationHelper;
+  }
+});
+Object.defineProperty(exports, 'ScaffoldingMethodsService', {
+  enumerable: true,
+  get: function () {
+    return ScaffoldingMethodsService;
+  }
+});

package/dist/{ScaffoldConfigLoader-B-NLy6VP.cjs → ScaffoldConfigLoader-BB4_YUFL.cjs}

@@ -1,3 +1,3 @@
-const require_ScaffoldConfigLoader = require('./ScaffoldConfigLoader-Y_SBLPg7.cjs');
+const require_ScaffoldConfigLoader = require('./ScaffoldConfigLoader-CQlXVksz.cjs');
 
 exports.ScaffoldConfigLoader = require_ScaffoldConfigLoader.ScaffoldConfigLoader;

package/dist/{ScaffoldConfigLoader-SHk-KEje.mjs → ScaffoldConfigLoader-DKJtnrWT.mjs}

@@ -1,3 +1,3 @@
-import { t as ScaffoldConfigLoader } from "./ScaffoldConfigLoader-BDMJNI1o.mjs";
+import { t as ScaffoldConfigLoader } from "./ScaffoldConfigLoader-8YI7v2GJ.mjs";
 
 export { ScaffoldConfigLoader };

package/dist/ScaffoldService-BCjJE9yK.mjs

@@ -0,0 +1,3 @@
+import { t as ScaffoldService } from "./ScaffoldService-CgYunbKN.mjs";
+
+export { ScaffoldService };

package/dist/ScaffoldService-Bhzxp5-C.cjs

@@ -0,0 +1,3 @@
+const require_ScaffoldService = require('./ScaffoldService-BPyiY_0B.cjs');
+
+exports.ScaffoldService = require_ScaffoldService.ScaffoldService;

package/dist/TemplateService-B1bd6iHw.mjs

@@ -0,0 +1,3 @@
+import { t as TemplateService } from "./TemplateService-CVDL2uqt.mjs";
+
+export { TemplateService };

package/dist/TemplateService-BrJGDvQt.cjs

@@ -0,0 +1,3 @@
+const require_TemplateService = require('./TemplateService-CAD8jkoO.cjs');
+
+exports.TemplateService = require_TemplateService.TemplateService;

package/dist/VariableReplacementService-BO-UYgcf.mjs

@@ -0,0 +1,3 @@
+import { t as VariableReplacementService } from "./VariableReplacementService-B9RA8D0a.mjs";
+
+export { VariableReplacementService };

package/dist/{VariableReplacementService-DKaF2C9l.cjs → VariableReplacementService-CNimgwaq.cjs}

@@ -1,3 +1,3 @@
-const require_VariableReplacementService = require('./VariableReplacementService-CAjesAYq.cjs');
+const require_VariableReplacementService = require('./VariableReplacementService-DDG5KZpb.cjs');
 
 exports.VariableReplacementService = require_VariableReplacementService.VariableReplacementService;

package/dist/cli.cjs

@@ -1,19 +1,22 @@
 #!/usr/bin/env node
 const require_chunk = require('./chunk-CUT6urMc.cjs');
-const require_stdio = require('./stdio-BGj_FLky.cjs');
-require('./ScaffoldConfigLoader-Y_SBLPg7.cjs');
-require('./ScaffoldService-ChzxM0Yc.cjs');
-const require_TemplateService = require('./TemplateService-D3ydJR_R.cjs');
-require('./VariableReplacementService-CAjesAYq.cjs');
+const require_stdio = require('./stdio-BcTSxlVH.cjs');
+const require_ListScaffoldingMethodsTool = require('./ListScaffoldingMethodsTool-BuxKRbwi.cjs');
+require('./ScaffoldConfigLoader-CQlXVksz.cjs');
+require('./ScaffoldService-BPyiY_0B.cjs');
+const require_TemplateService = require('./TemplateService-CAD8jkoO.cjs');
+require('./VariableReplacementService-DDG5KZpb.cjs');
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
 let __agiflowai_aicode_utils = require("@agiflowai/aicode-utils");
 let __modelcontextprotocol_sdk_types_js = require("@modelcontextprotocol/sdk/types.js");
 let commander = require("commander");
 let __modelcontextprotocol_sdk_server_index_js = require("@modelcontextprotocol/sdk/server/index.js");
+let __agiflowai_coding_agent_bridge = require("@agiflowai/coding-agent-bridge");
+let __agiflowai_hooks_adapter = require("@agiflowai/hooks-adapter");
 
 //#region package.json
-var version = "1.0.4";
+var version = "1.0.7";
 
 //#endregion
 //#region src/commands/boilerplate.ts
@@ -344,7 +347,7 @@ function createServer(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 listScaffoldingMethodsTool = new require_ListScaffoldingMethodsTool.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;
@@ -395,7 +398,7 @@ function createServer(options = {}) {
 			if (isMonolith || !useBoilerplateTool) throw new Error("Boilerplate tools are not available for monolith projects");
 			return await useBoilerplateTool.execute(args || {});
 		}
-		if (name === require_stdio.ListScaffoldingMethodsTool.TOOL_NAME) return await listScaffoldingMethodsTool.execute(args || {});
+		if (name === require_ListScaffoldingMethodsTool.ListScaffoldingMethodsTool.TOOL_NAME) return await listScaffoldingMethodsTool.execute(args || {});
 		if (name === require_stdio.UseScaffoldMethodTool.TOOL_NAME) return await useScaffoldMethodTool.execute(args || {});
 		if (name === require_stdio.WriteToFileTool.TOOL_NAME) return await writeToFileTool.execute(args || {});
 		if (name === require_stdio.GenerateBoilerplateTool.TOOL_NAME) {
@@ -525,7 +528,7 @@ scaffoldCommand.command("list [projectPath]").description("List available scaffo
 			process.exit(1);
 		}
 		const templatesDir = await __agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPath();
-		const scaffoldingMethodsService = new require_stdio.ScaffoldingMethodsService(new require_stdio.FileSystemService(), templatesDir);
+		const scaffoldingMethodsService = new require_ListScaffoldingMethodsTool.ScaffoldingMethodsService(new require_ListScaffoldingMethodsTool.FileSystemService(), templatesDir);
 		let result;
 		let displayName;
 		if (projectPath) {
@@ -582,7 +585,7 @@ scaffoldCommand.command("add <featureName>").description("Add a feature to an ex
 			process.exit(1);
 		}
 		const templatesDir = await __agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPath();
-		const scaffoldingMethodsService = new require_stdio.ScaffoldingMethodsService(new require_stdio.FileSystemService(), templatesDir);
+		const scaffoldingMethodsService = new require_ListScaffoldingMethodsTool.ScaffoldingMethodsService(new require_ListScaffoldingMethodsTool.FileSystemService(), templatesDir);
 		let allMethods = [];
 		let cursor;
 		do {
@@ -653,7 +656,7 @@ scaffoldCommand.command("info <featureName>").description("Show detailed informa
 			process.exit(1);
 		}
 		const templatesDir = await __agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPath();
-		const scaffoldingMethodsService = new require_stdio.ScaffoldingMethodsService(new require_stdio.FileSystemService(), templatesDir);
+		const scaffoldingMethodsService = new require_ListScaffoldingMethodsTool.ScaffoldingMethodsService(new require_ListScaffoldingMethodsTool.FileSystemService(), templatesDir);
 		let allMethods = [];
 		let cursor;
 		if (options.project) {
@@ -697,6 +700,80 @@ scaffoldCommand.command("info <featureName>").description("Show detailed informa
 	}
 });
 
+//#endregion
+//#region src/commands/hook.ts
+/**
+* Hook Command
+*
+* DESIGN PATTERNS:
+* - Command pattern with Commander for CLI argument parsing
+* - Async/await pattern for asynchronous operations
+* - Error handling pattern with try-catch and proper exit codes
+*
+* CODING STANDARDS:
+* - Use async action handlers for asynchronous operations
+* - Provide clear option descriptions and default values
+* - Handle errors gracefully with process.exit()
+* - Log progress and errors to console
+* - Use Commander's .option() for inputs
+*
+* AVOID:
+* - Synchronous blocking operations in action handlers
+* - Missing error handling (always use try-catch)
+* - Hardcoded values (use options or environment variables)
+* - Not exiting with appropriate exit codes on errors
+*/
+/**
+* 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.afterTool)").action(async (options) => {
+	try {
+		if (!options.type) {
+			__agiflowai_aicode_utils.print.error("--type option is required");
+			__agiflowai_aicode_utils.print.info("Examples:");
+			__agiflowai_aicode_utils.print.info("  scaffold hook --type claude-code.preToolUse");
+			__agiflowai_aicode_utils.print.info("  scaffold hook --type claude-code.postToolUse");
+			__agiflowai_aicode_utils.print.info("  scaffold hook --type gemini-cli.beforeTool");
+			__agiflowai_aicode_utils.print.info("  scaffold hook --type gemini-cli.afterTool");
+			process.exit(1);
+		}
+		const { agent, hookMethod } = (0, __agiflowai_hooks_adapter.parseHookType)(options.type);
+		if (agent === __agiflowai_coding_agent_bridge.CLAUDE_CODE) {
+			const useScaffoldMethodModule = await Promise.resolve().then(() => require("./useScaffoldMethod-C1hQdBVD.cjs"));
+			const claudeCallbacks = [];
+			if (useScaffoldMethodModule.UseScaffoldMethodHook) {
+				const hookInstance = new useScaffoldMethodModule.UseScaffoldMethodHook();
+				const hookFn = hookInstance[hookMethod];
+				if (hookFn) claudeCallbacks.push(hookFn.bind(hookInstance));
+			}
+			if (claudeCallbacks.length === 0) {
+				__agiflowai_aicode_utils.print.error(`Hook not found: ${hookMethod} in Claude Code hooks`);
+				process.exit(1);
+			}
+			await new __agiflowai_hooks_adapter.ClaudeCodeAdapter().executeMultiple(claudeCallbacks);
+		} else if (agent === __agiflowai_coding_agent_bridge.GEMINI_CLI) {
+			const useScaffoldMethodModule = await Promise.resolve().then(() => require("./useScaffoldMethod-Btc_9iCj.cjs"));
+			const geminiCallbacks = [];
+			if (useScaffoldMethodModule.UseScaffoldMethodHook) {
+				const hookInstance = new useScaffoldMethodModule.UseScaffoldMethodHook();
+				const hookFn = hookInstance[hookMethod];
+				if (hookFn) geminiCallbacks.push(hookFn.bind(hookInstance));
+			}
+			if (geminiCallbacks.length === 0) {
+				__agiflowai_aicode_utils.print.error(`Hook not found: ${hookMethod} in Gemini CLI hooks`);
+				process.exit(1);
+			}
+			await new __agiflowai_hooks_adapter.GeminiCliAdapter().executeMultiple(geminiCallbacks);
+		} else {
+			__agiflowai_aicode_utils.print.error(`Unsupported agent: ${agent}. Supported: ${__agiflowai_coding_agent_bridge.CLAUDE_CODE}, ${__agiflowai_coding_agent_bridge.GEMINI_CLI}`);
+			process.exit(1);
+		}
+	} catch (error) {
+		__agiflowai_aicode_utils.print.error(`Hook error: ${error.message}`);
+		process.exit(1);
+	}
+});
+
 //#endregion
 //#region src/cli.ts
 /**
@@ -708,6 +785,7 @@ async function main() {
 	program.addCommand(mcpServeCommand);
 	program.addCommand(boilerplateCommand);
 	program.addCommand(scaffoldCommand);
+	program.addCommand(hookCommand);
 	await program.parseAsync(process.argv);
 }
 main();