@agiflowai/scaffold-mcp 1.1.0 → 1.3.0

package/dist/codex-CfOJFx29.cjs

@@ -0,0 +1,255 @@
+const require_ListScaffoldingMethodsTool = require("./ListScaffoldingMethodsTool-rX9Hxn2d.cjs");
+const require_shared = require("./shared-B0H-6AUG.cjs");
+let _agiflowai_aicode_utils = require("@agiflowai/aicode-utils");
+let node_path = require("node:path");
+node_path = require_ListScaffoldingMethodsTool.__toESM(node_path, 1);
+let _agiflowai_hooks_adapter = require("@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: _agiflowai_hooks_adapter.DECISION_SKIP,
+				message: "Not a tool use event"
+			};
+			const command = typeof context.tool_input?.command === "string" ? context.tool_input.command : void 0;
+			const newFileTargets = require_shared.resolveApplyPatchNewFileTargets(context.cwd, context.tool_name, command);
+			if (newFileTargets.length === 0) return {
+				decision: _agiflowai_hooks_adapter.DECISION_SKIP,
+				message: "Not a new-file apply_patch operation"
+			};
+			const globalExcludeGlobs = await require_shared.getGlobalExcludeGlobs(context.cwd);
+			const target = newFileTargets.find((p) => !require_shared.matchesExcludeGlob(p, globalExcludeGlobs));
+			if (!target) return {
+				decision: _agiflowai_hooks_adapter.DECISION_ALLOW,
+				message: "New file(s) match configured excludeGlobs - writing directly."
+			};
+			const executionLog = new _agiflowai_hooks_adapter.ExecutionLogService(context.session_id);
+			if (await executionLog.hasExecuted({
+				filePath: target,
+				decision: _agiflowai_hooks_adapter.DECISION_DENY
+			})) return {
+				decision: _agiflowai_hooks_adapter.DECISION_SKIP,
+				message: "Scaffolding methods already provided for this file"
+			};
+			const templatesPath = await _agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPath();
+			if (!templatesPath) return {
+				decision: _agiflowai_hooks_adapter.DECISION_SKIP,
+				message: "Templates folder not found - skipping scaffold method check"
+			};
+			const tool = new require_ListScaffoldingMethodsTool.ListScaffoldingMethodsTool(templatesPath, false);
+			const projectPath = (await new _agiflowai_aicode_utils.ProjectFinderService(await _agiflowai_aicode_utils.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: _agiflowai_hooks_adapter.DECISION_SKIP,
+				message: "⚠️ Unexpected response type from scaffolding methods tool"
+			};
+			if (result.isError) return {
+				decision: _agiflowai_hooks_adapter.DECISION_SKIP,
+				message: `⚠️ Could not load scaffolding methods: ${firstContent.text}`
+			};
+			const resultText = firstContent.text;
+			if (typeof resultText !== "string") return {
+				decision: _agiflowai_hooks_adapter.DECISION_SKIP,
+				message: "⚠️ Invalid response format from scaffolding methods tool"
+			};
+			const parsed = JSON.parse(resultText);
+			if (!isScaffoldMethodsResponse(parsed)) return {
+				decision: _agiflowai_hooks_adapter.DECISION_SKIP,
+				message: "⚠️ Unexpected response shape from scaffolding methods tool"
+			};
+			const data = parsed;
+			if (require_shared.matchesExcludeGlob(target, data.excludeGlobs)) return {
+				decision: _agiflowai_hooks_adapter.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: _agiflowai_hooks_adapter.DECISION_ALLOW
+				});
+				return {
+					decision: _agiflowai_hooks_adapter.DECISION_ALLOW,
+					message: "No scaffolding methods are available for this project template. You should write new files directly."
+				};
+			}
+			const message = require_shared.formatScaffoldMethodsHookMessage(data.methods);
+			await executionLog.logExecution({
+				filePath: target,
+				operation: "list-scaffold-methods",
+				decision: _agiflowai_hooks_adapter.DECISION_DENY
+			});
+			return {
+				decision: _agiflowai_hooks_adapter.DECISION_DENY,
+				message
+			};
+		} catch (error) {
+			return {
+				decision: _agiflowai_hooks_adapter.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: _agiflowai_hooks_adapter.DECISION_SKIP,
+				message: "Not a tool use event"
+			};
+			const executionLog = new _agiflowai_hooks_adapter.ExecutionLogService(context.session_id);
+			if (context.tool_name === "use-scaffold-method" || context.tool_input?.toolName === "use-scaffold-method") return {
+				decision: _agiflowai_hooks_adapter.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 = require_shared.resolveApplyPatchEditedPaths(context.tool_name, command);
+			if (editedPaths.length === 0) return {
+				decision: _agiflowai_hooks_adapter.DECISION_SKIP,
+				message: "Not a file edit/write operation"
+			};
+			const lastScaffoldExecution = await getLastScaffoldExecution(executionLog);
+			if (!lastScaffoldExecution) return {
+				decision: _agiflowai_hooks_adapter.DECISION_SKIP,
+				message: "No scaffold execution found"
+			};
+			const { scaffoldId, generatedFiles, featureName } = lastScaffoldExecution;
+			const fulfilledKey = `scaffold-fulfilled-${scaffoldId}`;
+			if (await executionLog.hasExecuted({
+				filePath: fulfilledKey,
+				decision: _agiflowai_hooks_adapter.DECISION_ALLOW
+			})) return {
+				decision: _agiflowai_hooks_adapter.DECISION_SKIP,
+				message: "Scaffold already fulfilled"
+			};
+			let touchedScaffoldFile = false;
+			for (const editedPath of editedPaths) {
+				const absoluteEditedPath = node_path.default.isAbsolute(editedPath) ? editedPath : node_path.default.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: _agiflowai_hooks_adapter.DECISION_ALLOW
+				})) await executionLog.logExecution({
+					filePath: editKey,
+					operation: "scaffold-file-edit",
+					decision: _agiflowai_hooks_adapter.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: _agiflowai_hooks_adapter.DECISION_ALLOW
+				});
+				return {
+					decision: _agiflowai_hooks_adapter.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: _agiflowai_hooks_adapter.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: _agiflowai_hooks_adapter.DECISION_SKIP,
+				message: "Edited file not part of last scaffold execution"
+			};
+		} catch (error) {
+			return {
+				decision: _agiflowai_hooks_adapter.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
+exports.UseScaffoldMethodHook = UseScaffoldMethodHook;

package/dist/{geminiCli-CcrZEqsz.mjs → geminiCli-CgajucCd.mjs}

@@ -1,5 +1,5 @@
-import { t as ListScaffoldingMethodsTool } from "./ListScaffoldingMethodsTool-DxdrPlcb.mjs";
-import { n as resolveNewFileWriteTarget, t as formatScaffoldMethodsHookMessage } from "./shared-BVYIN3Is.mjs";
+import { t as ListScaffoldingMethodsTool } from "./ListScaffoldingMethodsTool-dHaM4QXT.mjs";
+import { n as getGlobalExcludeGlobs, o as resolveNewFileWriteTarget, r as matchesExcludeGlob, t as formatScaffoldMethodsHookMessage } from "./shared-BJjclypj.mjs";
 import { ProjectFinderService, TemplatesManagerService } from "@agiflowai/aicode-utils";
 import { DECISION_ALLOW, DECISION_DENY, DECISION_SKIP, ExecutionLogService } from "@agiflowai/hooks-adapter";
 //#region src/hooks/geminiCli/useScaffoldMethod.ts
@@ -26,6 +26,10 @@ var UseScaffoldMethodHook = class {
 				decision: DECISION_SKIP,
 				message: "Not a new file write operation"
 			};
+			if (matchesExcludeGlob(absoluteFilePath, await getGlobalExcludeGlobs(context.cwd))) return {
+				decision: DECISION_ALLOW,
+				message: "File matches configured excludeGlobs - writing directly."
+			};
 			const executionLog = new ExecutionLogService(context.session_id);
 			const sessionKey = filePath;
 			if (await executionLog.hasExecuted({
@@ -72,6 +76,10 @@ var UseScaffoldMethodHook = class {
 				message: "⚠️ Invalid response format from scaffolding methods tool"
 			};
 			const data = JSON.parse(resultText);
+			if (matchesExcludeGlob(absoluteFilePath, 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: sessionKey,

package/dist/{geminiCli--s1Qy7ZP.cjs → geminiCli-wTHUG-A6.cjs}

@@ -1,5 +1,5 @@
-const require_ListScaffoldingMethodsTool = require("./ListScaffoldingMethodsTool-CYZtpU-W.cjs");
-const require_shared = require("./shared-QxPXh-L-.cjs");
+const require_ListScaffoldingMethodsTool = require("./ListScaffoldingMethodsTool-rX9Hxn2d.cjs");
+const require_shared = require("./shared-B0H-6AUG.cjs");
 let _agiflowai_aicode_utils = require("@agiflowai/aicode-utils");
 let _agiflowai_hooks_adapter = require("@agiflowai/hooks-adapter");
 //#region src/hooks/geminiCli/useScaffoldMethod.ts
@@ -26,6 +26,10 @@ var UseScaffoldMethodHook = class {
 				decision: _agiflowai_hooks_adapter.DECISION_SKIP,
 				message: "Not a new file write operation"
 			};
+			if (require_shared.matchesExcludeGlob(absoluteFilePath, await require_shared.getGlobalExcludeGlobs(context.cwd))) return {
+				decision: _agiflowai_hooks_adapter.DECISION_ALLOW,
+				message: "File matches configured excludeGlobs - writing directly."
+			};
 			const executionLog = new _agiflowai_hooks_adapter.ExecutionLogService(context.session_id);
 			const sessionKey = filePath;
 			if (await executionLog.hasExecuted({
@@ -72,6 +76,10 @@ var UseScaffoldMethodHook = class {
 				message: "⚠️ Invalid response format from scaffolding methods tool"
 			};
 			const data = JSON.parse(resultText);
+			if (require_shared.matchesExcludeGlob(absoluteFilePath, data.excludeGlobs)) return {
+				decision: _agiflowai_hooks_adapter.DECISION_ALLOW,
+				message: "File matches template exclude globs - writing directly."
+			};
 			if (!data.methods || data.methods.length === 0) {
 				await executionLog.logExecution({
 					filePath: sessionKey,

package/dist/index.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_ListScaffoldingMethodsTool = require("./ListScaffoldingMethodsTool-CYZtpU-W.cjs");
-const require_src = require("./src-oF_UdSBu.cjs");
-const require_tools = require("./tools-CVSZSirE.cjs");
+const require_ListScaffoldingMethodsTool = require("./ListScaffoldingMethodsTool-rX9Hxn2d.cjs");
+const require_src = require("./src-CRT1Er93.cjs");
+const require_tools = require("./tools-CV6GWs6f.cjs");
 exports.BoilerplateGeneratorService = require_tools.BoilerplateGeneratorService;
 exports.BoilerplateService = require_tools.BoilerplateService;
 exports.FileSystemService = require_ListScaffoldingMethodsTool.FileSystemService;

package/dist/index.d.cts

@@ -267,15 +267,10 @@ declare class UseBoilerplateTool {
 //#region src/tools/UseScaffoldMethodTool.d.ts
 declare class UseScaffoldMethodTool {
   static readonly TOOL_NAME = "use-scaffold-method";
-  private static readonly TEMP_LOG_DIR;
   private fileSystemService;
   private scaffoldingMethodsService;
   private isMonolith;
   constructor(templatesPath: string, isMonolith?: boolean);
-  /**
-   * Write scaffold execution info to temp log file for hook processing
-   */
-  private writePendingScaffoldLog;
   /**
    * Get the tool definition for MCP
    */
@@ -794,6 +789,11 @@ interface ListScaffoldingMethodsResult {
   sourceTemplate: string;
   templatePath: string;
   methods: ScaffoldMethod[];
+  /**
+   * Template-level glob patterns (from scaffold.yaml `exclude`) whose new-file
+   * writes bypass scaffold enforcement. Template-wide, so repeated on every page.
+   */
+  excludeGlobs?: string[];
   nextCursor?: string;
   _meta?: {
     total: number;

package/dist/index.d.mts

@@ -266,15 +266,10 @@ declare class UseBoilerplateTool {
 //#region src/tools/UseScaffoldMethodTool.d.ts
 declare class UseScaffoldMethodTool {
   static readonly TOOL_NAME = "use-scaffold-method";
-  private static readonly TEMP_LOG_DIR;
   private fileSystemService;
   private scaffoldingMethodsService;
   private isMonolith;
   constructor(templatesPath: string, isMonolith?: boolean);
-  /**
-   * Write scaffold execution info to temp log file for hook processing
-   */
-  private writePendingScaffoldLog;
   /**
    * Get the tool definition for MCP
    */
@@ -793,6 +788,11 @@ interface ListScaffoldingMethodsResult {
   sourceTemplate: string;
   templatePath: string;
   methods: ScaffoldMethod[];
+  /**
+   * Template-level glob patterns (from scaffold.yaml `exclude`) whose new-file
+   * writes bypass scaffold enforcement. Template-wide, so repeated on every page.
+   */
+  excludeGlobs?: string[];
   nextCursor?: string;
   _meta?: {
     total: number;

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { a as createServer, i as StdioTransportHandler, n as HttpTransportHandler, r as SseTransportHandler, t as TransportMode } from "./src-BEwgHhCT.mjs";
-import { a as ScaffoldProcessingService, i as ScaffoldService, l as TemplateService, n as ScaffoldingMethodsService, o as ScaffoldConfigLoader, r as VariableReplacementService, s as FileSystemService, t as ListScaffoldingMethodsTool } from "./ListScaffoldingMethodsTool-DxdrPlcb.mjs";
-import { a as GenerateFeatureScaffoldTool, c as ScaffoldGeneratorService, i as ListBoilerplatesTool, l as BoilerplateService, n as UseScaffoldMethodTool, o as GenerateBoilerplateTool, r as UseBoilerplateTool, s as GenerateBoilerplateFileTool, t as WriteToFileTool, u as BoilerplateGeneratorService } from "./tools-Cl06aoBi.mjs";
+import { a as createServer, i as StdioTransportHandler, n as HttpTransportHandler, r as SseTransportHandler, t as TransportMode } from "./src-CUQR93cQ.mjs";
+import { a as ScaffoldProcessingService, i as ScaffoldService, l as TemplateService, n as ScaffoldingMethodsService, o as ScaffoldConfigLoader, r as VariableReplacementService, s as FileSystemService, t as ListScaffoldingMethodsTool } from "./ListScaffoldingMethodsTool-dHaM4QXT.mjs";
+import { a as ListBoilerplatesTool, c as GenerateBoilerplateFileTool, d as BoilerplateGeneratorService, i as UseBoilerplateTool, l as ScaffoldGeneratorService, n as UseScaffoldMethodTool, o as GenerateFeatureScaffoldTool, s as GenerateBoilerplateTool, t as WriteToFileTool, u as BoilerplateService } from "./tools-BR1vQd_Y.mjs";
 export { BoilerplateGeneratorService, BoilerplateService, FileSystemService, GenerateBoilerplateFileTool, GenerateBoilerplateTool, GenerateFeatureScaffoldTool, HttpTransportHandler, ListBoilerplatesTool, ListScaffoldingMethodsTool, ScaffoldConfigLoader, ScaffoldGeneratorService, ScaffoldProcessingService, ScaffoldService, ScaffoldingMethodsService, SseTransportHandler, StdioTransportHandler, TemplateService, TransportMode, UseBoilerplateTool, UseScaffoldMethodTool, VariableReplacementService, WriteToFileTool, createServer };

package/dist/shared-B0H-6AUG.cjs

@@ -0,0 +1,187 @@
+const require_ListScaffoldingMethodsTool = require("./ListScaffoldingMethodsTool-rX9Hxn2d.cjs");
+let _agiflowai_aicode_utils = require("@agiflowai/aicode-utils");
+let node_path = require("node:path");
+node_path = require_ListScaffoldingMethodsTool.__toESM(node_path, 1);
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_ListScaffoldingMethodsTool.__toESM(node_fs_promises, 1);
+let minimatch = require("minimatch");
+/**
+* Returns true when an absolute write target matches any of the given exclude globs.
+*
+* Scaffold methods carry no target glob, so the hook cannot tell whether a method
+* applies to a given path: once any method exists it denies every new-file write,
+* which pushes agents to bypass the hook via Bash heredocs (skipping downstream
+* review hooks). Exclude globs are the configured escape hatch — matching writes are
+* allowed through directly. Globs come from two sources: workspace-wide
+* (`scaffold-mcp.hook.excludeGlobs` in .toolkit/settings.yaml, see
+* {@link getGlobalExcludeGlobs}) and per-template (`exclude` in scaffold.yaml).
+*
+* `dot: true` lets the globs traverse dot-directories (e.g. worktree paths) so a
+* file nested under one is not misclassified.
+*
+* @param absPath - Absolute path of the new-file write target.
+* @param globs - Glob patterns to match against; empty/undefined matches nothing.
+* @returns True when `absPath` matches at least one glob.
+*/
+function matchesExcludeGlob(absPath, globs) {
+	if (!globs || globs.length === 0) return false;
+	return globs.some((glob) => (0, minimatch.minimatch)(absPath, glob, { dot: true }));
+}
+/**
+* Loads the workspace-wide scaffold-enforcement exclude globs from the toolkit
+* config (`scaffold-mcp.hook.excludeGlobs` in .toolkit/settings.yaml).
+*
+* Fails open (returns an empty array) when the config is missing or unreadable so a
+* broken config never blocks writes.
+*
+* @param cwd - Directory to resolve the workspace config from (walks up to the root).
+* @returns The configured exclude globs, or an empty array when none are set.
+*/
+async function getGlobalExcludeGlobs(cwd) {
+	try {
+		const globs = (await _agiflowai_aicode_utils.TemplatesManagerService.readToolkitConfig(cwd))?.["scaffold-mcp"]?.hook?.excludeGlobs;
+		return Array.isArray(globs) ? globs : [];
+	} catch {
+		return [];
+	}
+}
+async function resolveNewFileWriteTarget(cwd, toolName, filePath) {
+	if (!filePath || toolName.toLowerCase() !== "write") return null;
+	const absoluteFilePath = node_path.default.isAbsolute(filePath) ? filePath : node_path.default.join(cwd, filePath);
+	if (!absoluteFilePath.startsWith(cwd + node_path.default.sep) && absoluteFilePath !== cwd) return null;
+	try {
+		await node_fs_promises.default.access(absoluteFilePath);
+		return null;
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return absoluteFilePath;
+		throw error;
+	}
+}
+/**
+* Parses a Codex `apply_patch` command body into the file paths it adds, updates,
+* and deletes. Paths are returned verbatim (as written in the patch, i.e. relative
+* to cwd). Pure and synchronous — performs no filesystem access.
+*
+* @param command - The `apply_patch` patch body (the tool_input.command string).
+* @returns The added/updated/deleted path lists.
+*/
+function parseApplyPatchTargets(command) {
+	const added = [];
+	const updated = [];
+	const deleted = [];
+	for (const line of command.split("\n")) {
+		const add = line.match(/^\*\*\* Add File: (.+)$/);
+		if (add) {
+			added.push(add[1].trim());
+			continue;
+		}
+		const update = line.match(/^\*\*\* Update File: (.+)$/);
+		if (update) {
+			updated.push(update[1].trim());
+			continue;
+		}
+		const del = line.match(/^\*\*\* Delete File: (.+)$/);
+		if (del) deleted.push(del[1].trim());
+	}
+	return {
+		added,
+		updated,
+		deleted
+	};
+}
+/**
+* Resolves the absolute, cwd-scoped paths of NEW files a Codex `apply_patch` tool
+* call creates (its `*** Add File:` targets). Returns an empty array for any other
+* tool or a missing command.
+*
+* Unlike {@link resolveNewFileWriteTarget} (the Claude/Gemini `Write` resolver), this
+* performs no on-disk existence check: an `Add File` block is new-file creation by
+* definition, and the patch fails downstream if the path already exists.
+*
+* @param cwd - Working directory the patch paths are relative to.
+* @param toolName - The Codex tool name (only `apply_patch` is handled).
+* @param command - The `apply_patch` patch body (tool_input.command).
+* @returns Absolute paths of new files created under cwd.
+*/
+function resolveApplyPatchNewFileTargets(cwd, toolName, command) {
+	if (!command || toolName !== "apply_patch") return [];
+	const targets = [];
+	for (const filePath of parseApplyPatchTargets(command).added) {
+		const absoluteFilePath = node_path.default.isAbsolute(filePath) ? filePath : node_path.default.join(cwd, filePath);
+		if (absoluteFilePath.startsWith(cwd + node_path.default.sep) || absoluteFilePath === cwd) targets.push(absoluteFilePath);
+	}
+	return targets;
+}
+/**
+* Returns the file paths a Codex `apply_patch` call writes (adds or updates), as
+* written in the patch. Used to correlate post-write edits with a scaffold's
+* generated files. Returns an empty array for any other tool or a missing command.
+*
+* @param toolName - The Codex tool name (only `apply_patch` is handled).
+* @param command - The `apply_patch` patch body (tool_input.command).
+* @returns The added and updated paths (verbatim).
+*/
+function resolveApplyPatchEditedPaths(toolName, command) {
+	if (!command || toolName !== "apply_patch") return [];
+	const { added, updated } = parseApplyPatchTargets(command);
+	return [...added, ...updated];
+}
+function formatScaffoldMethodsHookMessage(methods, options) {
+	const maxMethods = options?.maxMethods ?? 5;
+	const requiredVarsMethodLimit = options?.requiredVarsMethodLimit ?? 2;
+	const maxRequiredVars = options?.maxRequiredVars ?? 3;
+	const visibleMethods = methods.slice(0, maxMethods);
+	const hiddenCount = Math.max(methods.length - visibleMethods.length, 0);
+	let message = "Before writing this new file, use `use-scaffold-method` if any of these fit:\n\n";
+	for (const [index, method] of visibleMethods.entries()) {
+		message += `- **${method.name}**: ${method.description || "No description available"}\n`;
+		if (options?.includeRequiredVars && index < requiredVarsMethodLimit) {
+			const requiredVars = method.variables_schema?.required ?? [];
+			if (requiredVars.length > 0) {
+				const visibleVars = requiredVars.slice(0, maxRequiredVars);
+				const moreCount = Math.max(requiredVars.length - visibleVars.length, 0);
+				const suffix = moreCount > 0 ? `, +${moreCount} more` : "";
+				message += `  Required: ${visibleVars.join(", ")}${suffix}\n`;
+			}
+		}
+	}
+	if (hiddenCount > 0) message += `\n...and ${hiddenCount} more methods. Call \`list-scaffolding-methods\` for the full list.\n`;
+	return message.trimEnd();
+}
+//#endregion
+Object.defineProperty(exports, "formatScaffoldMethodsHookMessage", {
+	enumerable: true,
+	get: function() {
+		return formatScaffoldMethodsHookMessage;
+	}
+});
+Object.defineProperty(exports, "getGlobalExcludeGlobs", {
+	enumerable: true,
+	get: function() {
+		return getGlobalExcludeGlobs;
+	}
+});
+Object.defineProperty(exports, "matchesExcludeGlob", {
+	enumerable: true,
+	get: function() {
+		return matchesExcludeGlob;
+	}
+});
+Object.defineProperty(exports, "resolveApplyPatchEditedPaths", {
+	enumerable: true,
+	get: function() {
+		return resolveApplyPatchEditedPaths;
+	}
+});
+Object.defineProperty(exports, "resolveApplyPatchNewFileTargets", {
+	enumerable: true,
+	get: function() {
+		return resolveApplyPatchNewFileTargets;
+	}
+});
+Object.defineProperty(exports, "resolveNewFileWriteTarget", {
+	enumerable: true,
+	get: function() {
+		return resolveNewFileWriteTarget;
+	}
+});