claude_hooks 1.1.0 → 1.2.0

data/lib/claude_hooks/output/base.rb

@@ -40,6 +40,10 @@ module ClaudeHooks
         @data['hookSpecificOutput'] || {}
       end
 
+      def terminal_sequence
+        @data['terminalSequence']
+      end
+
       # === JSON SERIALIZATION ===
 
       # Convert to JSON string (same as existing stringify_output)
@@ -100,11 +104,12 @@ module ClaudeHooks
         # Apply base merge logic
         compacted_outputs.each do |output|
           output_data = output.respond_to?(:data) ? output.data : output
-          
+
           merged_data['continue'] = false if output_data['continue'] == false
           merged_data['suppressOutput'] = true if output_data['suppressOutput'] == true
           merged_data['stopReason'] = [merged_data['stopReason'], output_data['stopReason']].compact.reject(&:empty?).join('; ')
           merged_data['systemMessage'] = [merged_data['systemMessage'], output_data['systemMessage']].compact.reject(&:empty?).join('; ')
+          merged_data['terminalSequence'] = output_data['terminalSequence'] unless output_data['terminalSequence'].nil?
         end
 
         self.new(merged_data)
@@ -129,12 +134,52 @@ module ClaudeHooks
           SubagentStop.new(data)
         when 'Notification'
           Notification.new(data)
+        when 'MessageDisplay'
+          MessageDisplay.new(data)
         when 'SessionStart'
           SessionStart.new(data)
         when 'SessionEnd'
           SessionEnd.new(data)
         when 'PreCompact'
           PreCompact.new(data)
+        when 'Setup'
+          Setup.new(data)
+        when 'SubagentStart'
+          SubagentStart.new(data)
+        when 'UserPromptExpansion'
+          UserPromptExpansion.new(data)
+        when 'PostToolBatch'
+          PostToolBatch.new(data)
+        when 'ConfigChange'
+          ConfigChange.new(data)
+        when 'TaskCreated'
+          TaskCreated.new(data)
+        when 'TaskCompleted'
+          TaskCompleted.new(data)
+        when 'TeammateIdle'
+          TeammateIdle.new(data)
+        when 'PostToolUseFailure'
+          PostToolUseFailure.new(data)
+        when 'StopFailure'
+          StopFailure.new(data)
+        when 'PostCompact'
+          PostCompact.new(data)
+        when 'CwdChanged'
+          CwdChanged.new(data)
+        when 'FileChanged'
+          FileChanged.new(data)
+        when 'InstructionsLoaded'
+          InstructionsLoaded.new(data)
+        when 'WorktreeRemove'
+          WorktreeRemove.new(data)
+        when 'PermissionDenied'
+          PermissionDenied.new(data)
+        when 'Elicitation'
+          Elicitation.new(data)
+        when 'ElicitationResult'
+          ElicitationResult.new(data)
+        when 'WorktreeCreate'
+          WorktreeCreate.new(data)
         else
           raise ArgumentError, "Unknown hook type: #{hook_type}"
         end

data/lib/claude_hooks/output/config_change.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module ClaudeHooks
+  module Output
+    class ConfigChange < Base
+      def decision
+        @data['decision']
+      end
+
+      def reason
+        @data['reason'] || ''
+      end
+
+      def blocked?
+        decision == 'block'
+      end
+
+      def exit_code
+        default_exit_code
+      end
+
+      def self.merge(*outputs)
+        compacted_outputs = outputs.compact
+        return compacted_outputs.first if compacted_outputs.length == 1
+        return super(*outputs) if compacted_outputs.empty?
+
+        merged = super(*outputs)
+        merged_data = merged.data
+        reasons = []
+
+        compacted_outputs.each do |output|
+          output_data = output.respond_to?(:data) ? output.data : output
+          if output_data['decision'] == 'block'
+            merged_data['decision'] = 'block'
+            r = output_data['reason']
+            reasons << r if r && !r.empty?
+          end
+        end
+
+        merged_data['reason'] = reasons.join('; ') if reasons.any?
+        new(merged_data)
+      end
+    end
+  end
+end

data/lib/claude_hooks/output/cwd_changed.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module ClaudeHooks
+  module Output
+    class CwdChanged < Base
+      def watch_paths
+        hook_specific_output['watchPaths'] || []
+      end
+
+      def exit_code
+        default_exit_code
+      end
+
+      def self.merge(*outputs)
+        compacted_outputs = outputs.compact
+        return compacted_outputs.first if compacted_outputs.length == 1
+        return super(*outputs) if compacted_outputs.empty?
+
+        merged = super(*outputs)
+        merged_data = merged.data
+        all_paths = []
+
+        compacted_outputs.each do |output|
+          output_data = output.respond_to?(:data) ? output.data : output
+          paths = output_data.dig('hookSpecificOutput', 'watchPaths')
+          all_paths.concat(paths) if paths&.any?
+        end
+
+        unless all_paths.empty?
+          merged_data['hookSpecificOutput'] = {
+            'hookEventName' => 'CwdChanged',
+            'watchPaths' => all_paths.uniq
+          }
+        end
+
+        new(merged_data)
+      end
+    end
+  end
+end

data/lib/claude_hooks/output/elicitation.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module ClaudeHooks
+  module Output
+    class Elicitation < Base
+      def action
+        hook_specific_output['action']
+      end
+
+      def content
+        hook_specific_output['content'] || {}
+      end
+
+      def accepted?
+        action == 'accept'
+      end
+
+      def declined?
+        action == 'decline'
+      end
+
+      def cancelled?
+        action == 'cancel'
+      end
+
+      def exit_code
+        0
+      end
+
+      def output_stream
+        :stdout
+      end
+
+      def self.merge(*outputs)
+        compacted_outputs = outputs.compact
+        return compacted_outputs.first if compacted_outputs.length == 1
+        return super(*outputs) if compacted_outputs.empty?
+
+        # Last non-nil action wins
+        merged = super(*outputs)
+        merged_data = merged.data
+        last_action = nil
+        last_content = nil
+
+        compacted_outputs.each do |output|
+          output_data = output.respond_to?(:data) ? output.data : output
+          a = output_data.dig('hookSpecificOutput', 'action')
+          next unless a
+          last_action = a
+          last_content = output_data.dig('hookSpecificOutput', 'content')
+        end
+
+        if last_action
+          merged_data['hookSpecificOutput'] = {
+            'hookEventName' => 'Elicitation',
+            'action' => last_action
+          }
+          merged_data['hookSpecificOutput']['content'] = last_content if last_content
+        end
+
+        new(merged_data)
+      end
+    end
+  end
+end

data/lib/claude_hooks/output/elicitation_result.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module ClaudeHooks
+  module Output
+    class ElicitationResult < Base
+      def action
+        hook_specific_output['action']
+      end
+
+      def content
+        hook_specific_output['content'] || {}
+      end
+
+      def accepted?
+        action == 'accept'
+      end
+
+      def declined?
+        action == 'decline'
+      end
+
+      def cancelled?
+        action == 'cancel'
+      end
+
+      def exit_code
+        0
+      end
+
+      def output_stream
+        :stdout
+      end
+
+      def self.merge(*outputs)
+        compacted_outputs = outputs.compact
+        return compacted_outputs.first if compacted_outputs.length == 1
+        return super(*outputs) if compacted_outputs.empty?
+
+        merged = super(*outputs)
+        merged_data = merged.data
+        last_action = nil
+        last_content = nil
+
+        compacted_outputs.each do |output|
+          output_data = output.respond_to?(:data) ? output.data : output
+          a = output_data.dig('hookSpecificOutput', 'action')
+          next unless a
+          last_action = a
+          last_content = output_data.dig('hookSpecificOutput', 'content')
+        end
+
+        if last_action
+          merged_data['hookSpecificOutput'] = { 'hookEventName' => 'ElicitationResult', 'action' => last_action }
+          merged_data['hookSpecificOutput']['content'] = last_content if last_content
+        end
+
+        new(merged_data)
+      end
+    end
+  end
+end

data/lib/claude_hooks/output/file_changed.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module ClaudeHooks
+  module Output
+    class FileChanged < Base
+      def watch_paths
+        hook_specific_output['watchPaths'] || []
+      end
+
+      def exit_code
+        default_exit_code
+      end
+
+      def self.merge(*outputs)
+        compacted_outputs = outputs.compact
+        return compacted_outputs.first if compacted_outputs.length == 1
+        return super(*outputs) if compacted_outputs.empty?
+
+        merged = super(*outputs)
+        merged_data = merged.data
+        all_paths = []
+
+        compacted_outputs.each do |output|
+          output_data = output.respond_to?(:data) ? output.data : output
+          paths = output_data.dig('hookSpecificOutput', 'watchPaths')
+          all_paths.concat(paths) if paths&.any?
+        end
+
+        unless all_paths.empty?
+          merged_data['hookSpecificOutput'] = {
+            'hookEventName' => 'FileChanged',
+            'watchPaths' => all_paths.uniq
+          }
+        end
+
+        new(merged_data)
+      end
+    end
+  end
+end

data/lib/claude_hooks/output/instructions_loaded.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module ClaudeHooks
+  module Output
+    # InstructionsLoaded is non-blocking — exit code is ignored by Claude Code.
+    class InstructionsLoaded < Base
+      def exit_code
+        0
+      end
+
+      def self.merge(*outputs)
+        merged = super(*outputs)
+        new(merged.data)
+      end
+    end
+  end
+end

data/lib/claude_hooks/output/message_display.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module ClaudeHooks
+  module Output
+    # MessageDisplay is display-only — exit code and decision fields are ignored.
+    # Only hookSpecificOutput.displayContent has an effect (replaces on-screen text).
+    class MessageDisplay < Base
+      def display_content
+        hook_specific_output['displayContent']
+      end
+
+      def exit_code
+        0
+      end
+
+      def output_stream
+        :stdout
+      end
+
+      # Last non-nil displayContent wins.
+      def self.merge(*outputs)
+        compacted_outputs = outputs.compact
+        return compacted_outputs.first if compacted_outputs.length == 1
+        return super(*outputs) if compacted_outputs.empty?
+
+        merged = super(*outputs)
+        merged_data = merged.data
+        last_content = nil
+
+        compacted_outputs.each do |output|
+          output_data = output.respond_to?(:data) ? output.data : output
+          content = output_data.dig('hookSpecificOutput', 'displayContent')
+          last_content = content unless content.nil?
+        end
+
+        unless last_content.nil?
+          merged_data['hookSpecificOutput'] = {
+            'hookEventName' => 'MessageDisplay',
+            'displayContent' => last_content
+          }
+        end
+
+        new(merged_data)
+      end
+    end
+  end
+end

data/lib/claude_hooks/output/permission_denied.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module ClaudeHooks
+  module Output
+    class PermissionDenied < Base
+      def retry?
+        hook_specific_output['retry'] == true
+      end
+
+      # Exit code is ignored by Claude Code for PermissionDenied.
+      def exit_code
+        0
+      end
+
+      def output_stream
+        :stdout
+      end
+
+      def self.merge(*outputs)
+        compacted_outputs = outputs.compact
+        return compacted_outputs.first if compacted_outputs.length == 1
+        return super(*outputs) if compacted_outputs.empty?
+
+        merged = super(*outputs)
+        merged_data = merged.data
+
+        # If any hook says retry, retry
+        should_retry = compacted_outputs.any? do |output|
+          output_data = output.respond_to?(:data) ? output.data : output
+          output_data.dig('hookSpecificOutput', 'retry') == true
+        end
+
+        merged_data['hookSpecificOutput'] ||= { 'hookEventName' => 'PermissionDenied' }
+        merged_data['hookSpecificOutput']['retry'] = should_retry
+
+        new(merged_data)
+      end
+    end
+  end
+end

data/lib/claude_hooks/output/permission_request.rb

@@ -7,16 +7,33 @@ module ClaudeHooks
     class PermissionRequest < Base
       # === PERMISSION DECISION ACCESSORS ===
 
+      def behavior
+        hook_specific_output.dig('decision', 'behavior')
+      end
+
+      # Read nested decision.behavior with flat legacy fallback
       def permission_decision
-        hook_specific_output['permissionDecision']
+        behavior || hook_specific_output['permissionDecision']
       end
 
+      # Read decision.message with legacy permissionDecisionReason fallback
       def permission_reason
-        hook_specific_output['permissionDecisionReason'] || ''
+        hook_specific_output.dig('decision', 'message') ||
+          hook_specific_output['permissionDecisionReason'] || ''
       end
 
+      # Read decision.updatedInput with flat legacy fallback
       def updated_input
-        hook_specific_output['updatedInput']
+        hook_specific_output.dig('decision', 'updatedInput') ||
+          hook_specific_output['updatedInput']
+      end
+
+      def updated_permissions
+        hook_specific_output.dig('decision', 'updatedPermissions')
+      end
+
+      def interrupt?
+        hook_specific_output.dig('decision', 'interrupt') == true
       end
 
       # === SEMANTIC HELPERS ===
@@ -34,16 +51,13 @@ module ClaudeHooks
       end
 
       # === EXIT CODE LOGIC ===
-      #
-      # PermissionRequest hooks use the advanced JSON API with exit code 0.
-      # Following the same pattern as PreToolUse (permission-based hooks).
+
       def exit_code
         0
       end
 
       # === OUTPUT STREAM LOGIC ===
-      #
-      # PermissionRequest hooks always output to stdout when using the JSON API.
+
       def output_stream
         :stdout
       end
@@ -58,35 +72,46 @@ module ClaudeHooks
         merged = super(*outputs)
         merged_data = merged.data
 
-        # PermissionRequest specific merge: deny > allow (most restrictive wins)
-        permission_decision = 'allow'
-        permission_reasons = []
+        # deny > allow (most restrictive wins)
+        behavior = 'allow'
+        messages = []
         updated_inputs = []
+        interrupt = false
+        updated_permissions = nil
 
         compacted_outputs.each do |output|
           output_data = output.respond_to?(:data) ? output.data : output
 
-          next unless output_data.dig('hookSpecificOutput', 'permissionDecision')
+          # Support both nested and legacy flat shapes
+          current_behavior = output_data.dig('hookSpecificOutput', 'decision', 'behavior') ||
+                             output_data.dig('hookSpecificOutput', 'permissionDecision')
+          next unless current_behavior
 
-          current_decision = output_data['hookSpecificOutput']['permissionDecision']
-          permission_decision = 'deny' if current_decision == 'deny'
+          behavior = 'deny' if current_behavior == 'deny'
 
-          reason = output_data.dig('hookSpecificOutput', 'permissionDecisionReason')
-          permission_reasons << reason if reason && !reason.empty?
+          msg = output_data.dig('hookSpecificOutput', 'decision', 'message') ||
+                output_data.dig('hookSpecificOutput', 'permissionDecisionReason')
+          messages << msg if msg && !msg.empty?
 
-          updated = output_data.dig('hookSpecificOutput', 'updatedInput')
+          updated = output_data.dig('hookSpecificOutput', 'decision', 'updatedInput') ||
+                    output_data.dig('hookSpecificOutput', 'updatedInput')
           updated_inputs << updated if updated
+
+          # Propagate interrupt (OR logic — if any output has it, merged should too)
+          interrupt = true if output_data.dig('hookSpecificOutput', 'decision', 'interrupt') == true
+
+          # Propagate updatedPermissions (last writer wins)
+          perms = output_data.dig('hookSpecificOutput', 'decision', 'updatedPermissions')
+          updated_permissions = perms unless perms.nil?
         end
 
         merged_data['hookSpecificOutput'] ||= { 'hookEventName' => 'PermissionRequest' }
-        merged_data['hookSpecificOutput']['permissionDecision'] = permission_decision
-        merged_data['hookSpecificOutput']['permissionDecisionReason'] = if permission_reasons.any?
-                                                                          permission_reasons.join('; ')
-                                                                        else
-                                                                          ''
-                                                                        end
-        # Last updated input wins
-        merged_data['hookSpecificOutput']['updatedInput'] = updated_inputs.last if updated_inputs.any?
+        decision = { 'behavior' => behavior }
+        decision['message'] = messages.join('; ') if messages.any?
+        decision['updatedInput'] = updated_inputs.last if updated_inputs.any?
+        decision['interrupt'] = interrupt
+        decision['updatedPermissions'] = updated_permissions unless updated_permissions.nil?
+        merged_data['hookSpecificOutput']['decision'] = decision
 
         new(merged_data)
       end

data/lib/claude_hooks/output/post_compact.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module ClaudeHooks
+  module Output
+    class PostCompact < Base
+      def exit_code
+        default_exit_code
+      end
+
+      def self.merge(*outputs)
+        merged = super(*outputs)
+        new(merged.data)
+      end
+    end
+  end
+end

data/lib/claude_hooks/output/post_tool_batch.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module ClaudeHooks
+  module Output
+    class PostToolBatch < Base
+      def decision
+        @data['decision']
+      end
+
+      def reason
+        @data['reason'] || ''
+      end
+
+      def blocked?
+        decision == 'block'
+      end
+
+      def additional_context
+        hook_specific_output['additionalContext'] || ''
+      end
+
+      def exit_code
+        default_exit_code
+      end
+
+      def self.merge(*outputs)
+        compacted_outputs = outputs.compact
+        return compacted_outputs.first if compacted_outputs.length == 1
+        return super(*outputs) if compacted_outputs.empty?
+
+        merged = super(*outputs)
+        merged_data = merged.data
+        reasons = []
+
+        compacted_outputs.each do |output|
+          output_data = output.respond_to?(:data) ? output.data : output
+          if output_data['decision'] == 'block'
+            merged_data['decision'] = 'block'
+            r = output_data['reason']
+            reasons << r if r && !r.empty?
+          end
+        end
+
+        merged_data['reason'] = reasons.join('; ') if reasons.any?
+        new(merged_data)
+      end
+    end
+  end
+end

data/lib/claude_hooks/output/post_tool_use.rb

@@ -19,12 +19,24 @@ module ClaudeHooks
         hook_specific_output['additionalContext'] || ''
       end
 
+      def updated_tool_output
+        hook_specific_output['updatedToolOutput']
+      end
+
+      def updated_mcp_tool_output
+        hook_specific_output['updatedMCPToolOutput']
+      end
+
       # === SEMANTIC HELPERS ===
 
       def blocked?
         decision == 'block'
       end
 
+      def output_updated?
+        !updated_tool_output.nil? || !updated_mcp_tool_output.nil?
+      end
+
       # === EXIT CODE LOGIC ===
       #
       # PostToolUse hooks use the advanced JSON API with exit code 0.