rubycode 0.1.0 → 0.1.2

data/lib/rubycode/client.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RubyCode
+  # Main client that provides the public API for the agent
+  class Client
+    attr_reader :history
+
+    def initialize
+      @config = RubyCode.config
+      @adapter = build_adapter
+      @history = History.new
+    end
+
+    def ask(prompt:)
+      @history.add_message(role: "user", content: prompt)
+      system_prompt = build_system_prompt
+
+      AgentLoop.new(
+        adapter: @adapter,
+        history: @history,
+        config: @config,
+        system_prompt: system_prompt
+      ).run
+    end
+
+    def clear_history
+      @history.clear
+    end
+
+    private
+
+    def build_adapter
+      case @config.adapter
+      when :ollama
+        Adapters::Ollama.new(@config)
+      else
+        raise "Unknown Adapter"
+      end
+    end
+
+    def build_system_prompt
+      context = ContextBuilder.new(root_path: @config.root_path).environment_context
+
+      <<~PROMPT
+        You are a helpful Ruby on Rails coding assistant.
+
+        #{context}
+
+        # CRITICAL RULE
+        You MUST call a tool in EVERY response. You MUST NEVER respond with just text.
+
+        # Available tools
+        - 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 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.
+      PROMPT
+    end
+  end
+end

data/lib/rubycode/configuration.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+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 = "deepseek-v3.1:671b-cloud"
+      @root_path = Dir.pwd
+      @debug = false # Set to true to see JSON requests/responses
+
+      # WORKAROUND for models that don't follow tool-calling instructions
+      # When enabled, injects reminder messages if model generates text instead of calling tools
+      # Enabled by default as most models need this nudge
+      @enable_tool_injection_workaround = true
+    end
+  end
+end

data/lib/rubycode/context_builder.rb

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RubyCode
+  # Manages conversation history between user and assistant
+  class History
+    attr_reader :messages
+
+    def initialize
+      @messages = []
+    end
+
+    # 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(&:to_h)
+    end
+
+    def clear
+      @messages = []
+    end
+
+    def last_user_message
+      @messages.reverse.find { |msg| msg.role == "user" }
+    end
+
+    def last_assistant_message
+      @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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "English"
+require "shellwords"
+
+module RubyCode
+  module Tools
+    # Tool for executing safe bash commands
+    class Bash < Base
+      # Whitelist of safe commands
+      SAFE_COMMANDS = %w[
+        ls
+        pwd
+        find
+        tree
+        cat
+        head
+        tail
+        wc
+        file
+        which
+        echo
+        grep
+        rg
+      ].freeze
+
+      private
+
+      def perform(params)
+        command = params["command"].strip
+        base_command = command.split.first
+
+        raise UnsafeCommandError, safe_command_error(base_command) unless SAFE_COMMANDS.include?(base_command)
+
+        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 = $CHILD_STATUS.exitstatus
+
+          raise CommandExecutionError, "Command failed with exit code #{exit_code}:\n#{output}" unless exit_code.zero?
+
+          CommandResult.new(
+            stdout: truncate_output(output),
+            stderr: "",
+            exit_code: exit_code
+          )
+        end
+      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
+end

data/lib/rubycode/tools/done.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RubyCode
+  module Tools
+    # Tool for signaling task completion
+    class Done < Base
+      private
+
+      def perform(params)
+        params["answer"]
+      end
+    end
+  end
+end

data/lib/rubycode/tools/read.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RubyCode
+  module Tools
+    # Tool for reading files and directories
+    class Read < Base
+      private
+
+      def perform(params)
+        file_path = params["file_path"]
+        offset = params["offset"] || 1
+        limit = params["limit"] || 2000
+
+        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)
+
+        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
+
+      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
+
+        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
+
+      def format_line(line, line_num)
+        content = line.chomp
+        content = "#{content[0..2000]}..." if content.length > 2000
+        "#{line_num}: #{content}"
+      end
+    end
+  end
+end

data/lib/rubycode/tools/search.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "English"
+require "shellwords"
+
+module RubyCode
+  module Tools
+    # Tool for searching file contents with grep
+    class Search < Base
+      private
+
+      def perform(params)
+        pattern = params["pattern"]
+        path = params["path"] || "."
+
+        full_path = resolve_path(path)
+        raise PathError, "Path '#{path}' does not exist" unless File.exist?(full_path)
+
+        command = build_grep_command(pattern, full_path, params)
+        output, exit_code = execute_grep(command)
+
+        format_output(output, exit_code, pattern)
+      end
+
+      def resolve_path(path)
+        File.absolute_path?(path) ? path : File.join(root_path, path)
+      end
+
+      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`
+        [output, $CHILD_STATUS.exitstatus]
+      end
+
+      def format_output(output, exit_code, pattern)
+        case exit_code
+        when 0
+          truncate_output(output)
+        when 1
+          "No matches found for pattern: #{pattern}"
+        else
+          raise CommandExecutionError, "Error running search: #{output}"
+        end
+      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
+end

data/lib/rubycode/tools.rb

@@ -0,0 +1,37 @@
+# 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
+  # Collection of available tools for the AI agent
+  module Tools
+    # Registry of all available tools
+    TOOLS = [
+      Bash,
+      Read,
+      Search,
+      Done
+    ].freeze
+
+    def self.definitions
+      TOOLS.map(&:definition)
+    end
+
+    def self.execute(tool_name:, params:, context:)
+      tool_class = TOOLS.find { |t| t.definition[:function][:name] == tool_name }
+
+      raise ToolError, "Unknown tool '#{tool_name}'" unless tool_class
+
+      # 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.0"
+module RubyCode
+  VERSION = "0.1.2"
 end

data/lib/rubycode.rb

@@ -1,8 +1,29 @@
 # 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
-  # Your code goes here...
+# Rubycode is a Ruby-native AI coding agent with pluggable LLM adapters
+module RubyCode
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield(configuration)
+  end
+
+  def self.config
+    self.configuration ||= Configuration.new
+  end
 end