@agiflowai/hooks-adapter 0.0.0 → 0.0.2

package/dist/index.mjs

@@ -1,19 +1,19 @@
+import { log } from "@agiflowai/aicode-utils";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import * as os from "node:os";
 import * as crypto from "node:crypto";
-import { CLAUDE_CODE } from "@agiflowai/coding-agent-bridge";
 
-//#region src/constants/index.ts
+//#region src/constants/hookTypes.ts
 /**
-* @agiflowai/hooks-adapter - Constants
+* Hook Types Constants
 *
 * DESIGN PATTERNS:
 * - Strongly-typed constant exports for compile-time safety
 * - Immutable by default (as const assertions)
 *
 * CODING STANDARDS:
-* - Primitive constants: UPPER_SNAKE_CASE
+* - Primitive constants: UPPER_SNAKE_CASE or PascalCase for event names
 * - Always include JSDoc with purpose and usage
 *
 * AVOID:
@@ -21,19 +21,36 @@ import { CLAUDE_CODE } from "@agiflowai/coding-agent-bridge";
 * - Magic strings without explanation
 */
 /**
-* Hook type identifiers for different hook events
+* Hook type identifiers for Claude Code hook events
 */
 const PRE_TOOL_USE = "PreToolUse";
 const POST_TOOL_USE = "PostToolUse";
+/**
+* Hook type identifiers for Gemini CLI hook events
+*/
+const BEFORE_TOOL_USE = "BeforeTool";
+const AFTER_TOOL_USE = "AfterTool";
+
+//#endregion
+//#region src/constants/decisions.ts
+/**
+* Normalized hook decision types used across all adapters
+* Adapters convert platform-specific formats to these normalized values
+*/
+const DECISION_ALLOW = "allow";
+const DECISION_DENY = "deny";
+const DECISION_SKIP = "skip";
+const DECISION_ASK = "ask";
 
 //#endregion
 //#region src/adapters/BaseAdapter.ts
 /**
-* Abstract base adapter for normalizing AI agent hook formats
+* Abstract base adapter for AI agent hook formats
+* @template TContext - The adapter-specific input context type
 */
 var BaseAdapter = class {
 	/**
-	* Execute hook callback with normalized context
+	* Execute hook callback with context
 	* Template method that orchestrates the hook execution flow
 	*
 	* @param callback - Hook callback function to execute
@@ -54,6 +71,32 @@ var BaseAdapter = class {
 		}
 	}
 	/**
+	* Execute multiple hooks with shared stdin (read once, execute all)
+	* This is useful when multiple hooks need to process the same input
+	* @param callbacks - Array of callback functions to execute
+	*/
+	async executeMultiple(callbacks) {
+		try {
+			const stdin = await this.readStdin();
+			const context = this.parseInput(stdin);
+			const responses = [];
+			for (const callback of callbacks) {
+				const response = await callback(context);
+				responses.push(response);
+			}
+			const finalResponse = responses.find((r) => r.decision !== "skip");
+			if (!finalResponse) {
+				process.exit(0);
+				return;
+			}
+			const output = this.formatOutput(finalResponse);
+			console.log(output);
+			process.exit(0);
+		} catch (error) {
+			this.handleError(error);
+		}
+	}
+	/**
 	* Read stdin from AI agent
 	* @returns Promise resolving to stdin content
 	*/
@@ -91,16 +134,18 @@ var BaseAdapter = class {
 //#endregion
 //#region src/adapters/ClaudeCodeAdapter.ts
 /**
-* ClaudeCodeAdapter - Adapter for Claude Code hook format
+* ClaudeCodeAdapter - Unified adapter for Claude Code hook format (PreToolUse & PostToolUse)
 *
 * DESIGN PATTERNS:
 * - Adapter pattern: Converts Claude Code format to normalized format
 * - Parser pattern: Extracts file paths and operations from tool inputs
+* - State pattern: Stores hook event type to morph behavior between PreToolUse and PostToolUse
 *
 * CODING STANDARDS:
 * - Parse Claude Code JSON stdin format exactly as specified
 * - Format output to match Claude Code hook response schema
 * - Handle missing/optional fields gracefully
+* - Support both PreToolUse and PostToolUse events in one adapter
 *
 * AVOID:
 * - Assuming all fields are present
@@ -108,84 +153,88 @@ var BaseAdapter = class {
 * - Mutating input objects
 */
 /**
-* Adapter for Claude Code hook format
+* Unified adapter for Claude Code hook format (PreToolUse & PostToolUse)
 */
 var ClaudeCodeAdapter = class extends BaseAdapter {
+	hookEventName = "PreToolUse";
 	/**
-	* Parse Claude Code stdin into normalized HookContext
+	* Parse Claude Code stdin into ClaudeCodeHookInput
 	*
 	* @param stdin - Raw JSON string from Claude Code
-	* @returns Normalized hook context
+	* @returns ClaudeCodeHookInput
 	*/
 	parseInput(stdin) {
+		log.debug("ClaudeCodeAdapter: Parsing input", { stdin });
 		const input = JSON.parse(stdin);
-		return {
-			toolName: input.tool_name,
-			toolInput: input.tool_input,
-			filePath: this.extractFilePath(input.tool_name, input.tool_input),
-			operation: this.extractOperation(input.tool_name),
-			cwd: input.cwd,
-			sessionId: input.session_id,
-			llmTool: input.llm_tool
-		};
+		this.hookEventName = input.hook_event_name;
+		log.debug("ClaudeCodeAdapter: Parsed input", {
+			hookEventName: this.hookEventName,
+			input
+		});
+		return input;
 	}
 	/**
 	* Format normalized HookResponse into Claude Code output
+	* Morphs output based on hook event type (PreToolUse vs PostToolUse)
 	*
 	* @param response - Normalized hook response
 	* @returns JSON string for Claude Code
 	*/
 	formatOutput(response) {
-		if (response.decision === "skip") return JSON.stringify({}, null, 2);
+		log.debug("ClaudeCodeAdapter: Formatting output", {
+			hookEventName: this.hookEventName,
+			response
+		});
+		if (response.decision === "skip") {
+			const emptyOutput = JSON.stringify({}, null, 2);
+			log.debug("ClaudeCodeAdapter: Skip decision, returning empty output");
+			return emptyOutput;
+		}
+		if (this.hookEventName === "PostToolUse") return this.formatPostToolUseOutput(response);
+		return this.formatPreToolUseOutput(response);
+	}
+	/**
+	* Format PreToolUse output
+	*/
+	formatPreToolUseOutput(response) {
 		const output = { hookSpecificOutput: {
 			hookEventName: "PreToolUse",
 			permissionDecision: response.decision,
 			permissionDecisionReason: response.message
 		} };
 		if (response.updatedInput) output.hookSpecificOutput.updatedInput = response.updatedInput;
-		return JSON.stringify(output, null, 2);
+		const formattedOutput = JSON.stringify(output, null, 2);
+		log.debug("ClaudeCodeAdapter: Formatted PreToolUse output", { output: formattedOutput });
+		return formattedOutput;
 	}
 	/**
-	* Extract file path from tool input
-	*
-	* @param toolName - Name of the tool
-	* @param toolInput - Tool input parameters
-	* @returns File path if this is a file operation
+	* Format PostToolUse output
 	*/
-	extractFilePath(toolName, toolInput) {
-		if ([
-			"Read",
-			"Write",
-			"Edit"
-		].includes(toolName)) return toolInput.file_path;
-	}
-	/**
-	* Extract operation type from tool name
-	*
-	* @param toolName - Name of the tool
-	* @returns Operation type if this is a file operation
-	*/
-	extractOperation(toolName) {
-		return {
-			Read: "read",
-			Write: "write",
-			Edit: "edit"
-		}[toolName];
+	formatPostToolUseOutput(response) {
+		const output = { hookSpecificOutput: { hookEventName: "PostToolUse" } };
+		if (response.decision === "deny") {
+			output.decision = "block";
+			output.reason = response.message;
+		}
+		if (response.decision === "allow" && response.message) output.hookSpecificOutput.additionalContext = response.message;
+		const formattedOutput = JSON.stringify(output, null, 2);
+		log.debug("ClaudeCodeAdapter: Formatted PostToolUse output", { output: formattedOutput });
+		return formattedOutput;
 	}
 };
 
 //#endregion
-//#region src/adapters/ClaudeCodePostToolUseAdapter.ts
+//#region src/adapters/GeminiCliAdapter.ts
 /**
-* ClaudeCodePostToolUseAdapter - Adapter for Claude Code PostToolUse hook format
+* GeminiCliAdapter - Adapter for Gemini CLI hook format
 *
 * DESIGN PATTERNS:
-* - Adapter pattern: Converts Claude Code PostToolUse format to normalized format
-* - Parser pattern: Extracts file paths and operations from tool response
+* - Adapter pattern: Converts Gemini CLI format to normalized format
+* - Parser pattern: Extracts file paths and operations from tool inputs
 *
 * CODING STANDARDS:
-* - Parse Claude Code JSON stdin format exactly as specified
-* - Format output to match Claude Code PostToolUse hook response schema
+* - Parse Gemini CLI JSON stdin format exactly as specified
+* - Format output to match Gemini CLI hook response schema
 * - Handle missing/optional fields gracefully
 *
 * AVOID:
@@ -194,69 +243,44 @@ var ClaudeCodeAdapter = class extends BaseAdapter {
 * - Mutating input objects
 */
 /**
-* Adapter for Claude Code PostToolUse hook format
+* Adapter for Gemini CLI hook format
 */
-var ClaudeCodePostToolUseAdapter = class extends BaseAdapter {
+var GeminiCliAdapter = class extends BaseAdapter {
 	/**
-	* Parse Claude Code PostToolUse stdin into normalized HookContext
+	* Parse Gemini CLI stdin into full hook input (preserves all fields)
 	*
-	* @param stdin - Raw JSON string from Claude Code
-	* @returns Normalized hook context
+	* @param stdin - Raw JSON string from Gemini CLI
+	* @returns Full Gemini CLI hook input
 	*/
 	parseInput(stdin) {
+		log.debug("GeminiCliAdapter.parseInput - Raw input:", stdin);
 		const input = JSON.parse(stdin);
-		return {
-			toolName: input.tool_name,
-			toolInput: input.tool_input,
-			filePath: this.extractFilePath(input.tool_name, input.tool_input, input.tool_response),
-			operation: this.extractOperation(input.tool_name),
-			cwd: input.cwd,
-			sessionId: input.session_id,
-			llmTool: input.llm_tool
-		};
+		log.debug("GeminiCliAdapter.parseInput - Parsed input:", JSON.stringify(input, null, 2));
+		return input;
 	}
 	/**
-	* Format normalized HookResponse into Claude Code PostToolUse output
+	* Format normalized HookResponse into Gemini CLI output
 	*
 	* @param response - Normalized hook response
-	* @returns JSON string for Claude Code
+	* @returns JSON string for Gemini CLI
 	*/
 	formatOutput(response) {
-		const output = { hookSpecificOutput: { hookEventName: "PostToolUse" } };
-		if (response.decision === "deny") {
-			output.decision = "block";
-			output.reason = response.message;
+		log.debug("GeminiCliAdapter.formatOutput - Normalized response:", JSON.stringify(response, null, 2));
+		if (response.decision === DECISION_SKIP) {
+			const output$1 = JSON.stringify({ decision: "ALLOW" }, null, 2);
+			log.debug("GeminiCliAdapter.formatOutput - Output (skip):", output$1);
+			return output$1;
 		}
-		if (response.decision === "allow" && response.message) output.hookSpecificOutput.additionalContext = response.message;
-		return JSON.stringify(output, null, 2);
-	}
-	/**
-	* Extract file path from tool input or response
-	*
-	* @param toolName - Name of the tool
-	* @param toolInput - Tool input parameters
-	* @param toolResponse - Tool response data
-	* @returns File path if this is a file operation
-	*/
-	extractFilePath(toolName, toolInput, toolResponse) {
-		if ([
-			"Read",
-			"Write",
-			"Edit"
-		].includes(toolName)) return toolInput.file_path || toolResponse.filePath;
-	}
-	/**
-	* Extract operation type from tool name
-	*
-	* @param toolName - Name of the tool
-	* @returns Operation type if this is a file operation
-	*/
-	extractOperation(toolName) {
-		return {
-			Read: "read",
-			Write: "write",
-			Edit: "edit"
-		}[toolName];
+		const output = { decision: {
+			[DECISION_ALLOW]: "ALLOW",
+			[DECISION_DENY]: "DENY",
+			[DECISION_ASK]: "ASK_USER"
+		}[response.decision] || "ALLOW" };
+		if (response.message) output.message = response.message;
+		if (response.updatedInput) output.updatedInput = response.updatedInput;
+		const outputStr = JSON.stringify(output, null, 2);
+		log.debug("GeminiCliAdapter.formatOutput - Output:", outputStr);
+		return outputStr;
 	}
 };
 
@@ -271,7 +295,7 @@ var ClaudeCodePostToolUseAdapter = class extends BaseAdapter {
 * - Singleton cache: In-memory cache for performance
 *
 * CODING STANDARDS:
-* - Use static methods for stateless operations
+* - Use instance methods for session-scoped operations
 * - Handle file system errors gracefully
 * - Optimize for performance with efficient data structures
 *
@@ -281,53 +305,88 @@ var ClaudeCodePostToolUseAdapter = class extends BaseAdapter {
 * - Complex parsing logic (keep it simple)
 */
 /**
+* Type guard for Node.js filesystem errors
+*/
+function isNodeError(error) {
+	return error instanceof Error && "code" in error;
+}
+/**
 * Service for tracking hook executions using an append-only log
 * Prevents duplicate hook actions (e.g., showing design patterns twice for same file)
+* Each session has its own log file for isolation
 */
 var ExecutionLogService = class ExecutionLogService {
-	/** Log file path - stored in system temp directory */
-	static LOG_FILE = path.join(os.tmpdir(), "hook-adapter-executions.jsonl");
+	/** Log file path for this session - stored in system temp directory */
+	logFile;
 	/** In-memory cache of recent executions (last 1000 entries) */
-	static cache = null;
+	cache = null;
 	/** Max cache size to prevent memory bloat */
 	static MAX_CACHE_SIZE = 1e3;
+	/** Session ID for this service instance */
+	sessionId;
+	/**
+	* Create a new ExecutionLogService instance for a specific session
+	* @param sessionId - Unique session identifier
+	*/
+	constructor(sessionId) {
+		this.sessionId = sessionId;
+		this.logFile = path.join(os.tmpdir(), `hook-adapter-executions-${sessionId}.jsonl`);
+	}
 	/**
 	* Check if a specific action was already taken for this file in this session
 	*
-	* @param sessionId - Session identifier
-	* @param filePath - File path to check
-	* @param decision - Decision to check for (e.g., 'deny' means we already showed patterns)
-	* @returns true if the action was already taken
+	* NOTE: Uses fail-open strategy - on error, returns false to allow action.
+	* This ensures hooks can still provide guidance even if log access fails.
+	*
+	* @param params - Parameters for checking execution
+	* @returns true if the action was already taken, false on error (fail-open)
 	*/
-	static async hasExecuted(sessionId, filePath, decision) {
-		const entries = await ExecutionLogService.loadLog();
-		for (let i = entries.length - 1; i >= 0; i--) {
-			const entry = entries[i];
-			if (entry.sessionId === sessionId && entry.filePath === filePath && entry.decision === decision) return true;
+	async hasExecuted(params) {
+		const { filePath, decision, filePattern, projectPath } = params;
+		try {
+			const entries = await this.loadLog();
+			for (let i = entries.length - 1; i >= 0; i--) {
+				const entry = entries[i];
+				const matchedFile = entry.filePattern === filePattern && entry.filePattern && filePattern || entry.filePath === filePath;
+				const matchedProject = !projectPath || entry.projectPath === projectPath;
+				if (entry.decision === decision && matchedFile && matchedProject) return true;
+			}
+			return false;
+		} catch (error) {
+			console.error(`Error checking execution for ${filePath}:`, error);
+			return false;
 		}
-		return false;
 	}
 	/**
 	* Log a hook execution
 	*
-	* @param params - Log execution parameters
+	* NOTE: This method uses fail-silent strategy. Logging failures should never
+	* break hook execution since the hook's primary purpose is to provide guidance,
+	* not to persist data. The log is used for optimization (preventing duplicate
+	* guidance) rather than critical functionality.
+	*
+	* @param params - Log execution parameters (sessionId will be set automatically)
 	*/
-	static async logExecution(params) {
+	async logExecution(params) {
 		const entry = {
 			timestamp: Date.now(),
-			sessionId: params.sessionId,
+			sessionId: this.sessionId,
 			filePath: params.filePath,
 			operation: params.operation,
 			decision: params.decision,
 			filePattern: params.filePattern,
 			fileMtime: params.fileMtime,
-			fileChecksum: params.fileChecksum
+			fileChecksum: params.fileChecksum,
+			generatedFiles: params.generatedFiles,
+			scaffoldId: params.scaffoldId,
+			projectPath: params.projectPath,
+			featureName: params.featureName
 		};
 		try {
-			await fs.appendFile(ExecutionLogService.LOG_FILE, `${JSON.stringify(entry)}\n`, "utf-8");
-			if (ExecutionLogService.cache) {
-				ExecutionLogService.cache.push(entry);
-				if (ExecutionLogService.cache.length > ExecutionLogService.MAX_CACHE_SIZE) ExecutionLogService.cache = ExecutionLogService.cache.slice(-ExecutionLogService.MAX_CACHE_SIZE);
+			await fs.appendFile(this.logFile, `${JSON.stringify(entry)}\n`, "utf-8");
+			if (this.cache) {
+				this.cache.push(entry);
+				if (this.cache.length > ExecutionLogService.MAX_CACHE_SIZE) this.cache = this.cache.slice(-ExecutionLogService.MAX_CACHE_SIZE);
 			}
 		} catch (error) {
 			console.error("Failed to log hook execution:", error);
@@ -336,50 +395,73 @@ var ExecutionLogService = class ExecutionLogService {
 	/**
 	* Load execution log from file
 	* Uses in-memory cache for performance
+	*
+	* NOTE: Uses fail-silent strategy for non-ENOENT errors. The log is used for
+	* optimization (deduplication) rather than critical functionality. If the log
+	* cannot be read, returning empty allows hooks to continue with potentially
+	* duplicate guidance rather than failing entirely.
 	*/
-	static async loadLog() {
-		if (ExecutionLogService.cache !== null) return ExecutionLogService.cache;
+	async loadLog() {
+		if (this.cache !== null) return this.cache;
 		try {
-			const lines = (await fs.readFile(ExecutionLogService.LOG_FILE, "utf-8")).trim().split("\n").filter(Boolean);
+			const lines = (await fs.readFile(this.logFile, "utf-8")).trim().split("\n").filter(Boolean);
 			const entries = [];
 			for (const line of lines) try {
 				entries.push(JSON.parse(line));
-			} catch {}
-			ExecutionLogService.cache = entries.slice(-ExecutionLogService.MAX_CACHE_SIZE);
-			return ExecutionLogService.cache;
+			} catch (parseError) {
+				console.warn("Skipping malformed log entry:", line.substring(0, 100));
+			}
+			this.cache = entries.slice(-ExecutionLogService.MAX_CACHE_SIZE);
+			return this.cache;
 		} catch (error) {
-			if (error.code === "ENOENT") {
-				ExecutionLogService.cache = [];
-				return ExecutionLogService.cache;
+			if (isNodeError(error) && error.code === "ENOENT") {
+				this.cache = [];
+				return this.cache;
 			}
-			console.error("Failed to load execution log:", error);
-			ExecutionLogService.cache = [];
-			return ExecutionLogService.cache;
+			console.error(`Failed to load execution log from ${this.logFile}:`, error);
+			this.cache = [];
+			return this.cache;
 		}
 	}
 	/**
 	* Clear the execution log (for testing)
+	* @throws Error if deletion fails for reasons other than file not existing
 	*/
-	static async clearLog() {
+	async clearLog() {
 		try {
-			await fs.unlink(ExecutionLogService.LOG_FILE);
-			ExecutionLogService.cache = [];
+			await fs.unlink(this.logFile);
+			this.cache = [];
 		} catch (error) {
-			if (error.code !== "ENOENT") throw error;
+			if (isNodeError(error) && error.code === "ENOENT") {
+				this.cache = [];
+				return;
+			}
+			throw new Error(`Failed to clear execution log at ${this.logFile}: ${error instanceof Error ? error.message : "Unknown error"}`);
 		}
 	}
 	/**
 	* Get log statistics (for debugging)
+	*
+	* NOTE: Uses fail-open strategy - on error, returns zero counts.
+	* This is acceptable for debugging statistics which are non-critical.
+	*
+	* @returns Log statistics, or zeros on error (fail-open)
 	*/
-	static async getStats() {
-		const entries = await ExecutionLogService.loadLog();
-		const sessions = new Set(entries.map((e) => e.sessionId));
-		const files = new Set(entries.map((e) => e.filePath));
-		return {
-			totalEntries: entries.length,
-			uniqueSessions: sessions.size,
-			uniqueFiles: files.size
-		};
+	async getStats() {
+		try {
+			const entries = await this.loadLog();
+			const files = new Set(entries.map((e) => e.filePath));
+			return {
+				totalEntries: entries.length,
+				uniqueFiles: files.size
+			};
+		} catch (error) {
+			console.error("Error getting log stats:", error);
+			return {
+				totalEntries: 0,
+				uniqueFiles: 0
+			};
+		}
 	}
 	/**
 	* Get file metadata (mtime and checksum) for a file
@@ -387,7 +469,7 @@ var ExecutionLogService = class ExecutionLogService {
 	* @param filePath - Path to the file
 	* @returns File metadata or null if file doesn't exist
 	*/
-	static async getFileMetadata(filePath) {
+	async getFileMetadata(filePath) {
 		try {
 			const content = await fs.readFile(filePath, "utf-8");
 			const checksum = crypto.createHash("md5").update(content).digest("hex");
@@ -395,7 +477,9 @@ var ExecutionLogService = class ExecutionLogService {
 				mtime: (await fs.stat(filePath)).mtimeMs,
 				checksum
 			};
-		} catch {
+		} catch (error) {
+			if (isNodeError(error) && error.code === "ENOENT") return null;
+			console.warn(`Failed to get file metadata for ${filePath}:`, error);
 			return null;
 		}
 	}
@@ -403,78 +487,115 @@ var ExecutionLogService = class ExecutionLogService {
 	* Check if a file has changed since the last execution for this session
 	* Returns true if the file should be reviewed (new file or content changed)
 	*
-	* @param sessionId - Session identifier
+	* NOTE: Uses fail-open strategy - on error, returns true to allow review.
+	* This ensures hooks can still provide value even if log access fails.
+	*
 	* @param filePath - File path to check
 	* @param decision - Decision type to check for
-	* @returns true if file has changed or no previous execution found
+	* @returns true if file has changed or no previous execution found, true on error (fail-open)
 	*/
-	static async hasFileChanged(sessionId, filePath, decision) {
-		const entries = await ExecutionLogService.loadLog();
-		let lastExecution = null;
-		for (let i = entries.length - 1; i >= 0; i--) {
-			const entry = entries[i];
-			if (entry.sessionId === sessionId && entry.filePath === filePath && entry.decision === decision) {
-				lastExecution = entry;
-				break;
+	async hasFileChanged(filePath, decision) {
+		try {
+			const entries = await this.loadLog();
+			let lastExecution = null;
+			for (let i = entries.length - 1; i >= 0; i--) {
+				const entry = entries[i];
+				if (entry.filePath === filePath && entry.decision === decision) {
+					lastExecution = entry;
+					break;
+				}
 			}
+			if (!lastExecution || !lastExecution.fileChecksum) return true;
+			const currentMetadata = await this.getFileMetadata(filePath);
+			if (!currentMetadata) return true;
+			return currentMetadata.checksum !== lastExecution.fileChecksum;
+		} catch (error) {
+			console.error(`Error checking if file changed for ${filePath}:`, error);
+			return true;
 		}
-		if (!lastExecution || !lastExecution.fileChecksum) return true;
-		const currentMetadata = await ExecutionLogService.getFileMetadata(filePath);
-		if (!currentMetadata) return true;
-		return currentMetadata.checksum !== lastExecution.fileChecksum;
 	}
-};
-
-//#endregion
-//#region src/services/AdapterProxyService.ts
-/**
-* AdapterProxyService - Routes hook execution to appropriate adapter
-*
-* DESIGN PATTERNS:
-* - Proxy pattern: Routes requests to appropriate handlers
-* - Factory pattern: Creates adapter instances based on agent name
-*
-* CODING STANDARDS:
-* - Use static methods for stateless operations
-* - Provide clear error messages for invalid inputs
-* - Follow TitleCase naming convention for service classes
-*
-* AVOID:
-* - Creating adapter instances unnecessarily
-* - Silently falling back to defaults
-* - Complex conditional logic (use lookup tables)
-*/
-/**
-* Proxy service for routing hook execution
-* Eliminates duplication across commands by centralizing hook routing logic
-*/
-var AdapterProxyService = class AdapterProxyService {
 	/**
-	* Execute hook with the appropriate adapter for the agent
+	* Check if file was recently reviewed (within debounce window)
+	* Prevents noisy feedback during rapid successive edits
 	*
-	* @param agentName - Agent identifier (e.g., "claude-code")
-	* @param hookType - Type of hook ("PreToolUse" or "PostToolUse")
-	* @param callback - Hook callback function to execute
+	* NOTE: Uses fail-open strategy - on error, returns false to allow review.
+	* This ensures hooks can still provide value even if log access fails.
+	*
+	* @param filePath - File path to check
+	* @param debounceMs - Debounce window in milliseconds (default: 3000ms = 3 seconds)
+	* @returns true if file was reviewed within debounce window, false on error (fail-open)
 	*/
-	static async execute(agentName, hookType, callback) {
-		await AdapterProxyService.getAdapter(agentName, hookType).execute(callback);
+	async wasRecentlyReviewed(filePath, debounceMs = 3e3) {
+		try {
+			const entries = await this.loadLog();
+			const now = Date.now();
+			for (let i = entries.length - 1; i >= 0; i--) {
+				const entry = entries[i];
+				const isReviewOperation = entry.fileMtime !== void 0 || entry.fileChecksum !== void 0;
+				const isReviewDecision = entry.decision === "allow" || entry.decision === "deny";
+				if (entry.filePath === filePath && isReviewOperation && isReviewDecision) {
+					if (now - (entry.timestamp ?? 0) < debounceMs) return true;
+					return false;
+				}
+			}
+			return false;
+		} catch (error) {
+			console.error(`Error checking recent review for ${filePath}:`, error);
+			return false;
+		}
 	}
 	/**
-	* Get adapter instance for agent and hook type
+	* Check if a file was generated by a scaffold method
+	* Useful for hooks to avoid suggesting scaffold for files already created by scaffold
 	*
-	* @param agentName - Name of the AI agent (e.g., "claude-code")
-	* @param hookType - Type of hook ("PreToolUse" or "PostToolUse")
-	* @returns Adapter instance
+	* NOTE: Uses fail-open strategy - on error, returns false to allow scaffold suggestion.
+	* Worst case: user sees scaffold suggestion for an already-scaffolded file.
+	*
+	* @param filePath - File path to check
+	* @returns true if file was generated by scaffold in this session, false on error (fail-open)
 	*/
-	static getAdapter(agentName, hookType) {
-		switch (agentName) {
-			case CLAUDE_CODE:
-				if (hookType === POST_TOOL_USE) return new ClaudeCodePostToolUseAdapter();
-				return new ClaudeCodeAdapter();
-			default: throw new Error(`Unknown agent: ${agentName}. Supported: ${CLAUDE_CODE}`);
+	async wasGeneratedByScaffold(filePath) {
+		try {
+			const entries = await this.loadLog();
+			for (let i = entries.length - 1; i >= 0; i--) {
+				const entry = entries[i];
+				if (entry.operation === "scaffold") {
+					if (entry.generatedFiles && entry.generatedFiles.includes(filePath)) return true;
+				}
+			}
+			return false;
+		} catch (error) {
+			console.error(`Error checking if file was generated by scaffold for ${filePath}:`, error);
+			return false;
 		}
 	}
 };
 
 //#endregion
-export { AdapterProxyService, BaseAdapter, ClaudeCodeAdapter, ClaudeCodePostToolUseAdapter, ExecutionLogService, POST_TOOL_USE, PRE_TOOL_USE };
+//#region src/utils/parseHookType.ts
+/**
+* Parse hook type option in format: agent.hookMethod
+*
+* @param hookType - Hook type string in format '<agent>.<hookMethod>'
+* @returns Parsed hook type with agent and hookMethod
+* @throws Error if hook type format is invalid
+*
+* @example
+* parseHookType('claude-code.preToolUse')
+* // Returns: { agent: 'claude-code', hookMethod: 'preToolUse' }
+*
+* @example
+* parseHookType('gemini-cli.afterTool')
+* // Returns: { agent: 'gemini-cli', hookMethod: 'afterTool' }
+*/
+function parseHookType(hookType) {
+	const [agent, hookMethod] = hookType.split(".");
+	if (!agent || !hookMethod) throw new Error(`Invalid hook type: ${hookType}. Expected: <agent>.<hookMethod>`);
+	return {
+		agent,
+		hookMethod
+	};
+}
+
+//#endregion
+export { AFTER_TOOL_USE, BEFORE_TOOL_USE, BaseAdapter, ClaudeCodeAdapter, DECISION_ALLOW, DECISION_ASK, DECISION_DENY, DECISION_SKIP, ExecutionLogService, GeminiCliAdapter, POST_TOOL_USE, PRE_TOOL_USE, parseHookType };