rubycode 0.1.2 → 0.1.3

data/lib/rubycode/client/display_formatter.rb

@@ -1,25 +1,28 @@
 # frozen_string_literal: true
 
 require "json"
+require "pastel"
 
 module RubyCode
   class Client
     # Handles formatting and display of tool information and results
     class DisplayFormatter
-      TOOL_ICONS = {
-        "bash" => ["💻", "command"],
-        "read" => ["📖", "file_path"],
-        "search" => ["🔍", "pattern"]
+      TOOL_LABELS = {
+        "bash" => ["[BASH]", "command"],
+        "read" => ["[READ]", "file_path"],
+        "search" => ["[SEARCH]", "pattern"],
+        "write" => ["[WRITE]", "file_path"],
+        "update" => ["[UPDATE]", "file_path"]
       }.freeze
 
       def initialize(config:)
         @config = config
+        @pastel = Pastel.new
       end
 
       def display_tool_info(tool_name, arguments)
         if @config.debug
-          puts "\n🔧 Tool: #{tool_name}"
-          puts "   Args: #{arguments.inspect}"
+          puts Views::Formatter::DebugToolInfo.build(tool_name: tool_name, arguments: arguments)
         else
           display_minimal_tool_info(tool_name, arguments)
         end
@@ -28,19 +31,36 @@ module RubyCode
       def display_result(result)
         return unless @config.debug
 
-        first_line = result.lines.first&.strip || "(empty)"
-        suffix = result.lines.count > 1 ? "... (#{result.lines.count} lines)" : ""
-        puts "   ✓ Result: #{first_line}#{suffix}"
+        puts Views::Formatter::ToolResult.build(result: result)
+      end
+
+      def display_info(message)
+        puts Views::Formatter::InfoMessage.build(message: message)
+      end
+
+      def display_skip_notification(_tool_name, detail)
+        puts @pastel.yellow("   ⓘ Skipped: #{detail}")
       end
 
       private
 
       def display_minimal_tool_info(tool_name, arguments)
-        return unless TOOL_ICONS.key?(tool_name)
+        return unless TOOL_LABELS.key?(tool_name)
 
-        icon, key = TOOL_ICONS[tool_name]
+        label, key = TOOL_LABELS[tool_name]
         value = extract_argument_value(arguments, key)
-        puts "   #{icon} #{value}" if value
+        return unless value
+
+        puts Views::Formatter::MinimalToolInfo.build(
+          label: label,
+          value: truncate_value(value, 60)
+        )
+      end
+
+      def truncate_value(value, max_length)
+        return value if value.length <= max_length
+
+        "#{value[0...(max_length - 3)]}..."
       end
 
       def extract_argument_value(arguments, key)

data/lib/rubycode/client/response_handler.rb

@@ -7,15 +7,16 @@ module RubyCode
       MAX_ITERATIONS = 25
       MAX_TOOL_CALLS = 50
 
-      def initialize(history:, config:)
-        @history = history
+      def initialize(memory:, config:)
+        @memory = memory
         @config = config
       end
 
       def handle_max_iterations(_iteration)
-        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)
+        puts Views::ResponseHandler::MaxIterations.build(max_iterations: MAX_ITERATIONS)
+
+        error_msg = I18n.t("rubycode.errors.max_iterations_reached")
+        @memory.add_message(role: "assistant", content: error_msg)
         error_msg
       end
 
@@ -25,27 +26,34 @@ module RubyCode
           return nil
         end
 
-        puts "\n✅ Agent finished (#{iteration} iterations, #{total_tool_calls} tool calls)\n" unless @config.debug
+        unless @config.debug
+          puts Views::ResponseHandler::CompleteMessage.build(iteration: iteration,
+                                                             total_tool_calls: total_tool_calls)
+        end
         content
       end
 
       def handle_max_tool_calls(content, _total_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)
+        puts Views::ResponseHandler::MaxToolCalls.build(max_tool_calls: MAX_TOOL_CALLS)
+
+        error_msg = I18n.t("rubycode.errors.max_tool_calls_reached")
+        @memory.add_message(role: "assistant", content: error_msg)
         content.empty? ? error_msg : content
       end
 
       def finalize_response(done_result, iteration, total_tool_calls)
-        puts "\n✅ Agent finished (#{iteration} iterations, #{total_tool_calls + 1} tool calls)\n" unless @config.debug
+        unless @config.debug
+          puts Views::ResponseHandler::AgentFinished.build(iteration: iteration,
+                                                           total_tool_calls: total_tool_calls + 1)
+        end
         done_result
       end
 
       private
 
       def inject_tool_reminder(iteration)
-        puts "   ⚠️  No tool calls - injecting reminder (iteration #{iteration})" unless @config.debug
-        @history.add_message(
+        puts Views::ResponseHandler::ToolInjectionWarning.build(iteration: iteration) unless @config.debug
+        @memory.add_message(
           role: "user",
           content: "You MUST call a tool. Do not respond with text. Call search, read, bash, or done tool now."
         )

data/lib/rubycode/client.rb

@@ -1,30 +1,36 @@
 # frozen_string_literal: true
 
+require "set"
+
 module RubyCode
   # Main client that provides the public API for the agent
   class Client
-    attr_reader :history
+    attr_reader :memory
 
-    def initialize
+    def initialize(tty_prompt: nil)
       @config = RubyCode.config
       @adapter = build_adapter
-      @history = History.new
+      @memory = Memory.new
+      @read_files = Set.new
+      @tty_prompt = tty_prompt
     end
 
     def ask(prompt:)
-      @history.add_message(role: "user", content: prompt)
+      @memory.add_message(role: "user", content: prompt)
       system_prompt = build_system_prompt
 
       AgentLoop.new(
         adapter: @adapter,
-        history: @history,
+        memory: @memory,
         config: @config,
-        system_prompt: system_prompt
+        system_prompt: system_prompt,
+        options: { read_files: @read_files, tty_prompt: @tty_prompt }
       ).run
     end
 
-    def clear_history
-      @history.clear
+    def clear_memory
+      @memory.clear
+      @read_files.clear
     end
 
     private
@@ -34,41 +40,24 @@ module RubyCode
       when :ollama
         Adapters::Ollama.new(@config)
       else
-        raise "Unknown Adapter"
+        raise I18n.t("rubycode.errors.unknown_adapter")
       end
     end
 
     def build_system_prompt
       context = ContextBuilder.new(root_path: @config.root_path).environment_context
+      instructions = load_system_prompt
 
-      <<~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
+      [
+        instructions,
+        "",
+        context
+      ].join("\n")
+    end
 
-        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
+    def load_system_prompt
+      prompt_path = File.join(__dir__, "..", "..", "config", "system_prompt.md")
+      File.read(prompt_path)
     end
   end
 end

data/lib/rubycode/configuration.rb

@@ -3,7 +3,8 @@
 module RubyCode
   # Configuration class for Rubycode settings
   class Configuration
-    attr_accessor :adapter, :url, :model, :root_path, :debug, :enable_tool_injection_workaround
+    attr_accessor :adapter, :url, :model, :root_path, :debug, :enable_tool_injection_workaround,
+                  :http_read_timeout, :http_open_timeout, :max_retries, :retry_base_delay
 
     def initialize
       @adapter = :ollama
@@ -16,6 +17,12 @@ module RubyCode
       # 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
+
+      # HTTP timeout and retry configuration
+      @http_read_timeout = 120 # 2 minutes for LLM inference
+      @http_open_timeout = 10  # 10 seconds for connection
+      @max_retries = 3         # Number of retries (4 total attempts)
+      @retry_base_delay = 2.0  # Base delay for exponential backoff
     end
   end
 end

data/lib/rubycode/database.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "sequel"
+require "fileutils"
+
+module RubyCode
+  # Database connection manager for all models
+  class Database
+    class << self
+      attr_accessor :db
+
+      def connect(db_path: nil)
+        path = db_path || default_db_path
+        @db = Sequel.sqlite(path)
+        run_migrations
+        @db
+      end
+
+      def disconnect
+        @db&.disconnect
+        @db = nil
+      end
+
+      def connection
+        @db || connect
+      end
+
+      private
+
+      def default_db_path
+        dir = File.join(Dir.home, ".rubycode")
+        FileUtils.mkdir_p(dir)
+        File.join(dir, "memory.db")
+      end
+
+      def run_migrations
+        create_messages_table
+      end
+
+      def create_messages_table
+        @db.create_table?(:messages) do
+          primary_key :id
+          String :role, null: false
+          String :content, null: false, text: true
+          DateTime :created_at, default: Sequel::CURRENT_TIMESTAMP
+        end
+      end
+    end
+  end
+end

data/lib/rubycode/errors.rb

@@ -18,4 +18,16 @@ module RubyCode
 
   # Raised when command execution fails
   class CommandExecutionError < ToolError; end
+
+  # Base class for all adapter-related errors
+  class AdapterError < Error; end
+
+  # Raised when adapter request times out
+  class AdapterTimeoutError < AdapterError; end
+
+  # Raised when adapter cannot connect to server
+  class AdapterConnectionError < AdapterError; end
+
+  # Raised when all retry attempts are exhausted
+  class AdapterRetryExhaustedError < AdapterError; end
 end

data/lib/rubycode/models/base.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RubyCode
+  module Models
+    # Base class for all models that use the database
+    class Base
+      class << self
+        # Expose Sequel dataset for direct querying
+        # Subclasses must implement table_name
+        def dataset
+          Database.connection[table_name]
+        end
+
+        # Delegate common Sequel methods to dataset
+        def where(*args)
+          dataset.where(*args)
+        end
+
+        def order(field, direction = :asc)
+          if direction == :desc
+            dataset.order(Sequel.desc(field))
+          else
+            dataset.order(field)
+          end
+        end
+
+        def latest(field = :id)
+          order(field, :desc)
+        end
+
+        def oldest(field = :id)
+          order(field, :asc)
+        end
+
+        def delete
+          dataset.delete
+        end
+
+        def all
+          dataset.all
+        end
+
+        def first
+          dataset.first
+        end
+
+        def last
+          dataset.order(:id).last
+        end
+
+        def count
+          dataset.count
+        end
+
+        # Subclasses must define their table name
+        def table_name
+          raise NotImplementedError, "Subclasses must define table_name"
+        end
+      end
+
+      private
+
+      def db
+        Database.connection
+      end
+    end
+  end
+end

data/lib/rubycode/models/memory.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RubyCode
+  # Manages conversation memory using shared database connection
+  class Memory < Models::Base
+    class << self
+      def table_name
+        :messages
+      end
+    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)
+        insert_message(message.role, message.content)
+      elsif role && content
+        insert_message(role, content)
+      else
+        raise ArgumentError, "Must provide either a Message object or role: and content: keyword arguments"
+      end
+    end
+
+    def messages
+      db[:messages].order(:id).map do |row|
+        Message.new(role: row[:role], content: row[:content])
+      end
+    end
+
+    def to_llm_format
+      messages.map(&:to_h)
+    end
+
+    def clear
+      db[:messages].delete
+    end
+
+    def last_user_message
+      row = self.class.latest.where(role: "user").first
+      return nil unless row
+
+      Message.new(role: row[:role], content: row[:content])
+    end
+
+    def last_assistant_message
+      row = self.class.latest.where(role: "assistant").first
+      return nil unless row
+
+      Message.new(role: row[:role], content: row[:content])
+    end
+
+    private
+
+    def insert_message(role, content)
+      db[:messages].insert(role: role, content: content)
+    end
+  end
+end

data/lib/rubycode/models.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "models/base"
+require_relative "models/memory"

data/lib/rubycode/tools/base.rb

@@ -4,7 +4,7 @@ require "json"
 
 module RubyCode
   module Tools
-    # Base class for all tools providing common functionality
+    # Base class for all tools that can be executed by the AI agent
     class Base
       attr_reader :context
 
@@ -12,25 +12,20 @@ module RubyCode
         @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")
@@ -42,12 +37,10 @@ module RubyCode
 
       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)
 
@@ -59,7 +52,6 @@ module RubyCode
         end
       end
 
-      # Wraps string results in ToolResult, passes through ToolResult and CommandResult
       def wrap_result(result)
         case result
         when ToolResult, CommandResult
@@ -71,7 +63,6 @@ module RubyCode
         end
       end
 
-      # Helper to get root path from context
       def root_path
         context[:root_path]
       end

data/lib/rubycode/tools/bash.rb

@@ -5,9 +5,8 @@ require "shellwords"
 
 module RubyCode
   module Tools
-    # Tool for executing safe bash commands
+    # Tool for executing bash commands with safety checks and approval workflow
     class Bash < Base
-      # Whitelist of safe commands
       SAFE_COMMANDS = %w[
         ls
         pwd
@@ -30,15 +29,19 @@ module RubyCode
         command = params["command"].strip
         base_command = command.split.first
 
-        raise UnsafeCommandError, safe_command_error(base_command) unless SAFE_COMMANDS.include?(base_command)
+        unless SAFE_COMMANDS.include?(base_command)
+          approval_handler = context[:approval_handler]
+          unless approval_handler.request_bash_approval(command, base_command, SAFE_COMMANDS)
+            message = I18n.t("rubycode.errors.user_cancelled_bash",
+                             command: base_command,
+                             safe_commands: SAFE_COMMANDS.join(", "))
+            raise ToolError, message
+          end
+        end
 
         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`

data/lib/rubycode/tools/read.rb

@@ -16,6 +16,9 @@ module RubyCode
 
         return list_directory(full_path, file_path) if File.directory?(full_path)
 
+        # Track that this file was read
+        context[:read_files]&.add(full_path)
+
         format_file_lines(full_path, offset, limit)
       end
 

data/lib/rubycode/tools/update.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RubyCode
+  module Tools
+    # Tool for updating existing files
+    class Update < Base
+      private
+
+      def perform(params)
+        file_path = params["file_path"]
+        old_string = params["old_string"]
+        new_string = params["new_string"]
+
+        full_path = resolve_path(file_path)
+        validate_file_exists(file_path, full_path)
+        auto_read_file_if_needed(full_path)
+
+        content = File.read(full_path)
+        validate_string_match(content, old_string)
+        validate_uniqueness(content, old_string)
+        request_approval(file_path, old_string, new_string)
+
+        update_file(full_path, content, old_string, new_string)
+        build_result(file_path, old_string, new_string)
+      end
+
+      def validate_file_exists(file_path, full_path)
+        raise FileNotFoundError, I18n.t("rubycode.errors.file_not_found", path: file_path) unless File.exist?(full_path)
+      end
+
+      def auto_read_file_if_needed(full_path)
+        read_files = context[:read_files]
+        return if read_files&.include?(full_path)
+
+        context[:display_formatter].display_info("Auto-reading file before update...")
+        read_files&.add(full_path)
+      end
+
+      def validate_string_match(content, old_string)
+        return if content.include?(old_string)
+
+        raise ToolError, I18n.t("rubycode.errors.string_not_found", string: old_string[0..100])
+      end
+
+      def validate_uniqueness(content, old_string)
+        occurrences = content.scan(old_string).count
+        return if occurrences == 1
+
+        raise ToolError, I18n.t("rubycode.errors.string_not_unique", count: occurrences)
+      end
+
+      def request_approval(file_path, old_string, new_string)
+        approval_handler = context[:approval_handler]
+        return if approval_handler.request_update_approval(file_path, old_string, new_string)
+
+        raise ToolError, I18n.t("rubycode.errors.user_cancelled_update")
+      end
+
+      def update_file(full_path, content, old_string, new_string)
+        new_content = content.sub(old_string, new_string)
+        File.write(full_path, new_content)
+      end
+
+      def build_result(file_path, old_string, new_string)
+        ToolResult.new(
+          content: "Updated '#{file_path}' (replaced #{old_string.lines.count} lines)",
+          metadata: {
+            file_path: file_path,
+            old_lines: old_string.lines.count,
+            new_lines: new_string.lines.count
+          }
+        )
+      end
+
+      def resolve_path(file_path)
+        File.absolute_path?(file_path) ? file_path : File.join(root_path, file_path)
+      end
+    end
+  end
+end