brute 5.1.0 → 6.0.0

data/lib/brute/skill.rb

@@ -34,8 +34,16 @@ module Brute
   # (https://agentskills.io/specification). A skill whose frontmatter violates
   # a rule is skipped with a stderr warning naming the rule — never raised.
   class Skill
-    attr_reader :name, :description, :file_path, :base_dir, :content,
-                :source, :license, :compatibility, :metadata, :allowed_tools
+    attr_reader :name,
+      :description,
+      :file_path,
+      :base_dir,
+      :content,
+      :source,
+      :license,
+      :compatibility,
+      :metadata,
+      :allowed_tools
 
     FILENAME = "SKILL.md"
 
@@ -74,38 +82,42 @@ module Brute
     def self.load(path, source: :path)
       raw = File.read(path)
       frontmatter, content = parse_frontmatter(path, raw)
-      return nil unless frontmatter
-
-      dir_name = File.basename(File.dirname(path))
-      # Spec requires `name`; brute keeps the convenience of defaulting to the
-      # directory name when omitted (which trivially satisfies the dir-match rule).
-      frontmatter = { "name" => dir_name }.merge(frontmatter) unless frontmatter.key?("name")
-
-      # Unknown fields are a soft violation: warn and drop them rather than
-      # reject the skill. The reference validator hard-fails here, but a runtime
-      # loader must tolerate vendor/forward extensions (e.g. `tags`), which real
-      # published skills carry, instead of silently dropping the whole skill.
-      extra = frontmatter.keys - ALLOWED_FIELDS
-      warn "Skill #{path} has unexpected frontmatter fields (ignored): #{extra.sort.join(', ')}" unless extra.empty?
-
-      errors = validate(frontmatter, dir_name)
-      unless errors.empty?
-        warn "Skipping invalid skill #{path}: #{errors.join('; ')}"
-        return nil
-      end
+      if frontmatter
+        dir_name = File.basename(File.dirname(path))
+        # Spec requires `name`; brute keeps the convenience of defaulting to the
+        # directory name when omitted (which trivially satisfies the dir-match rule).
+        unless frontmatter.key?("name")
+          frontmatter = { "name" => dir_name }.merge(frontmatter)
+        end
 
-      new(
-        name: frontmatter["name"].to_s.strip,
-        description: frontmatter["description"].to_s.strip,
-        file_path: path,
-        content: content.to_s.strip,
-        source: source,
-        license: frontmatter["license"]&.to_s,
-        compatibility: frontmatter["compatibility"]&.to_s,
-        metadata: frontmatter["metadata"],
-        allowed_tools: parse_allowed_tools(frontmatter["allowed-tools"]),
-        disable_model_invocation: frontmatter["disable-model-invocation"] == true,
-      )
+        # Unknown fields are a soft violation: warn and drop them rather than
+        # reject the skill. The reference validator hard-fails here, but a runtime
+        # loader must tolerate vendor/forward extensions (e.g. `tags`), which real
+        # published skills carry, instead of silently dropping the whole skill.
+        extra = frontmatter.keys - ALLOWED_FIELDS
+        unless extra.empty?
+          warn "Skill #{path} has unexpected frontmatter fields (ignored): #{extra.sort.join(', ')}"
+        end
+
+        errors = validate(frontmatter, dir_name)
+        if errors.empty?
+          new(
+            name:                     frontmatter["name"].to_s.strip,
+            description:              frontmatter["description"].to_s.strip,
+            file_path:                path,
+            content:                  content.to_s.strip,
+            source:                   source,
+            license:                  frontmatter["license"]&.to_s,
+            compatibility:            frontmatter["compatibility"]&.to_s,
+            metadata:                 frontmatter["metadata"],
+            allowed_tools:            parse_allowed_tools(frontmatter["allowed-tools"]),
+            disable_model_invocation: frontmatter["disable-model-invocation"] == true,
+          )
+        else
+          warn "Skipping invalid skill #{path}: #{errors.join('; ')}"
+          nil
+        end
+      end
     rescue => e
       warn "Failed to load skill #{path}: #{e.message}"
       nil
@@ -122,25 +134,28 @@ module Brute
 
       add = lambda do |path, source|
         skill = load(path, source: source)
-        return unless skill
-
-        real = realpath(path)
-        return if seen_files[real]
-
-        if (winner = skills[skill.name])
-          warn "Skill name collision: '#{skill.name}' at #{path} ignored; " \
-               "already loaded from #{winner.file_path}"
-          return
+        real  = skill && realpath(path)
+
+        if skill && !seen_files[real]
+          if (winner = skills[skill.name])
+            warn "Skill name collision: '#{skill.name}' at #{path} ignored; " \
+                 "already loaded from #{winner.file_path}"
+          else
+            seen_files[real] = true
+            skills[skill.name] = skill
+          end
         end
-
-        seen_files[real] = true
-        skills[skill.name] = skill
       end
 
       project = File.join(cwd, ".brute", "skills")
       glob(project) { |path| add.call(path, :project) }
 
-      global = File.join(Dir.home, ".config", "brute", "skills")
+      global = File.join(
+        Dir.home,
+        ".config",
+        "brute",
+        "skills",
+      )
       glob(global) { |path| add.call(path, :user) }
 
       paths.each do |raw|
@@ -163,9 +178,11 @@ module Brute
     end
 
     def self.glob(dir, &block)
-      return unless File.directory?(dir)
-
-      Dir.glob(File.join(dir, "**", FILENAME)).sort.each(&block)
+      if File.directory?(dir)
+        Dir.glob(File.join(dir, "**", FILENAME)).sort.each(&block)
+      else
+        nil
+      end
     end
 
     def self.realpath(path)
@@ -177,70 +194,100 @@ module Brute
     # Validate frontmatter against the spec. Returns an array of error strings
     # (empty means valid), each naming the violated rule.
     def self.validate(frontmatter, dir_name)
-      errors = []
-
-      errors.concat(validate_name(frontmatter["name"], dir_name))
-      errors.concat(validate_description(frontmatter["description"]))
-
-      if frontmatter.key?("compatibility")
-        compatibility = frontmatter["compatibility"]
-        if !compatibility.is_a?(String)
-          errors << "'compatibility' must be a string"
-        elsif compatibility.length > MAX_COMPATIBILITY_LENGTH
-          errors << "'compatibility' exceeds #{MAX_COMPATIBILITY_LENGTH} characters"
+      [].tap do |errors|
+        errors.concat(validate_name(frontmatter["name"], dir_name))
+        errors.concat(validate_description(frontmatter["description"]))
+
+        if frontmatter.key?("compatibility")
+          compatibility = frontmatter["compatibility"]
+          if !compatibility.is_a?(String)
+            errors << "'compatibility' must be a string"
+          elsif compatibility.length > MAX_COMPATIBILITY_LENGTH
+            errors << "'compatibility' exceeds #{MAX_COMPATIBILITY_LENGTH} characters"
+          end
         end
       end
-
-      errors
     end
 
     def self.validate_name(name, dir_name)
-      return ["missing required field 'name'"] unless name.is_a?(String) && !name.strip.empty?
-
-      name = name.strip.unicode_normalize(:nfkc)
-      errors = []
-      errors << "'name' exceeds #{MAX_NAME_LENGTH} characters" if name.length > MAX_NAME_LENGTH
-      errors << "'name' must be lowercase" if name != name.downcase
-      errors << "'name' cannot start or end with a hyphen" if name.start_with?("-") || name.end_with?("-")
-      errors << "'name' cannot contain consecutive hyphens" if name.include?("--")
-      errors << "'name' may only contain letters, digits, and hyphens" unless name.match?(/\A[\p{Alnum}\-]+\z/)
-      errors << "directory name '#{dir_name}' must match skill name '#{name}'" if dir_name.unicode_normalize(:nfkc) != name
-      errors
+      if name.is_a?(String) && !name.strip.empty?
+        name = name.strip.unicode_normalize(:nfkc)
+        errors = []
+        if name.length > MAX_NAME_LENGTH
+          errors << "'name' exceeds #{MAX_NAME_LENGTH} characters"
+        end
+        if name != name.downcase
+          errors << "'name' must be lowercase"
+        end
+        if name.start_with?("-") || name.end_with?("-")
+          errors << "'name' cannot start or end with a hyphen"
+        end
+        if name.include?("--")
+          errors << "'name' cannot contain consecutive hyphens"
+        end
+        unless name.match?(/\A[\p{Alnum}\-]+\z/)
+          errors << "'name' may only contain letters, digits, and hyphens"
+        end
+        if dir_name.unicode_normalize(:nfkc) != name
+          errors << "directory name '#{dir_name}' must match skill name '#{name}'"
+        end
+        errors
+      else
+        ["missing required field 'name'"]
+      end
     end
 
     def self.validate_description(description)
-      return ["missing required field 'description'"] unless description.is_a?(String) && !description.strip.empty?
-      return ["'description' exceeds #{MAX_DESCRIPTION_LENGTH} characters"] if description.length > MAX_DESCRIPTION_LENGTH
-
-      []
+      if description.is_a?(String) && !description.strip.empty?
+        if description.length > MAX_DESCRIPTION_LENGTH
+          ["'description' exceeds #{MAX_DESCRIPTION_LENGTH} characters"]
+        else
+          []
+        end
+      else
+        ["missing required field 'description'"]
+      end
     end
 
     # `allowed-tools` is an experimental, space-separated list of tool names.
     def self.parse_allowed_tools(value)
-      return nil if value.nil?
-
-      value.to_s.split(/\s+/).reject(&:empty?)
+      if value.nil?
+        nil
+      else
+        value.to_s.split(/\s+/).reject(&:empty?)
+      end
     end
 
     # Split YAML frontmatter from markdown body.
     # Returns [hash, string] or [nil, nil].
     def self.parse_frontmatter(path, raw)
-      return [nil, nil] unless raw.start_with?("---")
-
-      parts = raw.split(/^---\s*$/, 3)
-      return [nil, nil] if parts.length < 3
+      parts = nil
+      if raw.start_with?("---")
+        parts = raw.split(/^---\s*$/, 3)
+      end
 
-      frontmatter = YAML.safe_load(parts[1])
-      return [nil, nil] unless frontmatter.is_a?(Hash)
+      frontmatter = nil
+      if parts && parts.length >= 3
+        frontmatter = YAML.safe_load(parts[1])
+      end
 
-      [frontmatter, parts[2]]
+      if frontmatter.is_a?(Hash)
+        [frontmatter, parts[2]]
+      else
+        [nil, nil]
+      end
     rescue => e
       warn "Failed to parse frontmatter in #{path}: #{e.message}"
       [nil, nil]
     end
 
-    private_class_method :glob, :realpath, :validate, :validate_name,
-                         :validate_description, :parse_allowed_tools, :parse_frontmatter
+    private_class_method :glob,
+      :realpath,
+      :validate,
+      :validate_name,
+      :validate_description,
+      :parse_allowed_tools,
+      :parse_frontmatter
   end
 end
 

data/lib/brute/system_prompt.rb

@@ -34,11 +34,11 @@ module Brute
         # upstream model family from the model name so we use the most
         # appropriate prompt stack (e.g., anthropic stack for claude-*).
         provider = ctx[:provider_name].to_s
-        stack_key = if provider.start_with?("opencode")
-                      infer_stack_from_model(ctx[:model_name].to_s)
-                    else
-                      provider
-                    end
+        if provider.start_with?("opencode")
+          stack_key = infer_stack_from_model(ctx[:model_name].to_s)
+        else
+          stack_key = provider
+        end
         STACKS.fetch(stack_key, STACKS["default"]).each do |mod|
           prompt << mod.call(ctx)
         end
@@ -78,7 +78,7 @@ module Brute
       ],
 
       # GPT-4 / o1 / o3 — pragmatic engineer persona, editing focus, autonomy
-      "openai" => [
+      "openai"    => [
         Prompts::Identity,
         Prompts::EditingApproach,
         Prompts::Autonomy,
@@ -94,7 +94,7 @@ module Brute
       ],
 
       # Gemini — formal/structured, explicit workflows, security focus
-      "google" => [
+      "google"    => [
         Prompts::Identity,
         Prompts::Conventions,
         Prompts::DoingTasks,
@@ -109,7 +109,7 @@ module Brute
       ],
 
       # Ollama — lean stack for local models with smaller context windows
-      "ollama" => [
+      "ollama"    => [
         Prompts::Identity,
         Prompts::ToneAndStyle,
         Prompts::Conventions,
@@ -121,7 +121,7 @@ module Brute
       ],
 
       # Fallback — conservative, concise, fewer than 4 lines
-      "default" => [
+      "default"   => [
         Prompts::Identity,
         Prompts::ToneAndStyle,
         Prompts::Proactiveness,

data/lib/brute/token_counter.rb

@@ -37,7 +37,9 @@ module Brute
     # the schemas, which are already inside it. Anything else double counts.
     def self.estimate(env, counter: nil, tools: nil)
       counter ||= env[:token_counter] || default
-      tools = env[:tools] if tools.nil?
+      if tools.nil?
+        tools = env[:tools]
+      end
       messages = env[:messages] || []
       reported = env.dig(:metadata, :last_llm_usage)&.total.to_i
       answered = messages.rindex { |message| message.role == :assistant }

data/lib/brute/tool.rb

@@ -30,9 +30,11 @@ module Brute
   class Tool
     class << self
       def description(text = nil)
-        return @description unless text
-
-        @description = text
+        if text
+          @description = text
+        else
+          @description
+        end
       end
 
       # Declare one parameter: param :key, type:, desc:, required:
@@ -46,9 +48,11 @@ module Brute
 
       # Raw JSON-schema override for complex argument shapes.
       def params(schema = nil)
-        return @params_schema unless schema
-
-        @params_schema = schema.deep_symbolize_keys
+        if schema
+          @params_schema = schema.deep_symbolize_keys
+        else
+          @params_schema
+        end
       end
     end
 

data/lib/brute/tools/adapter.rb

@@ -39,29 +39,32 @@ module Brute
 
       # Wrap a single tool of any supported shape. Idempotent.
       def self.wrap(tool)
-        return tool if tool.is_a?(Adapter)
-
-        tool = tool.new if tool.is_a?(Class)
-
-        case tool
-        when Hash                then from_hash(tool)
-        when ::Brute::Tool       then from_brute_tool(tool)
-        when Brute::Tools::SubAgent then new(
-          name:        tool.name,
-          description: tool.description,
-          params:      tool.params,
-          handler:     ->(**args) { tool.execute(args) },
-          original:    tool,
-        )
-        when Brute::Turn::ToolPipeline then new(
-          name:        tool.name,
-          description: tool.description,
-          params:      tool.params,
-          handler:     ->(**args) { tool.call(**args) },
-          original:    tool,
-        )
+        if tool.is_a?(Adapter)
+          tool
         else
-          from_duck_type(tool)
+          if tool.is_a?(Class)
+            tool = tool.new
+          end
+          case tool
+          when Hash                then from_hash(tool)
+          when ::Brute::Tool       then from_brute_tool(tool)
+          when Brute::Tools::SubAgent then new(
+            name:        tool.name,
+            description: tool.description,
+            params:      tool.params,
+            handler:     ->(**args) { tool.execute(args) },
+            original:    tool,
+          )
+          when Brute::Turn::ToolPipeline then new(
+            name:        tool.name,
+            description: tool.description,
+            params:      tool.params,
+            handler:     ->(**args) { tool.call(**args) },
+            original:    tool,
+          )
+          else
+            from_duck_type(tool)
+          end
         end
       end
 
@@ -78,7 +81,9 @@ module Brute
       def self.from_hash(definition)
         definition = definition.transform_keys(&:to_sym)
         handler = definition.fetch(:execute) { definition[:handler] }
-        raise ArgumentError, "inline tool needs an :execute proc" unless handler.respond_to?(:call)
+        unless handler.respond_to?(:call)
+          raise ArgumentError, "inline tool needs an :execute proc"
+        end
 
         new(
           name:        definition.fetch(:name).to_s,
@@ -108,7 +113,11 @@ module Brute
           raise ArgumentError, "don't know how to adapt #{tool.inspect} into a tool"
         end
 
-        entry = tool.respond_to?(:execute) ? tool.method(:execute) : tool.method(:call)
+        if tool.respond_to?(:execute)
+          entry = tool.method(:execute)
+        else
+          entry = tool.method(:call)
+        end
         new(
           name:        tool.name.to_s,
           description: tool.respond_to?(:description) ? tool.description : "",
@@ -141,27 +150,28 @@ module Brute
       # Library-neutral tool definition (JSON-Schema-ish). The inline `run`
       # proc reshapes this into whatever its LLM library expects.
       def to_h
-        return { name: @name, description: @description, parameters: @schema.deep_symbolize_keys } if @schema
-
-        properties = @params.transform_values do |opts|
+        if @schema
+          { name: @name, description: @description, parameters: @schema.deep_symbolize_keys }
+        else
+          properties = @params.transform_values do |opts|
+            {
+              type:        opts[:type] || "string",
+              description: opts[:desc] || opts[:description],
+              items:       opts[:items],
+              enum:        opts[:enum],
+            }.compact
+          end
+          required = @params.select { |_k, opts| opts[:required] }.keys
           {
-            type:        opts[:type] || "string",
-            description: opts[:desc] || opts[:description],
-            items:       opts[:items],
-            enum:        opts[:enum],
-          }.compact
+            name:        @name,
+            description: @description,
+            parameters:  {
+              type:       "object",
+              properties: properties,
+              required:   required.map(&:to_s),
+            },
+          }
         end
-        required = @params.select { |_k, opts| opts[:required] }.keys
-
-        {
-          name:        @name,
-          description: @description,
-          parameters: {
-            type:       "object",
-            properties: properties,
-            required:   required.map(&:to_s),
-          },
-        }
       end
     end
   end

data/lib/brute/tools/fs/snapshot_store.rb

@@ -19,7 +19,11 @@ module Brute
           # If the file doesn't exist yet, records +:did_not_exist+.
           def save(path)
             key = File.expand_path(path)
-            content = File.exist?(key) ? File.read(key) : :did_not_exist
+            if File.exist?(key)
+              content = File.read(key)
+            else
+              content = :did_not_exist
+            end
             @mutex.synchronize { @snapshots[key].push(content) }
           end
 

data/lib/brute/tools/fs_patch.rb

@@ -20,22 +20,30 @@ module Brute
       def execute(file_path:, old_string:, new_string:, replace_all: false)
         path = File.expand_path(file_path)
         Brute::Tools::FS::FileMutationQueue.serialize(path) do
-          raise "File not found: #{path}" unless File.exist?(path)
+          unless File.exist?(path)
+            raise "File not found: #{path}"
+          end
 
           original = File.read(path)
-          raise "old_string not found in #{path}" unless original.include?(old_string)
+          unless original.include?(old_string)
+            raise "old_string not found in #{path}"
+          end
 
           Brute::Tools::FS::SnapshotStore.save(path)
 
-          updated = if replace_all
-                      original.gsub(old_string, new_string)
-                    else
-                      original.sub(old_string, new_string)
-                    end
+          if replace_all
+            updated = original.gsub(old_string, new_string)
+          else
+            updated = original.sub(old_string, new_string)
+          end
 
           File.write(path, updated)
           diff = Brute::Diff.unified(original, updated)
-          count = replace_all ? original.scan(old_string).size : 1
+          if replace_all
+            count = original.scan(old_string).size
+          else
+            count = 1
+          end
           { success: true, file_path: path, replacements: count, diff: diff }
         end
       end