octo-agent 0.11.2

data/lib/octo/tools/glob.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Octo
+  module Tools
+    class Glob < Base
+      # Maximum file size to search (1MB)
+      MAX_FILE_SIZE = 1_048_576
+
+      self.tool_name = "glob"
+      self.tool_description = "Find files matching a glob pattern (e.g., '**/*.rb', 'src/**/*.js'). " \
+                              "Returns file paths sorted by modification time. Respects .gitignore patterns."
+      self.tool_category = "file_system"
+      self.tool_parameters = {
+        type: "object",
+        properties: {
+          pattern: {
+            type: "string",
+            description: "The glob pattern to match files (e.g., '**/*.rb', 'lib/**/*.rb', '*.txt')"
+          },
+          base_path: {
+            type: "string",
+            description: "The base directory to search in (defaults to current directory)",
+            default: "."
+          },
+          limit: {
+            type: "integer",
+            description: "Maximum number of results to return (default: 10)",
+            default: 10
+          }
+        },
+        required: %w[pattern]
+      }
+
+      def execute(pattern:, base_path: ".", limit: 10, working_dir: nil)
+        # Validate pattern
+        if pattern.nil? || pattern.strip.empty?
+          return { error: "Pattern cannot be empty" }
+        end
+
+        # Expand ~ in pattern only (pattern is relative to base_path, not working_dir)
+        pattern = pattern.start_with?("~") ? File.expand_path(pattern) : pattern
+        # Expand base_path fully (~ and relative paths resolved against working_dir)
+        base_path = expand_path(base_path, working_dir: working_dir)
+
+        # Validate base_path
+        unless Dir.exist?(base_path)
+          return { error: "Base path does not exist: #{base_path}" }
+        end
+
+        begin
+          expanded_path = base_path
+
+          skipped = {
+            binary: 0,
+            too_large: 0,
+            ignored: 0
+          }
+
+          # Auto-expand bare patterns (no slash, no **) to recursive search.
+          effective_pattern = if !File.absolute_path?(pattern) &&
+                                  !pattern.include?("/") &&
+                                  !pattern.start_with?("**")
+                                "**/#{pattern}"
+                              else
+                                pattern
+                              end
+
+          fnmatch_flags = File::FNM_PATHNAME | File::FNM_DOTMATCH
+
+          matches = []
+          Octo::Utils::FileIgnoreHelper.walk_files(expanded_path, skipped: skipped) do |file|
+            relative = file[(expanded_path.length + 1)..]
+
+            unless File.fnmatch(effective_pattern, relative, fnmatch_flags)
+              next
+            end
+
+            if Octo::Utils::FileProcessor.binary_file_path?(file) &&
+               !Octo::Utils::FileProcessor.glob_allowed_binary?(file)
+              skipped[:binary] += 1
+              next
+            end
+
+            if File.size(file) > MAX_FILE_SIZE
+              skipped[:too_large] += 1
+              next
+            end
+
+            matches << file
+          end
+
+          # Sort by modification time (most recent first)
+          matches = matches.sort_by { |path| -File.mtime(path).to_i }
+
+          # Apply limit
+          total_matches = matches.length
+          matches = matches.take(limit)
+
+          # Convert to absolute paths
+          matches = matches.map { |path| File.expand_path(path) }
+
+          {
+            matches: matches,
+            total_matches: total_matches,
+            returned: matches.length,
+            truncated: total_matches > limit,
+            skipped_files: skipped,
+            error: nil
+          }
+        rescue StandardError => e
+          { error: "Failed to glob files: #{e.message}" }
+        end
+      end
+
+      def format_call(args)
+        pattern = args[:pattern] || args['pattern'] || ''
+        base_path = args[:base_path] || args['base_path'] || '.'
+        
+        display_base = base_path == '.' ? '' : " in #{base_path}"
+        "glob(\"#{pattern}\"#{display_base})"
+      end
+
+      def format_result(result)
+        if result[:error]
+          "[Error] #{result[:error]}"
+        else
+          count = result[:returned] || 0
+          total = result[:total_matches] || 0
+          truncated = result[:truncated] ? " (truncated)" : ""
+          
+          msg = "[OK] Found #{count}/#{total} files#{truncated}"
+          
+          # Add skipped files info if present
+          if result[:skipped_files]
+            skipped = result[:skipped_files]
+            skipped_parts = []
+            skipped_parts << "#{skipped[:ignored]} ignored" if skipped[:ignored] > 0
+            skipped_parts << "#{skipped[:binary]} binary" if skipped[:binary] > 0
+            skipped_parts << "#{skipped[:too_large]} too large" if skipped[:too_large] > 0
+            
+            msg += " (skipped: #{skipped_parts.join(', ')})" unless skipped_parts.empty?
+          end
+          
+          msg
+        end
+      end
+
+      def format_result_for_ui(result)
+        return nil if result[:error]
+        {
+          type: "file_list",
+          path: result[:base_path] || ".",
+          entries: (result[:matches] || []).map { |p| { name: File.basename(p), is_dir: false } },
+          total: result[:total_matches] || 0,
+          truncated: result[:truncated] || false
+        }
+      end
+    end
+  end
+end

data/lib/octo/tools/grep.rb

@@ -0,0 +1,356 @@
+# frozen_string_literal: true
+
+module Octo
+  module Tools
+    class Grep < Base
+      # Maximum file size to search (1MB)
+      MAX_FILE_SIZE = 1_048_576
+
+      # Maximum line length to display (to avoid huge outputs)
+      MAX_LINE_LENGTH = 500
+
+      self.tool_name = "grep"
+      self.tool_description = "Search file contents using regular expressions. Returns matching lines with context."
+      self.tool_category = "file_system"
+      self.tool_parameters = {
+        type: "object",
+        properties: {
+          pattern: {
+            type: "string",
+            description: "The regular expression pattern to search for"
+          },
+          path: {
+            type: "string",
+            description: "File or directory to search in (defaults to current directory)",
+            default: "."
+          },
+          file_pattern: {
+            type: "string",
+            description: "Glob pattern to filter files (e.g., '*.rb', '**/*.js')",
+            default: "**/*"
+          },
+          case_insensitive: {
+            type: "boolean",
+            description: "Perform case-insensitive search",
+            default: false
+          },
+          context_lines: {
+            type: "integer",
+            description: "Number of context lines to show before and after each match (max: 10)",
+            default: 0
+          },
+          max_files: {
+            type: "integer",
+            description: "Maximum number of matching files to return",
+            default: 50
+          },
+          max_matches_per_file: {
+            type: "integer",
+            description: "Maximum number of matches to return per file",
+            default: 50
+          },
+          max_total_matches: {
+            type: "integer",
+            description: "Maximum total number of matches to return across all files",
+            default: 200
+          },
+          max_file_size: {
+            type: "integer",
+            description: "Maximum file size in bytes to search (default: 1MB)",
+            default: MAX_FILE_SIZE
+          },
+        },
+        required: %w[pattern]
+      }
+
+      def execute(
+        pattern:,
+        path: ".",
+        file_pattern: "**/*",
+        case_insensitive: false,
+        context_lines: 0,
+        max_files: 50,
+        max_matches_per_file: 50,
+        max_total_matches: 200,
+        max_file_size: MAX_FILE_SIZE,
+        max_files_to_search: 10000,
+        working_dir: nil
+      )
+        # Validate pattern
+        if pattern.nil? || pattern.strip.empty?
+          return { error: "Pattern cannot be empty" }
+        end
+
+        # Validate and expand path relative to working_dir when provided
+        begin
+          expanded_path = expand_path(path, working_dir: working_dir)
+        rescue StandardError => e
+          return { error: "Invalid path: #{e.message}" }
+        end
+
+        unless File.exist?(expanded_path)
+          return { error: "Path does not exist: #{path}" }
+        end
+
+        # Limit context_lines
+        context_lines = [[context_lines, 0].max, 10].min
+
+        begin
+          # Compile regex
+          regex_options = case_insensitive ? Regexp::IGNORECASE : 0
+          regex = Regexp.new(pattern, regex_options)
+
+          results = []
+          total_matches = 0
+          files_searched = 0
+          skipped = {
+            binary: 0,
+            too_large: 0,
+            ignored: 0
+          }
+          truncation_reason = nil
+
+          files = if File.file?(expanded_path)
+                    [expanded_path]
+                  else
+                    fnmatch_flags = File::FNM_PATHNAME | File::FNM_DOTMATCH
+                    collected = []
+                    Octo::Utils::FileIgnoreHelper.walk_files(expanded_path, skipped: skipped) do |f|
+                      relative = f[(expanded_path.length + 1)..]
+                      collected << f if File.fnmatch(file_pattern, relative, fnmatch_flags)
+                    end
+                    collected
+                  end
+
+          files.each do |file|
+            if files_searched >= max_files_to_search
+              truncation_reason ||= "max_files_to_search limit reached"
+              break
+            end
+
+            # Skip binary files
+            if Octo::Utils::FileProcessor.binary_file_path?(file)
+              skipped[:binary] += 1
+              next
+            end
+
+            # Skip files that are too large
+            if File.size(file) > max_file_size
+              skipped[:too_large] += 1
+              next
+            end
+
+            files_searched += 1
+
+            # Check if we've found enough matching files
+            if results.length >= max_files
+              truncation_reason ||= "max_files limit reached"
+              break
+            end
+
+            # Check if we've found enough total matches
+            if total_matches >= max_total_matches
+              truncation_reason ||= "max_total_matches limit reached"
+              break
+            end
+
+            # Search the file
+            matches = search_file(file, regex, context_lines, max_matches_per_file)
+            next if matches.empty?
+
+            # Add remaining matches respecting max_total_matches
+            remaining_matches = max_total_matches - total_matches
+            matches = matches.take(remaining_matches) if remaining_matches < matches.length
+
+            results << {
+              file: File.expand_path(file),
+              matches: matches
+            }
+            total_matches += matches.length
+          end
+
+          {
+            results: results,
+            total_matches: total_matches,
+            files_searched: files_searched,
+            files_with_matches: results.length,
+            skipped_files: skipped,
+            truncated: !truncation_reason.nil?,
+            truncation_reason: truncation_reason,
+            error: nil
+          }
+        rescue RegexpError => e
+          { error: "Invalid regex pattern: #{e.message}" }
+        rescue StandardError => e
+          { error: "Failed to search files: #{e.message}" }
+        end
+      end
+
+      def format_call(args)
+        pattern = args[:pattern] || args['pattern'] || ''
+        path = args[:path] || args['path'] || '.'
+
+        # Truncate pattern if too long
+        display_pattern = pattern.length > 30 ? "#{pattern[0..27]}..." : pattern
+        display_path = path == '.' ? 'current dir' : (path.length > 20 ? "...#{path[-17..]}" : path)
+
+        "grep(\"#{display_pattern}\" in #{display_path})"
+      end
+
+      def format_result(result)
+        if result[:error]
+          "[Error] #{result[:error]}"
+        else
+          matches = result[:total_matches] || 0
+          files = result[:files_with_matches] || 0
+          msg = "[OK] Found #{matches} matches in #{files} files"
+
+          # Add truncation info if present
+          if result[:truncated] && result[:truncation_reason]
+            msg += " (truncated: #{result[:truncation_reason]})"
+          end
+
+          msg
+        end
+      end
+
+      def format_result_for_ui(result)
+        return nil if result[:error]
+
+        matches = result[:results]&.flat_map do |r|
+          r[:matches]&.map do |m|
+            {
+              file: r[:file],
+              line_no: m[:line_number],
+              line: m[:line],
+              context: m[:context]
+            }
+          end
+        end&.compact || []
+
+        {
+          type: "search",
+          pattern: result[:pattern],
+          path: result[:path],
+          matches: matches.first(20),
+          total_matches: result[:total_matches],
+          files_with_matches: result[:files_with_matches],
+          truncated: result[:truncated],
+          truncation_reason: result[:truncation_reason]
+        }
+      end
+
+      # Format result for LLM consumption - return a compact version to save tokens
+      def format_result_for_llm(result)
+        # If there's an error, return it as-is
+        return result if result[:error]
+
+        # Build a compact summary with file list and sample matches
+        compact = {
+          summary: {
+            total_matches: result[:total_matches],
+            files_with_matches: result[:files_with_matches],
+            files_searched: result[:files_searched],
+            truncated: result[:truncated],
+            truncation_reason: result[:truncation_reason]
+          }
+        }
+
+        # Include list of files with match counts
+        if result[:results] && !result[:results].empty?
+          compact[:files] = result[:results].map do |file_result|
+            {
+              file: file_result[:file],
+              match_count: file_result[:matches].length
+            }
+          end
+
+          # Include sample matches (first 2 matches from first 3 files) for context
+          sample_results = result[:results].take(3)
+          compact[:sample_matches] = sample_results.map do |file_result|
+            {
+              file: file_result[:file],
+              matches: file_result[:matches].take(2).map do |match|
+                {
+                  line_number: match[:line_number],
+                  line: match[:line]
+                  # Omit context to save space - it's rarely needed by LLM
+                }
+              end
+            }
+          end
+        end
+
+        compact
+      end
+
+
+      def search_file(file, regex, context_lines, max_matches)
+        matches = []
+
+        # Use File.foreach for memory-efficient line-by-line reading.
+        # Scrub invalid UTF-8 bytes so results survive JSON encoding.
+        File.foreach(file, chomp: true).with_index do |raw_line, index|
+          line = safe_utf8(raw_line)
+          # Stop if we have enough matches for this file
+          break if matches.length >= max_matches
+
+          next unless line.match?(regex)
+
+          # Truncate long lines
+          display_line = line.length > MAX_LINE_LENGTH ? "#{line[0...MAX_LINE_LENGTH]}..." : line
+
+          # Get context if requested
+          if context_lines > 0
+            context = get_line_context(file, index, context_lines)
+          else
+            context = nil
+          end
+
+          matches << {
+            line_number: index + 1,
+            line: display_line,
+            context: context
+          }
+        end
+
+        matches
+      rescue StandardError
+        []
+      end
+
+      # Get context lines around a match
+      def get_line_context(file, match_index, context_lines)
+        lines = File.readlines(file, chomp: true).map! { |l| safe_utf8(l) }
+        start_line = [0, match_index - context_lines].max
+        end_line = [lines.length - 1, match_index + context_lines].min
+
+        context = []
+        (start_line..end_line).each do |i|
+          line_content = lines[i]
+          # Truncate long lines in context too
+          display_content = line_content.length > MAX_LINE_LENGTH ?
+                          "#{line_content[0...MAX_LINE_LENGTH]}..." :
+                          line_content
+
+          context << {
+            line_number: i + 1,
+            content: display_content,
+            is_match: i == match_index
+          }
+        end
+
+        context
+      rescue StandardError
+        nil
+      end
+
+      # Scrub invalid UTF-8 byte sequences (see file_reader.rb for rationale).
+      private def safe_utf8(str)
+        return str if str.nil?
+        return str if str.encoding == Encoding::UTF_8 && str.valid_encoding?
+        str.encode("UTF-8", invalid: :replace, undef: :replace, replace: "\u{FFFD}")
+      end
+    end
+  end
+end

data/lib/octo/tools/invoke_skill.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Octo
+  module Tools
+    # Tool for invoking skills within the agent
+    # This allows the AI to call skills as tools rather than requiring explicit user commands
+    class InvokeSkill < Base
+      self.tool_name = "invoke_skill"
+      self.tool_description = "Invoke a specialized skill to handle specific tasks. Use this when user's request matches a skill's description (e.g., code exploration, document creation, etc.). This will read the skill's instructions and execute them appropriately (either inline or in a subagent)."
+      self.tool_category = "skill_management"
+      self.tool_parameters = {
+        type: "object",
+        properties: {
+          skill_name: {
+            type: "string",
+            description: "Name of the skill to invoke (e.g., 'code-explorer', 'pptx', 'pdf')"
+          },
+          task: {
+            type: "string",
+            description: "The task or query to pass to the skill"
+          }
+        },
+        required: ["skill_name", "task"]
+      }
+
+      # Execute the skill invocation
+      # @param skill_name [String] Name of the skill to invoke
+      # @param task [String] Task description to pass to the skill
+      # @param agent [Octo::Agent] Agent instance (injected)
+      # @param skill_loader [Octo::SkillLoader] Skill loader instance (injected)
+      # @return [Hash] Result of skill execution
+      def execute(skill_name:, task:, agent: nil, skill_loader: nil, working_dir: nil)
+        # Validate injected dependencies
+        return { error: "Agent context is required" } unless agent
+        return { error: "Skill loader is required" } unless skill_loader
+
+        # Find skill by name
+        skill = skill_loader.find_by_name(skill_name)
+        return { error: "Skill not found: #{skill_name}" } unless skill
+
+        # Execute skill based on its configuration.
+        # Note: disable-model-invocation only prevents the skill from appearing in AVAILABLE SKILLS
+        # (so the model won't auto-discover it). It does NOT block execution here — the user may
+        # have triggered this skill explicitly via a slash command (/skill-name).
+        if skill.fork_agent?
+          # Execute in isolated subagent
+          result = agent.send(:execute_skill_with_subagent, skill, task)
+          {
+            message: "Skill '#{skill_name}' executed in subagent",
+            result: result,
+            skill_type: "subagent"
+          }
+        else
+          # Deferred injection path: enqueue the skill inject on the agent.
+          #
+          # Injecting inside execute() would produce an illegal message ordering for Bedrock:
+          #   assistant: {toolUse: invoke_skill}
+          #   assistant: {text: skill_instructions}   ← injected here (breaks pairing)
+          #   user:      {toolResult: invoke_skill}   ← observe() appends this too late
+          #
+          # Instead, enqueue the injection so the agent loop can flush it AFTER observe()
+          # appends the toolResult, producing the correct sequence:
+          #   assistant: {toolUse: invoke_skill}
+          #   user:      {toolResult: ...}            ← observe() appends first
+          #   assistant: {text: skill_instructions}   ← flush_pending_injections runs here
+          #   user:      "[SYSTEM] please proceed"
+          agent.enqueue_injection(skill, task)
+          "Skill '#{skill_name}' instructions expanded. Proceed to execute the task."
+        end
+      end
+
+      # Format the tool call for display
+      # @param args [Hash] Tool arguments
+      # @return [String] Formatted call description
+      def format_call(args)
+        skill = args[:skill_name] || args["skill_name"]
+        "InvokeSkill(#{skill})"
+      end
+
+      # Format the tool result for display
+      # @param result [Hash] Tool execution result
+      # @return [String] Formatted result summary
+      def format_result(result)
+        if result.is_a?(String)
+          result
+        elsif result[:error]
+          "Error: #{result[:error]}"
+        elsif result[:skill_type] == "subagent"
+          "Subagent executed successfully"
+        else
+          "Skill content expanded"
+        end
+      end
+    end
+  end
+end

data/lib/octo/tools/list_tasks.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Octo
+  module Tools
+    # Tool for listing task history (Time Machine feature)
+    class ListTasks < Base
+      self.tool_name = "list_tasks"
+      self.tool_description = "List recent tasks in the task history with summaries. " \
+        "Shows current task, past tasks, and future tasks (after undo). " \
+        "Use when user wants to see task history or choose which task to undo/redo to."
+      self.tool_category = "time_machine"
+      self.tool_parameters = {
+        type: "object",
+        properties: {
+          limit: {
+            type: "integer",
+            description: "Maximum number of recent tasks to show (default: 10)",
+            default: 10
+          }
+        }
+      }
+
+      def execute(agent:, limit: 10, **_args)
+        history = agent.get_task_history(limit: limit)
+        
+        if history.empty?
+          return "No task history available."
+        end
+
+        lines = ["Task History:"]
+        history.each do |task|
+          indicator = case task[:status]
+          when :current then "→"
+          when :past then " "
+          when :future then "↯"
+          end
+          
+          branch_indicator = task[:has_branches] ? " ⎇" : ""
+          lines << "#{indicator}#{branch_indicator} Task #{task[:task_id]}: #{task[:summary]}"
+        end
+
+        lines.join("\n")
+      end
+
+      def format_call(limit: 10, **_args)
+        "Listing task history (limit: #{limit})..."
+      end
+
+      def format_result(result)
+        result
+      end
+    end
+  end
+end