rubycode 0.1.1 → 0.1.2

data/lib/rubycode/tools/read.rb

@@ -1,74 +1,59 @@
 # frozen_string_literal: true
 
-module Rubycode
+module RubyCode
   module Tools
-    class Read
-      def self.definition
-        {
-          type: "function",
-          function: {
-            name: "read",
-            description: "Read a file or directory from the filesystem.\n\n- Use this when you know the file path and want to see its contents\n- Returns file contents with line numbers (format: 'line_number: content')\n- For directories, returns a listing of entries\n- Use the search tool to find specific content in files\n- Use bash with 'ls' or 'find' to discover what files exist",
-            parameters: {
-              type: "object",
-              properties: {
-                file_path: {
-                  type: "string",
-                  description: "Absolute or relative path to the file to read"
-                },
-                offset: {
-                  type: "integer",
-                  description: "Line number to start reading from (1-indexed). Optional."
-                },
-                limit: {
-                  type: "integer",
-                  description: "Maximum number of lines to read. Default 2000. Optional."
-                }
-              },
-              required: ["file_path"]
-            }
-          }
-        }
-      end
+    # Tool for reading files and directories
+    class Read < Base
+      private
 
-      def self.execute(params:, context:)
+      def perform(params)
         file_path = params["file_path"]
         offset = params["offset"] || 1
         limit = params["limit"] || 2000
 
-        # Resolve relative paths
-        full_path = if File.absolute_path?(file_path)
-                      file_path
-                    else
-                      File.join(context[:root_path], file_path)
-                    end
+        full_path = resolve_path(file_path)
+        raise FileNotFoundError, "File '#{file_path}' does not exist" unless File.exist?(full_path)
+
+        return list_directory(full_path, file_path) if File.directory?(full_path)
 
-        unless File.exist?(full_path)
-          return "Error: File '#{file_path}' does not exist"
-        end
+        format_file_lines(full_path, offset, limit)
+      end
+
+      def resolve_path(file_path)
+        File.absolute_path?(file_path) ? file_path : File.join(root_path, file_path)
+      end
 
-        if File.directory?(full_path)
-          # List directory contents instead
-          entries = Dir.entries(full_path).reject { |e| e.start_with?(".") }.sort
-          return "Directory listing for '#{file_path}':\n" + entries.map { |e| "  #{e}" }.join("\n")
-        end
+      def list_directory(full_path, file_path)
+        entries = Dir.entries(full_path).reject { |e| e.start_with?(".") }.sort
+        "Directory listing for '#{file_path}':\n" + entries.map { |e| "  #{e}" }.join("\n")
+      end
 
+      def format_file_lines(full_path, offset, limit)
         lines = File.readlines(full_path)
         start_idx = [offset - 1, 0].max
         end_idx = [start_idx + limit - 1, lines.length - 1].min
 
-        result = []
-        (start_idx..end_idx).each do |i|
-          line_num = i + 1
-          content = lines[i].chomp
-          # Truncate long lines
-          content = content[0..2000] + "..." if content.length > 2000
-          result << "#{line_num}: #{content}"
-        end
+        formatted_lines = (start_idx..end_idx).map do |i|
+          format_line(lines[i], i + 1)
+        end.join("\n")
+
+        build_tool_result(formatted_lines, start_idx, end_idx, lines.length)
+      end
+
+      def build_tool_result(content, start_idx, end_idx, total_lines)
+        ToolResult.new(
+          content: content,
+          metadata: {
+            line_count: end_idx - start_idx + 1,
+            truncated: end_idx < total_lines - 1
+          }
+        )
+      end
 
-        result.join("\n")
-      rescue => e
-        "Error reading file: #{e.message}"
+      def format_line(line, line_num)
+        content = line.chomp
+        content = "#{content[0..2000]}..." if content.length > 2000
+        "#{line_num}: #{content}"
       end
     end
   end

data/lib/rubycode/tools/search.rb

@@ -1,88 +1,63 @@
 # frozen_string_literal: true
 
+require "English"
 require "shellwords"
 
-module Rubycode
+module RubyCode
   module Tools
-    class Search
-      def self.definition
-        {
-          type: "function",
-          function: {
-            name: "search",
-            description: "Search INSIDE file contents for patterns using grep. Returns matching lines with file paths and line numbers.\n\n- Searches file CONTENTS using regular expressions\n- Use this when you need to find WHERE specific text/code appears inside files\n- Returns file paths, line numbers, and the matching content\n- Example: search for 'button' to find files containing that text",
-            parameters: {
-              type: "object",
-              properties: {
-                pattern: {
-                  type: "string",
-                  description: "The pattern to search for (supports regex)"
-                },
-                path: {
-                  type: "string",
-                  description: "Directory or file to search in. Defaults to '.' (current directory). Optional."
-                },
-                include: {
-                  type: "string",
-                  description: "File pattern to include (e.g., '*.rb', '*.js'). Optional."
-                },
-                case_insensitive: {
-                  type: "boolean",
-                  description: "Perform case-insensitive search. Optional."
-                }
-              },
-              required: ["pattern"]
-            }
-          }
-        }
-      end
+    # Tool for searching file contents with grep
+    class Search < Base
+      private
 
-      def self.execute(params:, context:)
+      def perform(params)
         pattern = params["pattern"]
         path = params["path"] || "."
-        include_pattern = params["include"]
-        case_insensitive = params["case_insensitive"] || false
 
-        # Resolve relative paths
-        full_path = if File.absolute_path?(path)
-                      path
-                    else
-                      File.join(context[:root_path], path)
-                    end
+        full_path = resolve_path(path)
+        raise PathError, "Path '#{path}' does not exist" unless File.exist?(full_path)
 
-        unless File.exist?(full_path)
-          return "Error: Path '#{path}' does not exist"
-        end
+        command = build_grep_command(pattern, full_path, params)
+        output, exit_code = execute_grep(command)
 
-        # Build grep command safely using Shellwords to prevent injection
-        cmd_parts = ["grep", "-n", "-r"]
-        cmd_parts << "-i" if case_insensitive
-        cmd_parts << "--include=#{Shellwords.escape(include_pattern)}" if include_pattern
-        cmd_parts << Shellwords.escape(pattern)
-        cmd_parts << Shellwords.escape(full_path)
+        format_output(output, exit_code, pattern)
+      end
+
+      def resolve_path(path)
+        File.absolute_path?(path) ? path : File.join(root_path, path)
+      end
 
-        command = cmd_parts.join(" ")
+      def build_grep_command(pattern, full_path, params)
+        [
+          "grep", "-n", "-r",
+          ("-i" if params["case_insensitive"]),
+          ("--include=#{Shellwords.escape(params["include"])}" if params["include"]),
+          Shellwords.escape(pattern),
+          Shellwords.escape(full_path)
+        ].compact.join(" ")
+      end
 
+      def execute_grep(command)
         output = `#{command} 2>&1`
-        exit_code = $?.exitstatus
+        [output, $CHILD_STATUS.exitstatus]
+      end
 
-        if exit_code == 0
-          # Found matches
-          lines = output.split("\n")
-          if lines.length > 100
-            lines[0..99].join("\n") + "\n\n... (#{lines.length - 100} more matches truncated)"
-          else
-            output
-          end
-        elsif exit_code == 1
-          # No matches found
+      def format_output(output, exit_code, pattern)
+        case exit_code
+        when 0
+          truncate_output(output)
+        when 1
           "No matches found for pattern: #{pattern}"
         else
-          # Error occurred
-          "Error running search: #{output}"
+          raise CommandExecutionError, "Error running search: #{output}"
         end
-      rescue => e
-        "Error: #{e.message}"
+      end
+
+      def truncate_output(output)
+        lines = output.split("\n")
+        return output if lines.length <= 100
+
+        truncated = lines[0..99].join("\n")
+        "#{truncated}\n\n... (#{lines.length - 100} more matches truncated)"
       end
     end
   end

data/lib/rubycode/tools.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
+require_relative "tools/base"
 require_relative "tools/bash"
 require_relative "tools/read"
 require_relative "tools/search"
 require_relative "tools/done"
 
-module Rubycode
+module RubyCode
+  # Collection of available tools for the AI agent
   module Tools
     # Registry of all available tools
     TOOLS = [
@@ -22,11 +24,14 @@ module Rubycode
     def self.execute(tool_name:, params:, context:)
       tool_class = TOOLS.find { |t| t.definition[:function][:name] == tool_name }
 
-      unless tool_class
-        return "Error: Unknown tool '#{tool_name}'"
-      end
+      raise ToolError, "Unknown tool '#{tool_name}'" unless tool_class
 
-      tool_class.execute(params: params, context: context)
+      # Instantiate tool and call execute
+      tool_instance = tool_class.new(context: context)
+      result = tool_instance.execute(params)
+
+      # Convert result to string for history compatibility
+      result.respond_to?(:to_s) ? result.to_s : result
     end
   end
 end

data/lib/rubycode/value_objects.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RubyCode
+  # Represents a conversation message
+  class Message
+    attr_reader :role, :content, :timestamp
+
+    def initialize(role:, content:)
+      @role = role
+      @content = content
+      @timestamp = Time.now
+    end
+
+    def to_h
+      { role: role, content: content }
+    end
+
+    def ==(other)
+      other.is_a?(Message) &&
+        role == other.role &&
+        content == other.content
+    end
+  end
+
+  # Represents a tool call from the LLM
+  class ToolCall
+    attr_reader :name, :arguments
+
+    def initialize(name:, arguments:)
+      @name = name
+      @arguments = arguments
+    end
+
+    def to_h
+      { name: name, arguments: arguments }
+    end
+
+    def ==(other)
+      other.is_a?(ToolCall) &&
+        name == other.name &&
+        arguments == other.arguments
+    end
+  end
+
+  # Represents the result of a tool execution
+  class ToolResult
+    attr_reader :content, :metadata
+
+    def initialize(content:, metadata: {})
+      @content = content
+      @metadata = metadata
+    end
+
+    def to_s
+      content
+    end
+
+    def truncated?
+      metadata[:truncated] == true
+    end
+
+    def line_count
+      metadata[:line_count]
+    end
+
+    def ==(other)
+      other.is_a?(ToolResult) &&
+        content == other.content &&
+        metadata == other.metadata
+    end
+  end
+
+  # Represents the result of a bash command execution
+  class CommandResult
+    attr_reader :stdout, :stderr, :exit_code
+
+    def initialize(stdout:, stderr: "", exit_code: 0)
+      @stdout = stdout
+      @stderr = stderr
+      @exit_code = exit_code
+    end
+
+    def success?
+      exit_code.zero?
+    end
+
+    def output
+      success? ? stdout : stderr
+    end
+
+    def to_s
+      output
+    end
+
+    def ==(other)
+      other.is_a?(CommandResult) &&
+        stdout == other.stdout &&
+        stderr == other.stderr &&
+        exit_code == other.exit_code
+    end
+  end
+end

data/lib/rubycode/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-module Rubycode
-  VERSION = "0.1.1"
+module RubyCode
+  VERSION = "0.1.2"
 end

data/lib/rubycode.rb

@@ -1,17 +1,19 @@
 # frozen_string_literal: true
 
 require_relative "rubycode/version"
+require_relative "rubycode/errors"
+require_relative "rubycode/value_objects"
 require_relative "rubycode/configuration"
 require_relative "rubycode/history"
 require_relative "rubycode/context_builder"
 require_relative "rubycode/adapters/base"
 require_relative "rubycode/adapters/ollama"
 require_relative "rubycode/tools"
+require_relative "rubycode/agent_loop"
 require_relative "rubycode/client"
 
-module Rubycode
-  class Error < StandardError; end
-
+# Rubycode is a Ruby-native AI coding agent with pluggable LLM adapters
+module RubyCode
   class << self
     attr_accessor :configuration
   end

data/rubycode_cli.rb

@@ -4,7 +4,7 @@
 require_relative "lib/rubycode"
 require "readline"
 
-puts "\n" + "=" * 80
+puts "\n#{"=" * 80}"
 puts "🚀 RubyCode - AI Ruby/Rails Code Assistant"
 puts "=" * 80
 
@@ -26,27 +26,26 @@ puts "\n📁 Working directory: #{full_path}"
 # Ask if debug mode should be enabled
 print "Enable debug mode? (shows JSON requests/responses) [y/N]: "
 debug_input = gets.chomp.downcase
-debug_mode = debug_input == 'y' || debug_input == 'yes'
+debug_mode = %w[y yes].include?(debug_input)
 
 # Configure the client
-Rubycode.configure do |config|
+RubyCode.configure do |config|
   config.adapter = :ollama
   config.url = "http://localhost:11434"
   config.model = "deepseek-v3.1:671b-cloud"
   config.root_path = full_path
   config.debug = debug_mode
 
-  # Test deepseek WITHOUT workaround first - it should have better tool-calling than qwen3
-  # If it fails, enable this: config.enable_tool_injection_workaround = true
-  config.enable_tool_injection_workaround = false
+  # Enable workaround to force tool-calling for models that don't follow instructions
+  config.enable_tool_injection_workaround = true
 end
 
-puts "🐛 Debug mode: #{debug_mode ? 'ON' : 'OFF'}" if debug_mode
+puts "🐛 Debug mode: #{debug_mode ? "ON" : "OFF"}" if debug_mode
 
 # Create a client
-client = Rubycode::Client.new
+client = RubyCode::Client.new
 
-puts "\n" + "=" * 80
+puts "\n#{"=" * 80}"
 puts "✨ Agent initialized! You can now ask questions or request code changes."
 puts "   Type 'exit' or 'quit' to exit, 'clear' to clear history"
 puts "=" * 80
@@ -61,16 +60,16 @@ loop do
 
   # Handle commands
   case prompt.strip.downcase
-  when 'exit', 'quit'
+  when "exit", "quit"
     puts "\n👋 Goodbye!"
     break
-  when 'clear'
+  when "clear"
     client.clear_history
     puts "\n🗑️  History cleared!"
     next
   end
 
-  puts "\n" + "-" * 80
+  puts "\n#{"-" * 80}"
 
   begin
     # Get response from agent
@@ -82,7 +81,7 @@ loop do
     puts "-" * 80
   rescue Interrupt
     puts "\n\n⚠️  Interrupted! Type 'exit' to quit or continue chatting."
-  rescue => e
+  rescue StandardError => e
     puts "\n❌ Error: #{e.message}"
     puts e.backtrace.first(3).join("\n")
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubycode
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Jonas Medeiros
@@ -22,27 +22,39 @@ files:
 - README.md
 - Rakefile
 - USAGE.md
+- config/tools/bash.json
+- config/tools/done.json
+- config/tools/read.json
+- config/tools/search.json
 - lib/rubycode.rb
 - lib/rubycode/adapters/base.rb
 - lib/rubycode/adapters/ollama.rb
+- lib/rubycode/agent_loop.rb
 - lib/rubycode/client.rb
+- lib/rubycode/client/display_formatter.rb
+- lib/rubycode/client/response_handler.rb
 - lib/rubycode/configuration.rb
 - lib/rubycode/context_builder.rb
+- lib/rubycode/errors.rb
 - lib/rubycode/history.rb
 - lib/rubycode/tools.rb
+- lib/rubycode/tools/base.rb
 - lib/rubycode/tools/bash.rb
 - lib/rubycode/tools/done.rb
 - lib/rubycode/tools/read.rb
 - lib/rubycode/tools/search.rb
+- lib/rubycode/value_objects.rb
 - lib/rubycode/version.rb
-- rubycode-0.1.0.gem
 - rubycode_cli.rb
 - sig/rubycode.rbs
-homepage: https://example.com
+homepage: https://github.com/jonasmedeiros/rubycode
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://example.com
+  homepage_uri: https://github.com/jonasmedeiros/rubycode
+  source_code_uri: https://github.com/jonasmedeiros/rubycode
+  bug_tracker_uri: https://github.com/jonasmedeiros/rubycode/issues
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib