@agiflowai/scaffold-mcp 1.1.0 → 1.3.0

package/dist/cli.mjs

@@ -1,12 +1,53 @@
 #!/usr/bin/env node
-import { a as createServer, i as StdioTransportHandler, n as HttpTransportHandler, o as version, r as SseTransportHandler, t as TransportMode } from "./src-BEwgHhCT.mjs";
-import { n as ScaffoldingMethodsService, s as FileSystemService } from "./ListScaffoldingMethodsTool-DxdrPlcb.mjs";
-import { l as BoilerplateService } from "./tools-Cl06aoBi.mjs";
-import { ProjectConfigResolver, TemplatesManagerService, icons, messages, print, sections } from "@agiflowai/aicode-utils";
+import { a as createServer, i as StdioTransportHandler, n as HttpTransportHandler, o as version, r as SseTransportHandler, t as TransportMode } from "./src-CUQR93cQ.mjs";
+import { n as ScaffoldingMethodsService, s as FileSystemService } from "./ListScaffoldingMethodsTool-dHaM4QXT.mjs";
+import { c as GenerateBoilerplateFileTool, o as GenerateFeatureScaffoldTool, r as writePendingScaffoldLog, s as GenerateBoilerplateTool, t as WriteToFileTool, u as BoilerplateService } from "./tools-BR1vQd_Y.mjs";
+import { ProjectConfigResolver, TemplatesManagerService, generateStableId, icons, messages, print, readFile, sections } from "@agiflowai/aicode-utils";
 import path from "node:path";
 import { Command } from "commander";
-import { CLAUDE_CODE, GEMINI_CLI, SUPPORTED_LLM_TOOLS, isValidLlmTool } from "@agiflowai/coding-agent-bridge";
-import { ClaudeCodeAdapter, GeminiCliAdapter, parseHookType } from "@agiflowai/hooks-adapter";
+import { CLAUDE_CODE, CODEX, GEMINI_CLI, SUPPORTED_LLM_TOOLS, isValidLlmTool } from "@agiflowai/coding-agent-bridge";
+import { ClaudeCodeAdapter, CodexAdapter, GeminiCliAdapter, parseHookType } from "@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 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 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 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
@@ -43,7 +84,7 @@ boilerplateCommand.command("list").description("List all available boilerplate t
 		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 TemplatesManagerService.findTemplatesPath();
 		if (!templatesDir) {
@@ -93,7 +134,8 @@ boilerplateCommand.command("create <boilerplateName>").description("Create a new
 			boilerplateName,
 			variables,
 			monolith: options.monolith,
-			targetFolderOverride: options.targetFolder
+			targetFolderOverride: options.targetFolder,
+			marker: options.marker
 		});
 		if (result.success) {
 			messages.success("Project created successfully!");
@@ -120,6 +162,42 @@ boilerplateCommand.command("create <boilerplateName>").description("Create a new
 		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 GenerateBoilerplateTool(templatesPath, isMonolith).execute({
+			templateName: options.template,
+			boilerplateName,
+			description: description ?? "",
+			instruction,
+			targetFolder,
+			variables,
+			includes: options.include ?? []
+		});
+		print.info(assertToolSuccess(result));
+	} catch (error) {
+		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 TemplatesManagerService.findTemplatesPath();
@@ -145,6 +223,28 @@ boilerplateCommand.command("info <boilerplateName>").description("Show detailed
 	}
 });
 //#endregion
+//#region src/commands/file.ts
+const fileCommand$1 = new 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 WriteToFileTool().execute({
+			file_path: filePath,
+			content
+		});
+		print.info(assertToolSuccess(result));
+	} catch (error) {
+		print.error("Error writing file:", error instanceof Error ? error.message : String(error));
+		process.exit(1);
+	}
+});
+//#endregion
 //#region src/commands/mcp-serve.ts
 /**
 * MCP Serve Command
@@ -298,13 +398,6 @@ const mcpServeCommand = new Command("mcp-serve").description("Start MCP server w
 const scaffoldCommand = new 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) {
-			messages.error("Either projectPath or --template option must be provided");
-			messages.hint("Examples:");
-			print.debug("  scaffold-mcp scaffold list ./my-project");
-			print.debug("  scaffold-mcp scaffold list --template nextjs-15");
-			process.exit(1);
-		}
 		const templatesDir = await TemplatesManagerService.findTemplatesPath();
 		if (!templatesDir) {
 			messages.error("Templates folder not found. Create a templates folder or specify templatesPath in toolkit.yaml");
@@ -313,15 +406,16 @@ scaffoldCommand.command("list [projectPath]").description("List available scaffo
 		const scaffoldingMethodsService = new ScaffoldingMethodsService(new FileSystemService(), templatesDir);
 		let result;
 		let displayName;
-		if (projectPath) {
-			const absolutePath = path.resolve(projectPath);
+		if (projectPath || !options.template) {
+			const inputProjectPath = projectPath ?? process.cwd();
+			const absolutePath = path.resolve(inputProjectPath);
 			if (!await ProjectConfigResolver.hasConfiguration(absolutePath)) {
 				messages.error(`No project configuration found in ${absolutePath}`);
 				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}`;
@@ -350,7 +444,7 @@ scaffoldCommand.command("list [projectPath]").description("List available scaffo
 		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 = path.resolve(options.project);
 		if (!await ProjectConfigResolver.hasConfiguration(projectPath)) {
@@ -407,9 +501,17 @@ scaffoldCommand.command("add <featureName>").description("Add a feature to an ex
 		const result = await scaffoldingMethodsService.useScaffoldMethod({
 			projectPath,
 			scaffold_feature_name: featureName,
-			variables
+			variables,
+			marker: options.marker
 		});
 		if (result.success) {
+			const scaffoldId = generateStableId(6);
+			if (result.createdFiles && result.createdFiles.length > 0) await writePendingScaffoldLog({
+				scaffoldId,
+				projectPath,
+				featureName,
+				generatedFiles: result.createdFiles
+			});
 			messages.success("✅ Feature added successfully!");
 			if (result.createdFiles && result.createdFiles.length > 0) {
 				print.header("\n📁 Created files:");
@@ -423,6 +525,7 @@ scaffoldCommand.command("add <featureName>").description("Add a feature to an ex
 					print.debug(`   - ${warning}`);
 				});
 			}
+			print.debug(`\nSCAFFOLD_ID:${scaffoldId}`);
 			print.header("\n📋 Next steps:");
 			print.debug("   - Review the generated files");
 			print.debug("   - Update imports if necessary");
@@ -436,6 +539,40 @@ scaffoldCommand.command("add <featureName>").description("Add a feature to an ex
 		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 GenerateFeatureScaffoldTool(templatesPath, isMonolith).execute({
+			templateName: options.template,
+			featureName,
+			description: description ?? "",
+			instruction,
+			variables,
+			includes: options.include ?? [],
+			patterns: options.pattern ?? []
+		});
+		print.info(assertToolSuccess(result));
+	} catch (error) {
+		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) {
@@ -574,7 +711,7 @@ const hookCommand = new Command("hook").description("Execute scaffold hooks for
 		const resolvedAdapterConfig = Object.keys(adapterConfig).length > 0 ? adapterConfig : void 0;
 		if (!isHookMethod(hookMethod)) process.exit(0);
 		if (agent === CLAUDE_CODE) {
-			const hookModule = await import("./claudeCode-DNgNiLlL.mjs");
+			const hookModule = await import("./claudeCode-CyHppxA_.mjs");
 			const claudeCallbacks = [];
 			if (hookModule.UseScaffoldMethodHook) {
 				const hookInstance = new hookModule.UseScaffoldMethodHook();
@@ -589,7 +726,7 @@ const hookCommand = new Command("hook").description("Execute scaffold hooks for
 			if (claudeCallbacks.length === 0) process.exit(0);
 			await new ClaudeCodeAdapter().executeMultiple(claudeCallbacks, resolvedAdapterConfig);
 		} else if (agent === GEMINI_CLI) {
-			const hookModule = await import("./geminiCli-CcrZEqsz.mjs");
+			const hookModule = await import("./geminiCli-CgajucCd.mjs");
 			const geminiCallbacks = [];
 			if (hookModule.UseScaffoldMethodHook) {
 				const hookInstance = new hookModule.UseScaffoldMethodHook();
@@ -598,13 +735,62 @@ const hookCommand = new Command("hook").description("Execute scaffold hooks for
 			}
 			if (geminiCallbacks.length === 0) process.exit(0);
 			await new GeminiCliAdapter().executeMultiple(geminiCallbacks, resolvedAdapterConfig);
-		} else throw new Error(`Unsupported agent: ${agent}. Supported: ${CLAUDE_CODE}, ${GEMINI_CLI}`);
+		} else if (agent === CODEX) {
+			const hookModule = await import("./codex-7ry557jE.mjs");
+			const codexCallbacks = [];
+			if (hookModule.UseScaffoldMethodHook) {
+				const hookInstance = new hookModule.UseScaffoldMethodHook();
+				const hookFn = hookInstance[hookMethod];
+				if (hookFn) codexCallbacks.push(hookFn.bind(hookInstance));
+			}
+			if (codexCallbacks.length === 0) process.exit(0);
+			await new CodexAdapter().executeMultiple(codexCallbacks, resolvedAdapterConfig);
+		} else throw new Error(`Unsupported agent: ${agent}. Supported: ${CLAUDE_CODE}, ${GEMINI_CLI}, ${CODEX}`);
 	} catch (error) {
 		print.error(`Hook error: ${error instanceof Error ? error.message : String(error)}`);
 		process.exit(1);
 	}
 });
 //#endregion
+//#region src/commands/template.ts
+const templateCommand = new Command("template").description("Manage scaffold template authoring assets");
+const fileCommand = new 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 GenerateBoilerplateFileTool(templatesPath, isMonolith).execute({
+			templateName: options.template,
+			filePath,
+			content,
+			sourceFile: options.sourceFile,
+			header
+		});
+		print.info(assertToolSuccess(result));
+	} catch (error) {
+		print.error("Error creating template file:", error instanceof Error ? error.message : String(error));
+		process.exit(1);
+	}
+});
+templateCommand.addCommand(fileCommand);
+//#endregion
 //#region src/cli.ts
 /**
 * Main entry point
@@ -615,6 +801,8 @@ 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);
 }

package/dist/codex-7ry557jE.mjs

@@ -0,0 +1,254 @@
+import { t as ListScaffoldingMethodsTool } from "./ListScaffoldingMethodsTool-dHaM4QXT.mjs";
+import { a as resolveApplyPatchNewFileTargets, i as resolveApplyPatchEditedPaths, n as getGlobalExcludeGlobs, r as matchesExcludeGlob, t as formatScaffoldMethodsHookMessage } from "./shared-BJjclypj.mjs";
+import { ProjectFinderService, TemplatesManagerService } from "@agiflowai/aicode-utils";
+import path from "node:path";
+import { DECISION_ALLOW, DECISION_DENY, DECISION_SKIP, ExecutionLogService } from "@agiflowai/hooks-adapter";
+//#region src/hooks/codex/useScaffoldMethod.ts
+/**
+* Type guard for ScaffoldMethodsResponse
+*/
+function isScaffoldMethodsResponse(value) {
+	if (typeof value !== "object" || value === null) return false;
+	if ("methods" in value && !Array.isArray(value.methods)) return false;
+	if ("excludeGlobs" in value && !Array.isArray(value.excludeGlobs)) return false;
+	if ("nextCursor" in value && typeof value.nextCursor !== "string") return false;
+	return true;
+}
+/**
+* UseScaffoldMethod Hook class for Codex CLI
+*
+* Provides lifecycle hooks for tool execution:
+* - preToolUse: Shows available scaffolding methods before an apply_patch creates new files
+* - postToolUse: Tracks scaffold completion progress after file edits
+*/
+var UseScaffoldMethodHook = class {
+	/**
+	* PreToolUse hook for Codex CLI
+	* Proactively shows available scaffolding methods and guides the agent to use them
+	* when an apply_patch is about to create a new file.
+	*
+	* @param context - Codex CLI hook input
+	* @returns Hook response with scaffolding methods guidance
+	*/
+	async preToolUse(context) {
+		try {
+			if (!("tool_name" in context)) return {
+				decision: DECISION_SKIP,
+				message: "Not a tool use event"
+			};
+			const command = typeof context.tool_input?.command === "string" ? context.tool_input.command : void 0;
+			const newFileTargets = resolveApplyPatchNewFileTargets(context.cwd, context.tool_name, command);
+			if (newFileTargets.length === 0) return {
+				decision: DECISION_SKIP,
+				message: "Not a new-file apply_patch operation"
+			};
+			const globalExcludeGlobs = await getGlobalExcludeGlobs(context.cwd);
+			const target = newFileTargets.find((p) => !matchesExcludeGlob(p, globalExcludeGlobs));
+			if (!target) return {
+				decision: DECISION_ALLOW,
+				message: "New file(s) match configured excludeGlobs - writing directly."
+			};
+			const executionLog = new ExecutionLogService(context.session_id);
+			if (await executionLog.hasExecuted({
+				filePath: target,
+				decision: DECISION_DENY
+			})) return {
+				decision: DECISION_SKIP,
+				message: "Scaffolding methods already provided for this file"
+			};
+			const templatesPath = await TemplatesManagerService.findTemplatesPath();
+			if (!templatesPath) return {
+				decision: DECISION_SKIP,
+				message: "Templates folder not found - skipping scaffold method check"
+			};
+			const tool = new ListScaffoldingMethodsTool(templatesPath, false);
+			const projectPath = (await new ProjectFinderService(await TemplatesManagerService.getWorkspaceRoot(context.cwd)).findProjectForFile(target))?.root || context.cwd;
+			const result = await tool.execute({ projectPath });
+			const firstContent = result.content[0];
+			if (firstContent?.type !== "text") return {
+				decision: DECISION_SKIP,
+				message: "⚠️ Unexpected response type from scaffolding methods tool"
+			};
+			if (result.isError) return {
+				decision: DECISION_SKIP,
+				message: `⚠️ Could not load scaffolding methods: ${firstContent.text}`
+			};
+			const resultText = firstContent.text;
+			if (typeof resultText !== "string") return {
+				decision: DECISION_SKIP,
+				message: "⚠️ Invalid response format from scaffolding methods tool"
+			};
+			const parsed = JSON.parse(resultText);
+			if (!isScaffoldMethodsResponse(parsed)) return {
+				decision: DECISION_SKIP,
+				message: "⚠️ Unexpected response shape from scaffolding methods tool"
+			};
+			const data = parsed;
+			if (matchesExcludeGlob(target, data.excludeGlobs)) return {
+				decision: DECISION_ALLOW,
+				message: "File matches template exclude globs - writing directly."
+			};
+			if (!data.methods || data.methods.length === 0) {
+				await executionLog.logExecution({
+					filePath: target,
+					operation: "list-scaffold-methods",
+					decision: DECISION_ALLOW
+				});
+				return {
+					decision: DECISION_ALLOW,
+					message: "No scaffolding methods are available for this project template. You should write new files directly."
+				};
+			}
+			const message = formatScaffoldMethodsHookMessage(data.methods);
+			await executionLog.logExecution({
+				filePath: target,
+				operation: "list-scaffold-methods",
+				decision: DECISION_DENY
+			});
+			return {
+				decision: DECISION_DENY,
+				message
+			};
+		} catch (error) {
+			return {
+				decision: DECISION_SKIP,
+				message: `⚠️ Hook error: ${error instanceof Error ? error.message : String(error)}`
+			};
+		}
+	}
+	/**
+	* PostToolUse hook for Codex CLI
+	* Tracks file edits after scaffold generation and reminds the agent to complete
+	* the implementation of all scaffold-generated files.
+	*
+	* @param context - Codex CLI hook input
+	* @returns Hook response with scaffold completion tracking
+	*/
+	async postToolUse(context) {
+		try {
+			if (!("tool_name" in context)) return {
+				decision: DECISION_SKIP,
+				message: "Not a tool use event"
+			};
+			const executionLog = new ExecutionLogService(context.session_id);
+			if (context.tool_name === "use-scaffold-method" || context.tool_input?.toolName === "use-scaffold-method") return {
+				decision: DECISION_ALLOW,
+				message: "Scaffold execution logged for progress tracking"
+			};
+			const command = typeof context.tool_input?.command === "string" ? context.tool_input.command : void 0;
+			const editedPaths = resolveApplyPatchEditedPaths(context.tool_name, command);
+			if (editedPaths.length === 0) return {
+				decision: DECISION_SKIP,
+				message: "Not a file edit/write operation"
+			};
+			const lastScaffoldExecution = await getLastScaffoldExecution(executionLog);
+			if (!lastScaffoldExecution) return {
+				decision: DECISION_SKIP,
+				message: "No scaffold execution found"
+			};
+			const { scaffoldId, generatedFiles, featureName } = lastScaffoldExecution;
+			const fulfilledKey = `scaffold-fulfilled-${scaffoldId}`;
+			if (await executionLog.hasExecuted({
+				filePath: fulfilledKey,
+				decision: DECISION_ALLOW
+			})) return {
+				decision: DECISION_SKIP,
+				message: "Scaffold already fulfilled"
+			};
+			let touchedScaffoldFile = false;
+			for (const editedPath of editedPaths) {
+				const absoluteEditedPath = path.isAbsolute(editedPath) ? editedPath : path.join(context.cwd, editedPath);
+				const generatedMatch = generatedFiles.find((f) => f === editedPath || f === absoluteEditedPath);
+				if (!generatedMatch) continue;
+				touchedScaffoldFile = true;
+				const editKey = `scaffold-edit-${scaffoldId}-${generatedMatch}`;
+				if (!await executionLog.hasExecuted({
+					filePath: editKey,
+					decision: DECISION_ALLOW
+				})) await executionLog.logExecution({
+					filePath: editKey,
+					operation: "scaffold-file-edit",
+					decision: DECISION_ALLOW
+				});
+			}
+			const editedFiles = await getEditedScaffoldFiles(executionLog, scaffoldId);
+			const totalFiles = generatedFiles.length;
+			const remainingFiles = generatedFiles.filter((f) => !editedFiles.includes(f));
+			if (remainingFiles.length === 0) {
+				await executionLog.logExecution({
+					filePath: fulfilledKey,
+					operation: "scaffold-fulfilled",
+					decision: DECISION_ALLOW
+				});
+				return {
+					decision: DECISION_ALLOW,
+					message: `✅ All scaffold files${featureName ? ` for "${featureName}"` : ""} have been implemented! (${totalFiles}/${totalFiles} files completed)`
+				};
+			}
+			if (touchedScaffoldFile) {
+				const remainingFilesList = remainingFiles.map((f) => `  - ${f}`).join("\n");
+				return {
+					decision: DECISION_ALLOW,
+					message: `
+⚠️ **Scaffold Implementation Progress${featureName ? ` for "${featureName}"` : ""}: ${editedFiles.length}/${totalFiles} files completed**
+
+**Remaining files to implement:**
+${remainingFilesList}
+
+Don't forget to complete the implementation for all scaffolded files!
+        `.trim()
+				};
+			}
+			return {
+				decision: DECISION_SKIP,
+				message: "Edited file not part of last scaffold execution"
+			};
+		} catch (error) {
+			return {
+				decision: DECISION_SKIP,
+				message: `⚠️ Hook error: ${error instanceof Error ? error.message : String(error)}`
+			};
+		}
+	}
+};
+/**
+* Helper function to get the last scaffold execution for a session.
+* Returns null if no scaffold execution found or on error.
+*/
+async function getLastScaffoldExecution(executionLog) {
+	try {
+		const entries = await executionLog.loadLog();
+		for (let i = entries.length - 1; i >= 0; i--) {
+			const entry = entries[i];
+			if (entry.operation === "scaffold" && entry.scaffoldId && entry.generatedFiles && entry.generatedFiles.length > 0) return {
+				scaffoldId: entry.scaffoldId,
+				generatedFiles: entry.generatedFiles,
+				featureName: entry.featureName
+			};
+		}
+		return null;
+	} catch (error) {
+		console.error("Error getting last scaffold execution:", error);
+		return null;
+	}
+}
+/**
+* Helper function to get the list of edited scaffold files.
+* Returns an empty array if no files found or on error.
+*/
+async function getEditedScaffoldFiles(executionLog, scaffoldId) {
+	try {
+		const entries = await executionLog.loadLog();
+		const editedFiles = [];
+		for (const entry of entries) if (entry.operation === "scaffold-file-edit" && entry.filePath.startsWith(`scaffold-edit-${scaffoldId}-`)) {
+			const filePath = entry.filePath.replace(`scaffold-edit-${scaffoldId}-`, "");
+			editedFiles.push(filePath);
+		}
+		return editedFiles;
+	} catch (error) {
+		console.error(`Error getting edited scaffold files for ${scaffoldId}:`, error);
+		return [];
+	}
+}
+//#endregion
+export { UseScaffoldMethodHook };