rubycode 0.1.1 → 0.1.2

data/lib/rubycode/client.rb

@@ -1,186 +1,34 @@
 # frozen_string_literal: true
 
-module Rubycode
+module RubyCode
+  # Main client that provides the public API for the agent
   class Client
     attr_reader :history
 
     def initialize
-      @config = Rubycode.config
+      @config = RubyCode.config
       @adapter = build_adapter
       @history = History.new
     end
 
-    MAX_ITERATIONS = 25  # Maximum number of LLM calls per request
-    MAX_TOOL_CALLS = 50  # Maximum total tool calls
-
     def ask(prompt:)
-      # Add user message to history
       @history.add_message(role: "user", content: prompt)
-
-      # Build system prompt with environment context
       system_prompt = build_system_prompt
 
-      iteration = 0
-      total_tool_calls = 0
-
-      # Agent loop: keep calling LLM until no more tool calls
-      loop do
-        iteration += 1
-
-        # Check iteration limit
-        if iteration > MAX_ITERATIONS
-          error_msg = "⚠️  Reached maximum iterations (#{MAX_ITERATIONS}). The agent may be stuck in a loop."
-          puts "\n#{error_msg}\n"
-          @history.add_message(role: "assistant", content: error_msg)
-          return error_msg
-        end
-
-        # Get messages in LLM format
-        messages = @history.to_llm_format
-
-        # Get response from LLM with tools
-        response_body = @adapter.generate(
-          messages: messages,
-          system: system_prompt,
-          tools: Tools.definitions
-        )
-
-        # Extract assistant message
-        assistant_message = response_body["message"]
-        content = assistant_message["content"] || ""
-        tool_calls = assistant_message["tool_calls"] || []
-
-        # Add assistant response to history
-        @history.add_message(role: "assistant", content: content)
-
-        # If no tool calls, we're done
-        if tool_calls.empty?
-          # ============================================================================
-          # WORKAROUND FOR WEAK TOOL-CALLING MODELS (e.g., qwen3-coder)
-          # This is ONLY for testing with models that have poor tool-calling capabilities.
-          # OpenCode does NOT do this - they rely on good models (Claude, GPT-4).
-          # Enable with: config.enable_tool_injection_workaround = true
-          # ============================================================================
-          if @config.enable_tool_injection_workaround && iteration < 10
-            puts "   ⚠️  No tool calls - injecting reminder (iteration #{iteration})" unless @config.debug
-
-            @history.add_message(
-              role: "user",
-              content: "You MUST call a tool. Do not respond with text. Call search, read, bash, or done tool now."
-            )
-            next  # Continue the loop
-          end
-          # ============================================================================
-          # END WORKAROUND
-          # ============================================================================
-
-          puts "\n✅ Agent finished (#{iteration} iterations, #{total_tool_calls} tool calls)\n" unless @config.debug
-          return content
-        end
-
-        # Check tool call limit
-        total_tool_calls += tool_calls.length
-        if total_tool_calls > MAX_TOOL_CALLS
-          error_msg = "⚠️  Reached maximum tool calls (#{MAX_TOOL_CALLS}). Stopping to prevent excessive operations."
-          puts "\n#{error_msg}\n"
-          @history.add_message(role: "assistant", content: error_msg)
-          return content.empty? ? error_msg : content
-        end
-
-        # Execute each tool call
-        unless @config.debug
-          puts "\n🤖 Iteration #{iteration}: Calling #{tool_calls.length} tool(s)..."
-        end
-
-        done_result = nil
-        tool_calls.each do |tool_call|
-          result = execute_tool(tool_call)
-
-          # Check if this was the "done" tool
-          if tool_call.dig("function", "name") == "done"
-            done_result = result
-            break
-          end
-        end
-
-        # If done was called, return the result
-        if done_result
-          puts "\n✅ Agent finished (#{iteration} iterations, #{total_tool_calls + 1} tool calls)\n" unless @config.debug
-          return done_result
-        end
-
-        # Loop continues - send tool results back to LLM
-      end
+      AgentLoop.new(
+        adapter: @adapter,
+        history: @history,
+        config: @config,
+        system_prompt: system_prompt
+      ).run
     end
 
-    private
-
     def clear_history
       @history.clear
     end
 
     private
 
-    def execute_tool(tool_call)
-      tool_name = tool_call.dig("function", "name")
-      arguments = tool_call.dig("function", "arguments")
-
-      if @config.debug
-        puts "\n🔧 Tool: #{tool_name}"
-        puts "   Args: #{arguments.inspect}"
-      else
-        # Show minimal output
-        case tool_name
-        when "bash"
-          cmd = arguments.is_a?(Hash) ? arguments["command"] : JSON.parse(arguments)["command"]
-          puts "   💻 #{cmd}"
-        when "read"
-          file = arguments.is_a?(Hash) ? arguments["file_path"] : JSON.parse(arguments)["file_path"]
-          puts "   📖 #{file}"
-        when "search"
-          pattern = arguments.is_a?(Hash) ? arguments["pattern"] : JSON.parse(arguments)["pattern"]
-          puts "   🔍 #{pattern}"
-        end
-      end
-
-      begin
-        # Arguments might be Hash or JSON string
-        params = arguments.is_a?(Hash) ? arguments : JSON.parse(arguments)
-
-        # Execute the tool
-        context = { root_path: @config.root_path }
-        result = Tools.execute(
-          tool_name: tool_name,
-          params: params,
-          context: context
-        )
-
-        if @config.debug
-          puts "   ✓ Result: #{result.lines.first&.strip || '(empty)'}#{result.lines.count > 1 ? "... (#{result.lines.count} lines)" : ""}"
-        end
-
-        # Add tool result to history
-        @history.add_message(
-          role: "user",
-          content: "Tool '#{tool_name}' result:\n#{result}"
-        )
-
-        # Return the result so caller can check if it was "done"
-        result
-
-      rescue JSON::ParserError => e
-        error_msg = "Error parsing tool arguments: #{e.message}"
-        puts "   ✗ #{error_msg}"
-        @history.add_message(role: "user", content: error_msg)
-        nil
-      rescue => e
-        error_msg = "Error executing tool: #{e.message}"
-        puts "   ✗ #{error_msg}"
-        @history.add_message(role: "user", content: error_msg)
-        nil
-      end
-    end
-
     def build_adapter
       case @config.adapter
       when :ollama
@@ -193,7 +41,7 @@ module Rubycode
     def build_system_prompt
       context = ContextBuilder.new(root_path: @config.root_path).environment_context
 
-      <<~PROMPT.strip
+      <<~PROMPT
         You are a helpful Ruby on Rails coding assistant.
 
         #{context}
@@ -202,17 +50,21 @@ module Rubycode
         You MUST call a tool in EVERY response. You MUST NEVER respond with just text.
 
         # Available tools
-        - bash: explore directories (ls, find)
-        - search: find text inside files (supports case_insensitive parameter)
+        - bash: run any safe command (ls, find, grep, cat, etc.)
+        - search: simplified search (use bash + grep for more control)
         - read: view file contents with line numbers
-        - done: call this when you have the answer (with your final answer as the parameter)
-
-        # Required workflow
-        1. Call search with the pattern
-        2. If "No matches found" → call search again with case_insensitive: true
-        3. If still no matches → call search with simpler pattern
-        4. Once found → call read to see the file
-        5. Once you have the answer → call done with your final answer
+        - done: call when you have the answer
+
+        # Recommended workflow
+        1. Use bash with grep to search: `grep -rn "pattern" directory/`
+        2. Use bash with find to locate files: `find . -name "*.rb"`
+        3. Once found → use read to see the file
+        4. When ready → call done with your final answer
+
+        # Example searches
+        - `grep -rn "button" app/views` - search for "button" in views
+        - `grep -ri "new product" .` - case-insensitive search
+        - `find . -name "*product*"` - find files with "product" in name
 
         IMPORTANT: You cannot respond with plain text. You must ALWAYS call one of the tools.
         When you're ready to provide your answer, call the "done" tool with your answer as the parameter.

data/lib/rubycode/configuration.rb

@@ -1,22 +1,21 @@
 # frozen_string_literal: true
 
-module Rubycode
+module RubyCode
+  # Configuration class for Rubycode settings
   class Configuration
-
     attr_accessor :adapter, :url, :model, :root_path, :debug, :enable_tool_injection_workaround
 
     def initialize
       @adapter = :ollama
       @url = "http://localhost:11434"
-      @model = "qwen3-coder:480b-cloud"
+      @model = "deepseek-v3.1:671b-cloud"
       @root_path = Dir.pwd
-      @debug = false  # Set to true to see JSON requests/responses
+      @debug = false # Set to true to see JSON requests/responses
 
-      # WORKAROUND for weak tool-calling models (qwen3-coder, etc.)
+      # WORKAROUND for models that don't follow tool-calling instructions
       # When enabled, injects reminder messages if model generates text instead of calling tools
-      # OpenCode does NOT use this - they rely on strong tool-calling models (Claude, GPT-4)
-      # Set to true ONLY for testing with weak models
-      @enable_tool_injection_workaround = false
+      # Enabled by default as most models need this nudge
+      @enable_tool_injection_workaround = true
     end
   end
 end

data/lib/rubycode/context_builder.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-module Rubycode
+module RubyCode
+  # Builds environment context for the AI assistant
   class ContextBuilder
     def initialize(root_path:)
       @root_path = root_path
@@ -12,7 +13,7 @@ module Rubycode
         Working directory: #{@root_path}
         Platform: #{RUBY_PLATFORM}
         Ruby version: #{RUBY_VERSION}
-        Today's date: #{Time.now.strftime('%Y-%m-%d')}
+        Today's date: #{Time.now.strftime("%Y-%m-%d")}
         </env>
       CONTEXT
     end

data/lib/rubycode/errors.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RubyCode
+  # Base error class for all RubyCode errors
+  class Error < StandardError; end
+
+  # Base class for all tool-related errors
+  class ToolError < Error; end
+
+  # Raised when attempting to execute an unsafe bash command
+  class UnsafeCommandError < ToolError; end
+
+  # Raised when a file is not found
+  class FileNotFoundError < ToolError; end
+
+  # Raised when a path is invalid or outside allowed directory
+  class PathError < ToolError; end
+
+  # Raised when command execution fails
+  class CommandExecutionError < ToolError; end
+end

data/lib/rubycode/history.rb

@@ -1,37 +1,39 @@
 # frozen_string_literal: true
 
-module Rubycode
+module RubyCode
+  # Manages conversation history between user and assistant
   class History
+    attr_reader :messages
+
     def initialize
       @messages = []
     end
 
-    def add_message(role:, content:)
-      @messages << {
-        role: role,
-        content: content,
-        timestamp: Time.now
-      }
+    # Accept either Message objects or keyword arguments for backwards compatibility
+    def add_message(message = nil, role: nil, content: nil)
+      if message.is_a?(Message)
+        @messages << message
+      elsif role && content
+        @messages << Message.new(role: role, content: content)
+      else
+        raise ArgumentError, "Must provide either a Message object or role: and content: keyword arguments"
+      end
     end
 
     def to_llm_format
-      @messages.map { |msg| { role: msg[:role], content: msg[:content] } }
+      @messages.map(&:to_h)
     end
 
     def clear
       @messages = []
     end
 
-    def messages
-      @messages
-    end
-
     def last_user_message
-      @messages.reverse.find { |msg| msg[:role] == "user" }
+      @messages.reverse.find { |msg| msg.role == "user" }
     end
 
     def last_assistant_message
-      @messages.reverse.find { |msg| msg[:role] == "assistant" }
+      @messages.reverse.find { |msg| msg.role == "assistant" }
     end
   end
 end

data/lib/rubycode/tools/base.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RubyCode
+  module Tools
+    # Base class for all tools providing common functionality
+    class Base
+      attr_reader :context
+
+      def initialize(context:)
+        @context = context
+      end
+
+      # Public execute method that validates and calls perform
+      def execute(params)
+        validate_params!(params)
+        result = perform(params)
+        wrap_result(result)
+      rescue ToolError => e
+        # Re-raise tool errors as-is
+        raise e
+      rescue StandardError => e
+        # Wrap unexpected errors in ToolError
+        raise ToolError, "Error in #{self.class.name}: #{e.message}"
+      end
+
+      # Load tool schema from JSON file in config/tools/
+      def self.definition
+        @definition ||= load_schema
+      end
+
+      # Load schema from config/tools/{tool_name}.json
+      def self.load_schema
+        tool_name = name.split("::").last.downcase
+        schema_path = File.join(__dir__, "..", "..", "..", "config", "tools", "#{tool_name}.json")
+
+        raise ToolError, "Schema file not found: #{schema_path}" unless File.exist?(schema_path)
+
+        JSON.parse(File.read(schema_path), symbolize_names: true)
+      end
+
+      private
+
+      # Must be implemented by subclasses to perform the actual work
+      def perform(params)
+        raise NotImplementedError, "#{self.class.name} must implement #perform"
+      end
+
+      # Validates required parameters based on schema
+      def validate_params!(params)
+        return unless self.class.definition.dig(:function, :parameters, :required)
+
+        required_params = self.class.definition.dig(:function, :parameters, :required)
+        required_params.each do |param|
+          next if params.key?(param) || params.key?(param.to_s)
+
+          raise ToolError, "Missing required parameter: #{param}"
+        end
+      end
+
+      # Wraps string results in ToolResult, passes through ToolResult and CommandResult
+      def wrap_result(result)
+        case result
+        when ToolResult, CommandResult
+          result
+        when String
+          ToolResult.new(content: result)
+        else
+          ToolResult.new(content: result.to_s)
+        end
+      end
+
+      # Helper to get root path from context
+      def root_path
+        context[:root_path]
+      end
+    end
+  end
+end

data/lib/rubycode/tools/bash.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
+require "English"
 require "shellwords"
 
-module Rubycode
+module RubyCode
   module Tools
-    class Bash
+    # Tool for executing safe bash commands
+    class Bash < Base
       # Whitelist of safe commands
       SAFE_COMMANDS = %w[
         ls
@@ -18,57 +20,46 @@ module Rubycode
         file
         which
         echo
+        grep
+        rg
       ].freeze
 
-      def self.definition
-        {
-          type: "function",
-          function: {
-            name: "bash",
-            description: "Execute safe bash commands for exploring the filesystem and terminal operations.\n\nIMPORTANT: This tool is for terminal operations and directory exploration (ls, find, tree, etc.). DO NOT use it for file operations (reading, searching file contents) - use the specialized tools instead.\n\nWhitelisted commands: #{SAFE_COMMANDS.join(', ')}",
-            parameters: {
-              type: "object",
-              properties: {
-                command: {
-                  type: "string",
-                  description: "The bash command to execute (e.g., 'ls -la', 'find . -name \"*.rb\"', 'tree app')"
-                }
-              },
-              required: ["command"]
-            }
-          }
-        }
-      end
+      private
 
-      def self.execute(params:, context:)
+      def perform(params)
         command = params["command"].strip
-
-        # Extract the base command (first word)
         base_command = command.split.first
 
-        unless SAFE_COMMANDS.include?(base_command)
-          return "Error: Command '#{base_command}' is not allowed. Safe commands: #{SAFE_COMMANDS.join(', ')}"
-        end
+        raise UnsafeCommandError, safe_command_error(base_command) unless SAFE_COMMANDS.include?(base_command)
 
-        # Execute in the project's root directory
-        Dir.chdir(context[:root_path]) do
+        execute_command(command)
+      end
+
+      def safe_command_error(base_command)
+        "Command '#{base_command}' is not allowed. Safe commands: #{SAFE_COMMANDS.join(", ")}"
+      end
+
+      def execute_command(command)
+        Dir.chdir(root_path) do
           output = `#{command} 2>&1`
-          exit_code = $?.exitstatus
+          exit_code = $CHILD_STATUS.exitstatus
+
+          raise CommandExecutionError, "Command failed with exit code #{exit_code}:\n#{output}" unless exit_code.zero?
 
-          if exit_code == 0
-            # Limit output length
-            lines = output.split("\n")
-            if lines.length > 200
-              lines[0..199].join("\n") + "\n\n... (#{lines.length - 200} more lines truncated)"
-            else
-              output
-            end
-          else
-            "Command failed with exit code #{exit_code}:\n#{output}"
-          end
+          CommandResult.new(
+            stdout: truncate_output(output),
+            stderr: "",
+            exit_code: exit_code
+          )
         end
-      rescue => e
-        "Error executing command: #{e.message}"
+      end
+
+      def truncate_output(output)
+        lines = output.split("\n")
+        return output if lines.length <= 200
+
+        truncated_output = lines[0..199].join("\n")
+        "#{truncated_output}\n\n... (#{lines.length - 200} more lines truncated)"
       end
     end
   end

data/lib/rubycode/tools/done.rb

@@ -1,30 +1,12 @@
 # frozen_string_literal: true
 
-module Rubycode
+module RubyCode
   module Tools
-    class Done
-      def self.definition
-        {
-          type: "function",
-          function: {
-            name: "done",
-            description: "Call this when you have found the code and are ready to provide your final answer. This signals you are finished exploring.",
-            parameters: {
-              type: "object",
-              properties: {
-                answer: {
-                  type: "string",
-                  description: "Your final answer showing the file, line number, current code, and suggested change"
-                }
-              },
-              required: ["answer"]
-            }
-          }
-        }
-      end
+    # Tool for signaling task completion
+    class Done < Base
+      private
 
-      def self.execute(params:, context:)
-        # Just return the answer - this is the final response
+      def perform(params)
         params["answer"]
       end
     end