claude_hooks 1.0.2 → 1.2.0

data/lib/claude_hooks/message_display.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module ClaudeHooks
+  # MessageDisplay runs while assistant message text is displayed on screen.
+  # Display-only: exit code and decision fields are ignored. The only effect is
+  # replacing the on-screen text via hookSpecificOutput.displayContent — the
+  # transcript and what Claude sees keep the original text.
+  class MessageDisplay < Base
+    def self.hook_type
+      'MessageDisplay'
+    end
+
+    def self.input_fields
+      %w[turn_id message_id index final delta]
+    end
+
+    # === INPUT DATA ACCESS ===
+
+    def turn_id
+      @input_data['turn_id'] || @input_data['turnId']
+    end
+
+    def message_id
+      @input_data['message_id'] || @input_data['messageId']
+    end
+
+    def index
+      @input_data['index']
+    end
+
+    def final
+      @input_data.key?('final') ? @input_data['final'] : @input_data['isFinal']
+    end
+    alias_method :final?, :final
+
+    # The streamed assistant text delta for this event.
+    def delta
+      @input_data['delta']
+    end
+
+    # Some payloads expose the full text so far; kept as a convenience reader.
+    def message_text
+      @input_data['message_text'] || @input_data['messageText']
+    end
+
+    # === OUTPUT DATA HELPERS ===
+
+    # Replace the text shown on screen (display-only).
+    def display_content!(content)
+      @output_data['hookSpecificOutput'] = {
+        'hookEventName' => hook_event_name,
+        'displayContent' => content
+      }
+    end
+  end
+end

data/lib/claude_hooks/notification.rb

@@ -9,7 +9,7 @@ module ClaudeHooks
     end
 
     def self.input_fields
-      %w[message]
+      %w[message notification_type]
     end
 
     # === INPUT DATA ACCESS ===
@@ -18,5 +18,9 @@ module ClaudeHooks
       @input_data['message']
     end
     alias_method :notification_message, :message
+
+    def notification_type
+      @input_data['notification_type'] || @input_data['notificationType']
+    end
   end
 end

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)
@@ -119,6 +124,8 @@ module ClaudeHooks
           UserPromptSubmit.new(data)
         when 'PreToolUse'
           PreToolUse.new(data)
+        when 'PermissionRequest'
+          PermissionRequest.new(data)
         when 'PostToolUse'
           PostToolUse.new(data)
         when 'Stop'
@@ -127,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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module ClaudeHooks
+  module Output
+    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
+        behavior || hook_specific_output['permissionDecision']
+      end
+
+      # Read decision.message with legacy permissionDecisionReason fallback
+      def permission_reason
+        hook_specific_output.dig('decision', 'message') ||
+          hook_specific_output['permissionDecisionReason'] || ''
+      end
+
+      # Read decision.updatedInput with flat legacy fallback
+      def updated_input
+        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 ===
+
+      def allowed?
+        permission_decision == 'allow'
+      end
+
+      def denied?
+        permission_decision == 'deny'
+      end
+
+      def input_updated?
+        !updated_input.nil?
+      end
+
+      # === EXIT CODE LOGIC ===
+
+      def exit_code
+        0
+      end
+
+      # === OUTPUT STREAM LOGIC ===
+
+      def output_stream
+        :stdout
+      end
+
+      # === MERGE HELPER ===
+
+      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
+
+        # 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
+
+          # Support both nested and legacy flat shapes
+          current_behavior = output_data.dig('hookSpecificOutput', 'decision', 'behavior') ||
+                             output_data.dig('hookSpecificOutput', 'permissionDecision')
+          next unless current_behavior
+
+          behavior = 'deny' if current_behavior == 'deny'
+
+          msg = output_data.dig('hookSpecificOutput', 'decision', 'message') ||
+                output_data.dig('hookSpecificOutput', 'permissionDecisionReason')
+          messages << msg if msg && !msg.empty?
+
+          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' }
+        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
+    end
+  end
+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