claude_hooks 1.0.2 → 1.2.0

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.

data/lib/claude_hooks/output/post_tool_use_failure.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module ClaudeHooks
+  module Output
+    class PostToolUseFailure < Base
+      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
+        contexts = []
+
+        compacted_outputs.each do |output|
+          output_data = output.respond_to?(:data) ? output.data : output
+          context = output_data.dig('hookSpecificOutput', 'additionalContext')
+          contexts << context if context && !context.empty?
+        end
+
+        unless contexts.empty?
+          merged_data['hookSpecificOutput'] = {
+            'hookEventName' => 'PostToolUseFailure',
+            'additionalContext' => contexts.join("\n\n")
+          }
+        end
+
+        new(merged_data)
+      end
+    end
+  end
+end

data/lib/claude_hooks/output/pre_compact.rb

@@ -5,6 +5,20 @@ require_relative 'base'
 module ClaudeHooks
   module Output
     class PreCompact < Base
+      # === DECISION ACCESSORS ===
+
+      def decision
+        @data['decision']
+      end
+
+      def reason
+        @data['reason'] || ''
+      end
+
+      def blocked?
+        decision == 'block'
+      end
+
       def exit_code
         default_exit_code
       end
@@ -12,9 +26,26 @@ module ClaudeHooks
       # === 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)
-        new(merged.data)
-      end 
+        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
+end

data/lib/claude_hooks/output/pre_tool_use.rb

@@ -15,6 +15,10 @@ module ClaudeHooks
         hook_specific_output['permissionDecisionReason'] || ''
       end
 
+      def updated_input
+        hook_specific_output['updatedInput']
+      end
+
       # === SEMANTIC HELPERS ===
 
       def allowed?
@@ -30,6 +34,14 @@ module ClaudeHooks
         permission_decision == 'ask'
       end
 
+      def input_updated?
+        !updated_input.nil?
+      end
+
+      def deferred?
+        permission_decision == 'defer'
+      end
+
       # === EXIT CODE LOGIC ===
       #
       # PreToolUse hooks use the advanced JSON API with exit code 0.
@@ -58,7 +70,7 @@ module ClaudeHooks
         merged = super(*outputs)
         merged_data = merged.data
 
-        # PreToolUse specific merge: deny > ask > allow (most restrictive wins)
+        # PreToolUse specific merge: deny > defer > ask > allow (most restrictive wins)
         permission_decision = 'allow'
         permission_reasons = []
 
@@ -71,8 +83,10 @@ module ClaudeHooks
           case current_decision
           when 'deny'
             permission_decision = 'deny'
+          when 'defer'
+            permission_decision = 'defer' unless permission_decision == 'deny'
           when 'ask'
-            permission_decision = 'ask' unless permission_decision == 'deny'
+            permission_decision = 'ask' unless %w[deny defer].include?(permission_decision)
           end
 
           reason = output_data.dig('hookSpecificOutput', 'permissionDecisionReason')
@@ -87,6 +101,16 @@ module ClaudeHooks
                                                                           ''
                                                                         end
 
+        # If any output has updatedInput, use the last one (most recent wins)
+        updated_inputs = []
+        compacted_outputs.each do |output|
+          output_data = output.respond_to?(:data) ? output.data : output
+          updated = output_data.dig('hookSpecificOutput', 'updatedInput')
+          updated_inputs << updated if updated
+        end
+
+        merged_data['hookSpecificOutput']['updatedInput'] = updated_inputs.last if updated_inputs.any?
+
         new(merged_data)
       end
     end

data/lib/claude_hooks/output/session_start.rb

@@ -11,6 +11,22 @@ module ClaudeHooks
         hook_specific_output['additionalContext'] || ''
       end
 
+      def session_title
+        hook_specific_output['sessionTitle']
+      end
+
+      def initial_user_message
+        hook_specific_output['initialUserMessage']
+      end
+
+      def watch_paths
+        hook_specific_output['watchPaths'] || []
+      end
+
+      def reload_skills?
+        hook_specific_output['reloadSkills'] == true
+      end
+
       # === EXIT CODE LOGIC ===
 
       def exit_code
@@ -27,19 +43,25 @@ module ClaudeHooks
         merged = super(*outputs)
         merged_data = merged.data
         contexts = []
-        
+        specific = {}
+
         compacted_outputs.each do |output|
           output_data = output.respond_to?(:data) ? output.data : output
-          context = output_data.dig('hookSpecificOutput', 'additionalContext')
+          hso = output_data['hookSpecificOutput'] || {}
+
+          context = hso['additionalContext']
           contexts << context if context && !context.empty?
+
+          # Last-non-nil wins for the scalar/array session fields.
+          %w[sessionTitle initialUserMessage watchPaths reloadSkills].each do |key|
+            specific[key] = hso[key] unless hso[key].nil?
+          end
         end
 
-        # Set merged additional context
-        unless contexts.empty?
-          merged_data['hookSpecificOutput'] = {
-            'hookEventName' => 'SessionStart',
-            'additionalContext' => contexts.join("\n\n")
-          }
+        specific['additionalContext'] = contexts.join("\n\n") unless contexts.empty?
+
+        unless specific.empty?
+          merged_data['hookSpecificOutput'] = { 'hookEventName' => 'SessionStart' }.merge(specific)
         end
 
         new(merged_data)

data/lib/claude_hooks/output/setup.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module ClaudeHooks
+  module Output
+    class Setup < Base
+      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
+        contexts = []
+
+        compacted_outputs.each do |output|
+          output_data = output.respond_to?(:data) ? output.data : output
+          context = output_data.dig('hookSpecificOutput', 'additionalContext')
+          contexts << context if context && !context.empty?
+        end
+
+        unless contexts.empty?
+          merged_data['hookSpecificOutput'] = {
+            'hookEventName' => 'Setup',
+            'additionalContext' => contexts.join("\n\n")
+          }
+        end
+
+        new(merged_data)
+      end
+    end
+  end
+end

data/lib/claude_hooks/output/stop.rb

@@ -18,6 +18,10 @@ module ClaudeHooks
       end
       alias_method :continue_instructions, :reason
 
+      def additional_context
+        hook_specific_output['additionalContext'] || ''
+      end
+
       # === SEMANTIC HELPERS ===
 
       # Check if Claude should be forced to continue (decision == 'block')
@@ -61,6 +65,7 @@ module ClaudeHooks
 
         # A blocking reason is actually a "continue instructions"
         blocking_reasons = []
+        contexts = []
 
         compacted_outputs.each do |output|
           output_data = output.respond_to?(:data) ? output.data : output
@@ -71,11 +76,21 @@ module ClaudeHooks
             reason = output_data['reason']
             blocking_reasons << reason if reason && !reason.empty?
           end
+
+          context = output_data.dig('hookSpecificOutput', 'additionalContext')
+          contexts << context if context && !context.empty?
         end
 
         # Combine all blocking reasons / continue instructions
         merged_data['reason'] = blocking_reasons.join('; ') unless blocking_reasons.empty?
 
+        unless contexts.empty?
+          merged_data['hookSpecificOutput'] = {
+            'hookEventName' => merged_data.dig('hookSpecificOutput', 'hookEventName') || 'Stop',
+            'additionalContext' => contexts.join("\n\n")
+          }
+        end
+
         new(merged_data)
       end
     end

data/lib/claude_hooks/output/stop_failure.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module ClaudeHooks
+  module Output
+    # StopFailure is purely a logging event — output/exit is ignored by Claude Code.
+    class StopFailure < 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/subagent_start.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module ClaudeHooks
+  module Output
+    class SubagentStart < Base
+      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
+        contexts = []
+
+        compacted_outputs.each do |output|
+          output_data = output.respond_to?(:data) ? output.data : output
+          context = output_data.dig('hookSpecificOutput', 'additionalContext')
+          contexts << context if context && !context.empty?
+        end
+
+        unless contexts.empty?
+          merged_data['hookSpecificOutput'] = {
+            'hookEventName' => 'SubagentStart',
+            'additionalContext' => contexts.join("\n\n")
+          }
+        end
+
+        new(merged_data)
+      end
+    end
+  end
+end

data/lib/claude_hooks/output/task_completed.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module ClaudeHooks
+  module Output
+    class TaskCompleted < 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/task_created.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module ClaudeHooks
+  module Output
+    class TaskCreated < 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/teammate_idle.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module ClaudeHooks
+  module Output
+    class TeammateIdle < 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/user_prompt_expansion.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module ClaudeHooks
+  module Output
+    class UserPromptExpansion < 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/worktree_create.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module ClaudeHooks
+  module Output
+    # WorktreeCreate has a special bare-stdout contract:
+    # the last non-empty stdout line is interpreted as the worktree path.
+    # An empty/missing path causes Claude Code to treat creation as failed.
+    class WorktreeCreate < Base
+      def worktree_path
+        @data['hookSpecificOutput']&.dig('worktreePath') || @data['_worktree_path']
+      end
+
+      def exit_code
+        worktree_path && !worktree_path.empty? ? 0 : 1
+      end
+
+      def output_stream
+        :stdout
+      end
+
+      # Overrides the default JSON output — prints the bare path instead.
+      def output_and_exit
+        path = worktree_path
+        if path && !path.empty?
+          $stdout.puts path
+          exit 0
+        else
+          exit 1
+        end
+      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 set path wins
+        merged = super(*outputs)
+        merged_data = merged.data
+        last_path = nil
+
+        compacted_outputs.each do |output|
+          output_data = output.respond_to?(:data) ? output.data : output
+          p = output_data.dig('hookSpecificOutput', 'worktreePath') || output_data['_worktree_path']
+          last_path = p if p && !p.empty?
+        end
+
+        if last_path
+          merged_data['hookSpecificOutput'] ||= { 'hookEventName' => 'WorktreeCreate' }
+          merged_data['hookSpecificOutput']['worktreePath'] = last_path
+          merged_data['_worktree_path'] = last_path
+        end
+
+        new(merged_data)
+      end
+    end
+  end
+end

data/lib/claude_hooks/output/worktree_remove.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module ClaudeHooks
+  module Output
+    # WorktreeRemove is non-blocking — only suppressOutput is honored.
+    class WorktreeRemove < Base
+      def exit_code
+        0
+      end
+
+      def self.merge(*outputs)
+        merged = super(*outputs)
+        new(merged.data)
+      end
+    end
+  end
+end

data/lib/claude_hooks/permission_denied.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module ClaudeHooks
+  class PermissionDenied < Base
+    def self.hook_type
+      'PermissionDenied'
+    end
+
+    def self.input_fields
+      %w[tool_name tool_input tool_use_id reason]
+    end
+
+    def tool_name
+      @input_data['tool_name']
+    end
+
+    def tool_input
+      @input_data['tool_input']
+    end
+
+    def tool_use_id
+      @input_data['tool_use_id'] || @input_data['toolUseId']
+    end
+
+    def reason
+      @input_data['reason']
+    end
+
+    def retry!
+      @output_data['hookSpecificOutput'] ||= { 'hookEventName' => hook_event_name }
+      @output_data['hookSpecificOutput']['retry'] = true
+    end
+
+    def no_retry!
+      @output_data['hookSpecificOutput'] ||= { 'hookEventName' => hook_event_name }
+      @output_data['hookSpecificOutput']['retry'] = false
+    end
+  end
+end