samagotchi 0.79.0 → 0.81.0

data/lib/samagotchi/guardrails/data_readers.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  module Guardrails
+    # Which shell commands read their stdin as data and never run it: cat and
+    # tee (to stdout), and a git or gh command taking its message from stdin.
+    # Pure word predicates over one simple command's words (the lexer's
+    # ShellLex). Everything else is an unknown consumer and stays matched.
+    module DataReaders
+      # Commands that print what they read.
+      SINKS = %w[cat tee].freeze
+      # What a heredoc body that a data reader reads becomes (the same value
+      # as ShellLex::HEREDOC).
+      HEREDOC = "\0HEREDOC"
+      # A word that is a redirection (>, >>, 2>&1, <; the same as
+      # ShellLex::REDIRECT).
+      REDIRECT = /\A\d*[<>]/
+      # git's global options that take the next word.
+      GIT_OPTIONS_WITH_VALUE = %w[-C -c --git-dir --work-tree --namespace].freeze
+      # A >& target that names an fd instead of a file: a number or -.
+      FD_TARGET = /\A(\d+|-)\z/
+
+      module_function
+
+      # The command word among a simple command's words: the NAME= words and
+      # the redirections dropped, and with a redirection written with a space
+      # (> /tmp/x) its target word too. nil when there is none.
+      def command_word(words)
+        index = command_index(words)
+        words[index] if index
+      end
+
+      # Where command_word's word is in +words+ (nil when there is none).
+      def command_index(words)
+        i = 0
+        while i < words.size
+          word = words[i]
+          if word.match?(REDIRECT)
+            i += 1 if word.match?(/\A\d*[<>]{1,2}\z/)
+          elsif !word.match?(/\A[A-Za-z_]\w*=/)
+            return i
+          end
+          i += 1
+        end
+        nil
+      end
+
+      # Whether a cat or tee command sends its output to a file (a file
+      # written can be run later): a stdout redirection whose target isn't
+      # /dev/null, a dangling >, or a tee argument that is no option,
+      # redirection, heredoc or /dev/null.
+      def writes_file?(words)
+        return true if stdout_file?(words)
+
+        File.basename(command_word(words).to_s) == "tee" && tee_file?(words)
+      end
+
+      # Whether one of +words+ sends stdout to a file: a >, >>, 1>, 1>>, >& or
+      # 1>& redirection (its target in the word, or in the next word when the
+      # operator ends it) whose target names a file and isn't /dev/null. A dup
+      # to an fd writes no file: >&2, >&-, 2>&1, and a spaced ">& 2" or
+      # ">& -". A >& with any other target does write one: bash reads
+      # ">& file" and ">&file" as "&>file".
+      def stdout_file?(words)
+        words.each_with_index do |word, i|
+          match = word.match(/\A1?(>>?)(&?)(.*)\z/m)
+          next unless match
+
+          amp = match[2]
+          target = match[3]
+          target = words[i + 1] if target.empty? # "> file", ">& 2"
+          return true if target.nil? # a dangling > or >&
+          next if target == "/dev/null"
+          next if !amp.empty? && target.match?(FD_TARGET)
+
+          return true
+        end
+        false
+      end
+
+      # Whether a tee command writes a file of its own (an argument that
+      # isn't an option, a redirection, a heredoc, a body or /dev/null).
+      def tee_file?(words)
+        verb = command_index(words)
+        return false unless verb
+
+        i = verb + 1
+        while i < words.size
+          word = words[i]
+          if word.match?(REDIRECT)
+            i += word.match?(/\A\d*[<>]{1,2}\z/) ? 2 : 1
+            next
+          end
+          return true if filename_word?(word)
+
+          i += 1
+        end
+        false
+      end
+
+      # Whether a tee argument names a file: not an option, a heredoc's tag,
+      # a body word (HEREDOC, SUBST, a script) or /dev/null.
+      def filename_word?(word)
+        !word.start_with?("-", "<<") && !word.include?("\0") && !word.include?("\n") && word != "/dev/null"
+      end
+
+      # Whether a simple command reads its stdin as a text file it never
+      # runs: cat or tee, git commit/tag -F - (--file -), gh pr|issue … -F -
+      # (--body-file -) or gh release … -F - (--notes-file -).
+      def data_reader?(words)
+        args = arguments(words)
+        verb = File.basename(args.first.to_s)
+        return true if SINKS.include?(verb)
+
+        case verb
+        when "git" then git_reader?(args)
+        when "gh" then gh_reader?(args)
+        else false
+        end
+      end
+
+      # Whether word +index+ of a simple command is the value of a message
+      # option of a data reader: git commit/tag -m/--message, gh pr|issue …
+      # -b/--body/-t/--title, gh release … -n/--notes/-t/--title. A
+      # "$(cat <<'EOF' … EOF)" there is a message, not code.
+      def message_arg?(words, index)
+        return false unless index.positive?
+
+        option = words[index - 1]
+        args = arguments(words)
+        case File.basename(args.first.to_s)
+        when "git" then git_message_option?(args, option)
+        when "gh" then gh_message_option?(args, option)
+        else false
+        end
+      end
+
+      # A simple command's arguments: the NAME= words, the redirections (with
+      # their spaced targets), the <<TAG words and the heredoc bodies left
+      # out.
+      def arguments(words)
+        args = []
+        i = 0
+        while i < words.size
+          word = words[i]
+          if word.match?(REDIRECT)
+            i += word.match?(/\A\d*[<>]{1,2}\z/) ? 2 : 1
+            next
+          end
+          args << word unless word.match?(/\A[A-Za-z_]\w*=/) || heredoc_word?(word)
+          i += 1
+        end
+        args
+      end
+
+      # Whether a word is a heredoc's <<TAG or one of its bodies.
+      def heredoc_word?(word)
+        word.match?(REDIRECT) || word.include?("\0") || word.include?("\n")
+      end
+
+      # The words after git's global options ([-C dir …] commit), nil when
+      # they run out.
+      def git_arguments(args)
+        i = 1
+        i += GIT_OPTIONS_WITH_VALUE.include?(args[i]) ? 2 : 1 while i < args.size && args[i].start_with?("-")
+        args[i..]
+      end
+
+      def git_reader?(args)
+        rest = git_arguments(args)
+        return false unless rest
+
+        subcommand, *opts = rest
+        return false unless %w[commit tag].include?(subcommand)
+
+        stdin_file?(opts, "-F", "--file")
+      end
+
+      def gh_reader?(args)
+        case args[1]
+        when "pr", "issue"
+          %w[create comment edit review].include?(args[2]) && stdin_file?(args.drop(3), "-F", "--body-file")
+        when "release"
+          %w[create edit].include?(args[2]) && stdin_file?(args.drop(3), "-F", "--notes-file")
+        else
+          false
+        end
+      end
+
+      # Whether +opts+ take their text from stdin: "-F -", "--file -",
+      # "-F-" or "--file=-".
+      def stdin_file?(opts, short, long)
+        opts.each_cons(2).any? { |a, b| [short, long].include?(a) && b == "-" } ||
+          opts.include?("#{short}-") || opts.include?("#{long}=-")
+      end
+
+      def git_message_option?(args, option)
+        rest = git_arguments(args)
+        rest && %w[commit tag].include?(rest.first) && %w[-m --message].include?(option)
+      end
+
+      def gh_message_option?(args, option)
+        case args[1]
+        when "pr", "issue"
+          %w[create comment edit review].include?(args[2]) && %w[-b --body -t --title].include?(option)
+        when "release"
+          %w[create edit].include?(args[2]) && %w[-n --notes -t --title].include?(option)
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/samagotchi/guardrails/gate.rb

@@ -49,10 +49,14 @@ module Samagotchi
       # @param call [Hash] the parsed tool call
       # @param iteration [Integer]
       # @param params [String] the call's one-line preview
+      # @param verdict [Verdict, nil] the one the voters vote on (the test
+      #   kit's recording one, maybe with a vote already in); default a new
+      #   one for +call+
       # @return [Verdict]
-      def evaluate(call, iteration:, params:)
+      def evaluate(call, iteration:, params:, verdict: nil)
         context = @context_lookup.call
-        verdict = Verdict.new(call: call)
+        verdict ||= Verdict.new(call: call)
+        verdict.call = call
         if @cancelled_lookup.call
           verdict.deny!("the turn was stopped", decided_by: "core")
           verdict.context = context
@@ -60,7 +64,7 @@ module Samagotchi
           return verdict
         end
         before = { type: :before_tool_call, iteration: iteration, call: call.dup, params: params,
-                   blocked: false, block_reason: nil, guardrail: verdict,
+                   blocked: verdict.deny?, block_reason: (verdict.reason if verdict.deny?), guardrail: verdict,
                    context: context.to_h, targets: targets_for(call, context).to_h }
         fire_each(:before_tool_call, before) do |event|
           verdict.legacy_deny!(event[:block_reason]) if event[:blocked]

data/lib/samagotchi/guardrails/rules.rb

@@ -13,7 +13,9 @@ module Samagotchi
     #            a name may be a glob ("mcp_*", "mcp_{git,gh}_*"); it
     #            matches the call's name or the tool a plugin tool's call
     #            acts as (Targets#acts_as: an MCP tool behind call_tool)
-    #   command: a Ruby regex on a shell tool's command
+    #   command: a Ruby regex on a shell tool's command, the body of a
+    #            heredoc its command only reads as data left out
+    #            (Targets#rule_command, ShellLex.code_text)
     #   path:    "outside_repo", or a glob on the resolved paths (absolute
     #            or "**/…" globs match the absolute path; others the path
     #            relative to the repo root, the cwd outside one)
@@ -61,7 +63,7 @@ module Samagotchi
           return false unless targets
           return false unless for_model?(targets.model_name, targets.model_key, -> { targets.small_model? })
           return false if tools && !tool_matches?(targets.tool) && !(targets.acts_as && tool_matches?(targets.acts_as))
-          return false if command && !(targets.command && command.match?(targets.command))
+          return false if command && !(targets.rule_command && command.match?(targets.rule_command))
           return false if path && !path_matches?(targets)
           return false if git && !targets.git_outside_repo?
           return false if touches && !targets.touches_chi?

data/lib/samagotchi/guardrails/shell_lex.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "data_readers"
+
 module Samagotchi
   module Guardrails
     # A small shell lexer for the guardrails' text checks (ShellGitDirs
@@ -8,8 +10,9 @@ module Samagotchi
     # backticks (quoted or not) as one opaque SUBST marker inside a word. A
     # heredoc's body (<<EOF, <<'EOF', <<-EOF) is one word after its <<TAG
     # word and lexing goes on after the terminator line: HEREDOC when cat or
-    # tee read it as data, SUBST when an unquoted tag's body holds $(…) or
-    # backticks, else the body text itself (a script, as sh -c '…' gives).
+    # tee read it as data (when the command ends at a plain separator,
+    # outside any ( or { group), SUBST when an unquoted tag's body holds $(…)
+    # or backticks, else the body text itself (a script, as sh -c '…' gives).
     # An unterminated heredoc is no heredoc: the rest is lexed as commands.
     # It never runs anything, and it does its best on odd input (an
     # unbalanced quote).
@@ -18,12 +21,15 @@ module Samagotchi
       OPERATORS = ["&&", "||", ";;", "|&", ";", "|", "&", "\n", "(", ")"].freeze
       # What a $(…) or `…` becomes inside a word.
       SUBST = "\0SUBST"
-      # What a heredoc body that cat or tee read as data becomes.
-      HEREDOC = "\0HEREDOC"
-      # Commands that read a heredoc as data (when not piped on).
-      DATA_SINKS = %w[cat tee].freeze
+      # What a heredoc body that a data reader reads as data becomes (its
+      # command ends at a plain separator, outside any ( or { group).
+      HEREDOC = DataReaders::HEREDOC
+      # The operators that may follow a data heredoc's command; any other
+      # (|, |&, &, (, ), ;;) may hand its output on, and & also starts
+      # &>file.
+      DATA_ENDS = ["\n", ";", "&&", "||"].freeze
       # A word that is a redirection (>, >>, 2>&1, <).
-      REDIRECT = /\A\d*[<>]/
+      REDIRECT = DataReaders::REDIRECT
 
       # Words and operators ([:word, "x", specials] / [:op, "&&"]). A word's
       # specials are the characters the shell would act on in it, unquoted
@@ -57,6 +63,146 @@ module Samagotchi
         commands.reject { |c| c.is_a?(Array) && c.empty? }
       end
 
+      # Whether an ( or { group is still open at token +at+: a pipe after
+      # the group's ) or } takes what the group prints. The counters never go
+      # below 0 (a case pattern's "x)" closes nothing); ((…)) arithmetic and
+      # <(…) / >(…) count as open parens (the conservative reading).
+      def self.in_group?(tokens, at)
+        parens = 0
+        braces = 0
+        tokens[0...at].each do |kind, value|
+          if kind == :op
+            parens += 1 if value == "("
+            parens -= 1 if value == ")" && parens.positive?
+          elsif value == "{"
+            braces += 1
+          elsif value == "}" && braces.positive?
+            braces -= 1
+          end
+        end
+        parens.positive? || braces.positive?
+      end
+
+      # +text+ as code: the lines of each heredoc body its command only reads
+      # as data (DataReaders) cut out, the <<TAG word and the terminator line
+      # kept as written. This is what a rule's command: reads. A text the
+      # lexer isn't sure of (unterminated) comes back as it was, and so does
+      # one it can't read: the safe default.
+      def self.code_text(text)
+        lexer = Lexer.new(text)
+        tokens = lexer.tokens
+        return text if lexer.unterminated?
+
+        bodies = lexer.heredoc_spans.map { |doc| doc[:span] }
+        cuts = []
+        each_command(tokens) do |indices|
+          words = indices.map { |i| tokens[i][1] }
+          indices.each_with_index do |i, position|
+            kind, value, = tokens[i]
+            next unless kind == :word
+
+            span = lexer.spans[i]
+            cut = if bodies.include?(span)
+                    body_cut(text, span, words) if value == HEREDOC
+                  elsif value == SUBST
+                    substitution_cut(text, tokens, i, span, words, position)
+                  end
+            cuts << cut if cut
+          end
+        end
+        cuts.sort_by { |span, _| -span.begin }.each_with_object(+text) do |(span, replacement), out|
+          out[span] = replacement
+        end
+      rescue ArgumentError, EncodingError
+        text
+      end
+
+      # The token indices of each simple command, its operators left out.
+      def self.each_command(tokens)
+        current = []
+        tokens.each_with_index do |(kind, _value, *_rest), i|
+          if kind == :op
+            yield current unless current.empty?
+            current = []
+          else
+            current << i
+          end
+        end
+        yield current unless current.empty?
+      end
+      private_class_method :each_command
+
+      # [span, what it becomes] for a data heredoc's body at +span+ (its
+      # command's +words+), or nil when the body stays in the code text: a
+      # cat or tee writing a file may be run later (D1).
+      def self.body_cut(text, span, words)
+        return nil unless cut_body?(words)
+
+        [span, terminator_line(text[span])]
+      end
+      private_class_method :body_cut
+
+      # Whether a body a data reader reads leaves the code text: a cat or tee
+      # sending it to a file keeps it (D1); a body any other command reads as
+      # data is one the lexer's data_sink? approved.
+      def self.cut_body?(words)
+        verb = DataReaders.command_word(words)
+        return true unless DataReaders::SINKS.include?(File.basename(verb.to_s))
+
+        !DataReaders.writes_file?(words)
+      end
+      private_class_method :cut_body?
+
+      # [span, what it becomes] for the body of a "$(cat <<'EOF' … EOF)" given
+      # as a message (-m, --body, …) of a data reader (D2), or nil: eval,
+      # bash -c, a command piped on and a body that runs stay.
+      def self.substitution_cut(text, tokens, index, span, words, position)
+        return nil unless data_end?(tokens, index)
+        return nil if in_group?(tokens, index)
+        return nil unless DataReaders.message_arg?(words, position)
+
+        raw = text[span]
+        dollar = raw.start_with?("\"$(") ? 1 : 0
+        return nil unless raw[dollar, 2] == "$("
+
+        inner = raw[(dollar + 2)..]
+        inner_lexer = Lexer.new(inner)
+        first = inner_lexer.tokens.first(5)
+        return nil unless message_heredoc?(first)
+
+        inner_span = inner_lexer.spans[2]
+        return nil unless inner_span
+
+        start = span.begin + dollar + 2
+        cut = ((start + inner_span.begin)...(start + inner_span.end))
+        [cut, terminator_line(text[cut])]
+      end
+      private_class_method :substitution_cut
+
+      # Whether the command holding token +index+ ends at nil or a plain
+      # separator (not piped on: what it prints is not run).
+      def self.data_end?(tokens, index)
+        next_op = (tokens[(index + 1)..] || []).find { |token| token[0] == :op }
+        next_op.nil? || DATA_ENDS.include?(next_op[1])
+      end
+      private_class_method :data_end?
+
+      # Whether the tokens inside a $(…) are cat <<TAG and a data body, and
+      # the substitution closes right after.
+      def self.message_heredoc?(first)
+        first.size == 5 && first[0][0..1] == [:word, "cat"] &&
+          first[1][0] == :word && first[1][1].start_with?("<<") &&
+          first[2][0..1] == [:word, HEREDOC] && first[3] == [:op, "\n"] && first[4] == [:op, ")"]
+      end
+      private_class_method :message_heredoc?
+
+      # +raw+ (a body and its terminator line) as its terminator line alone.
+      def self.terminator_line(raw)
+        line = raw.rindex("\n")
+        line ? raw[(line + 1)..] : raw
+      end
+      private_class_method :terminator_line
+
       # A hand-written shell lexer: quotes, backslashes, comments, $(…) and
       # backticks (an opaque marker inside the word), redirections kept in
       # their word (2>&1 doesn't split on &), operators.
@@ -357,32 +503,24 @@ module Samagotchi
           body
         end
 
-        # Whether the command the heredoc at token +at+ is in is cat or tee
-        # and not piped into another command.
+        # Whether the command the heredoc at token +at+ is in reads it as data
+        # (DataReaders.data_reader?: cat, tee, git commit -F -, gh …), ends at
+        # a plain separator (DATA_ENDS: not piped on, backgrounded or handed to
+        # a process substitution) and sits outside any ( or { group (whose
+        # output a pipe after the group's ) or } would take).
         def data_sink?(at)
           start = at
           start -= 1 while start.positive? && @tokens[start - 1][0] == :word
-          verb = command_word(@tokens[start...at])
-          next_op = @tokens[at..].find { |t| t[0] == :op }
-          DATA_SINKS.include?(File.basename(verb.to_s)) && !["|", "|&"].include?(next_op&.dig(1))
+          following = @tokens[at..] || []
+          next_op = following.index { |t| t[0] == :op }
+          ends = next_op.nil? || DATA_ENDS.include?(following[next_op][1])
+          words = @tokens[start...at].map { |t| t[1] }
+          words += @tokens[at...(next_op ? at + next_op : @tokens.size)].map { |t| t[1] }
+          DataReaders.data_reader?(words) && ends && !in_group?(at)
         end
 
-        # The command word among the words before a heredoc's: the NAME=
-        # words and the redirections dropped, and with a redirection written
-        # with a space (> /tmp/x) its target word too.
-        def command_word(words)
-          i = 0
-          while i < words.size
-            word = words[i][1]
-            if word.match?(REDIRECT)
-              i += 1 if word.match?(/\A\d*[<>]{1,2}\z/)
-            elsif !word.match?(/\A[A-Za-z_]\w*=/)
-              return word
-            end
-            i += 1
-          end
-          nil
-        end
+        # Whether an ( or { group is still open at token +at+.
+        def in_group?(at) = ShellLex.in_group?(@tokens, at)
       end
     end
   end

data/lib/samagotchi/guardrails/targets.rb

@@ -8,6 +8,7 @@ require_relative "../log"
 require_relative "model_size"
 require_relative "outside"
 require_relative "shell_git_dirs"
+require_relative "shell_lex"
 require_relative "read_only_shell"
 require_relative "shell_paths"
 require_relative "rm_targets"
@@ -246,6 +247,19 @@ module Samagotchi
 
       def shell? = SHELL_TOOLS.include?(@tool)
 
+      # What a rule's command: reads: the shell command with the body of each
+      # heredoc its command only reads as data left out (ShellLex.code_text);
+      # a plugin tool's own command as given (its text may not be shell).
+      # Approvals, the approval question and hooks keep #command.
+      def rule_command
+        return @rule_command if defined?(@rule_command)
+
+        @rule_command = if @command.nil? then nil
+                        elsif shell? then ShellLex.code_text(@command)
+                        else @command
+                        end
+      end
+
       # The repository's name: its main checkout's folder (the folder
       # holding the common .git dir; a bare repo's name less .git), else
       # the repo root's folder; nil outside a repo.

data/lib/samagotchi/hooks/bundle_loader.rb

@@ -70,10 +70,7 @@ module Samagotchi
             # A hook with no declared event cannot be auto-registered.
             next if hook.event.empty?
 
-            event_sym = hook.event.to_sym
-            on_error = hook.on_error
-            priority = hook.priority
-            fail_closed = on_error == "fail_closed" && event_sym == :before_tool_call
+            fail_closed = hook.on_error == "fail_closed" && hook.event == "before_tool_call"
             what = "hook #{basename} (bundle #{bundle_name})"
             file = hooks_dir && File.join(hooks_dir, basename)
             unless file && File.exist?(file)
@@ -87,15 +84,7 @@ module Samagotchi
             end
 
             begin
-              plugin = instantiate(bundle_name, basename, file, settings: settings)
-              policy = if fail_closed then :deny
-                       elsif on_error == "log" then :log
-                       else :skip
-                       end
-              label = "#{"guardrail " if fail_closed}#{basename} (bundle #{bundle_name})"
-              handler = Hooks.wrap(label: label, event: event_sym, policy: policy, log: [:hooks, "bundle_hook_failed"],
-                                   fields: { bundle: bundle_name }) { |event| plugin.call(event) }
-              registry.register_bundle(bundle_name, event_sym, hook_name: basename, priority: priority, &handler)
+              load_hook_file(bundle_name, basename, file, hook, registry, settings: settings)
               loaded += 1
             rescue Exception => e # rubocop:disable Lint/RescueException -- a hook's SyntaxError or exit must not stop chi
               raise if e.is_a?(SignalException) # Ctrl-C and kill signals are the user's
@@ -107,6 +96,31 @@ module Samagotchi
           loaded
         end
 
+        # Build one hook file and register it in +registry+ under its
+        # event, priority and error policy (a fail_closed before_tool_call
+        # one denies when it raises). No missing-file, sha or requires_chi
+        # check: #load makes them; the test kit loads a bundle's source
+        # this way.
+        # @param hook [MemoryBundle::BundleHook] its manifest entry
+        # @param namespace [Module, nil] the module the file is evaluated
+        #   in (default: the bundle's, #namespace_for)
+        # @raise [Exception] what loading or building the file raised;
+        #   nothing is registered then
+        def load_hook_file(bundle_name, basename, file, hook, registry, settings: {}, namespace: nil)
+          event_sym = hook.event.to_sym
+          fail_closed = hook.on_error == "fail_closed" && event_sym == :before_tool_call
+          plugin = instantiate(bundle_name, basename, file, settings: settings, namespace: namespace)
+          policy = if fail_closed then :deny
+                   elsif hook.on_error == "log" then :log
+                   else :skip
+                   end
+          label = "#{"guardrail " if fail_closed}#{basename} (bundle #{bundle_name})"
+          handler = Hooks.wrap(label: label, event: event_sym, policy: policy, log: [:hooks, "bundle_hook_failed"],
+                               fields: { bundle: bundle_name }) { |event| plugin.call(event) }
+          registry.register_bundle(bundle_name, event_sym, hook_name: basename, priority: hook.priority, &handler)
+          nil
+        end
+
         # Why the file doesn't match the sha256 recorded at install, or nil.
         # With none recorded, only a required hook counts as a mismatch.
         def sha_mismatch(file, recorded, required:)
@@ -119,12 +133,13 @@ module Samagotchi
           "its sha256 #{actual[0, 12]}… differs from the installed #{expected[0, 12]}… (edited after install? reinstall the bundle)"
         end
 
-        # Evaluate a plugin file inside the bundle's namespace module and
+        # Evaluate a plugin file inside the bundle's namespace module (or
+        # +namespace+) and
         # return an instance that responds to #call. A class whose
         # initialize takes an argument gets the settings (one Hash, string
         # keys); one that takes none is built bare.
-        def instantiate(bundle_name, basename, file, settings: {})
-          ns = namespace_for(bundle_name)
+        def instantiate(bundle_name, basename, file, settings: {}, namespace: nil)
+          ns = namespace || namespace_for(bundle_name)
           content = File.read(file)
           ns.module_eval(content, file, 1)
           klass = Hooks.class_for(basename, ns)