rubycode 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3de3303b47050cfd2d290e35fcbf834e57c5eeb53d85a6b697e0cd554a5b05c0
-  data.tar.gz: 3a60d16a0f7fc111e6ccf305b1d4d0427f8b9b42296e79455f9b3caae06ce2ee
+  metadata.gz: b77afd8d1e1731bea1936ffad3ed3e572ce8d14088ebb8fd49570b11c1c7b0b5
+  data.tar.gz: 2c5abe4b384a4f1f0ef5a26ee4c173eb41124235cd3337147d3fc04a291043b5
 SHA512:
-  metadata.gz: ca04ec8192747e4e97cef35c2a8ec6440e82b65a412e7c13a979f84a5d58de92c615e90e58cebe28b8761ae05d462f4a5e9a38bdeb0388005234b76bb02edc67
-  data.tar.gz: 84066bb9aa138c598eedad4a48472448d253f0eaeb1551ed1041a2bb4a3fc0087cabbc4c46dffeaf14ff83c1570096ff88db3c439537debbaea0f710eb01414c
+  metadata.gz: 7400478e459c00e8e6ce7889f4eb58667cbe203a30fe4bd64568b122b1d323acb7f08dea92be7b725e4c41547d420fb81c9520071b1c89be3b1a3b6048c4fd1f
+  data.tar.gz: a6559e94215bf89b6c6cc0ed8a065dce7bae23232e7d3bd7c203ea274644a045a8e003c8e922772575c86f1ea86e0ce56b6fdaed0603535d958c15cd3d35a464

data/.rubocop.yml

@@ -8,6 +8,10 @@ Style/StringLiterals:
 Style/StringLiteralsInInterpolation:
   EnforcedStyle: double_quotes
 
+Style/OneClassPerFile:
+  Exclude:
+    - "test/**/*"
+
 # Metrics - reasonable limits for maintainability
 Metrics/ClassLength:
   Max: 200

data/README.md

@@ -7,16 +7,27 @@ A Ruby-native AI coding assistant with pluggable LLM adapters. RubyCode provides
 
 **GitHub Repository**: [github.com/jonasmedeiros/rubycode](https://github.com/jonasmedeiros/rubycode)
 
+## Demo
+
+![RubyCode in action](docs/images/demo.png)
+
+*RubyCode autonomously exploring a Rails codebase, finding the right file, and suggesting code changes.*
+
 ## Features
 
 - **AI Agent Loop**: Autonomous task execution with tool calling
-- **Pluggable LLM Adapters**: Currently supports Ollama, easily extendable to other LLMs
+- **Pluggable LLM Adapters**: Currently supports Ollama with configurable timeouts and retry logic
 - **Built-in Tools**:
   - `bash`: Execute safe bash commands for filesystem exploration
   - `search`: Search file contents using grep with regex support
   - `read`: Read files and directories with line numbers
+  - `write`: Create new files with user approval
+  - `update`: Edit existing files with user approval
   - `done`: Signal task completion with final answer
-- **Conversation History**: Maintains context across interactions
+- **Persistent Memory**: SQLite-backed conversation history with Sequel ORM
+- **Enhanced CLI**: TTY-based interface with formatted output, progress indicators, and approval workflows
+- **Resilient Network**: Automatic retry with exponential backoff for LLM requests
+- **I18n Support**: Internationalized error messages and UI text
 - **Environment Context**: Automatically provides Ruby version, platform, and working directory info
 
 ## Installation
@@ -71,12 +82,18 @@ RubyCode.configure do |config|
   config.root_path = Dir.pwd                  # Project root directory
   config.debug = false                        # Enable debug output
   config.enable_tool_injection_workaround = true  # Force tool usage (enabled by default)
+
+  # HTTP timeout and retry settings (new in 0.1.3)
+  config.http_read_timeout = 120              # Request timeout in seconds (default: 120)
+  config.http_open_timeout = 10               # Connection timeout in seconds (default: 10)
+  config.max_retries = 3                      # Number of retry attempts (default: 3)
+  config.retry_base_delay = 2.0               # Exponential backoff base delay (default: 2.0)
 end
 ```
 
 ### Available Tools
 
-The agent has access to four built-in tools:
+The agent has access to six built-in tools:
 
 1. **bash**: Execute safe bash commands including:
    - Directory exploration: `ls`, `pwd`, `find`, `tree`
@@ -85,10 +102,22 @@ The agent has access to four built-in tools:
    - Examples: `grep -rn "button" app/views`, `find . -name "*.rb"`
 2. **search**: Simplified search wrapper (use bash + grep for more control)
 3. **read**: Read files with line numbers or list directory contents
-4. **done**: Signal completion and provide the final answer
+4. **write**: Create new files (requires user approval)
+5. **update**: Edit existing files with exact string replacement (requires user approval)
+6. **done**: Signal completion and provide the final answer
 
 **Note**: Tool schemas are externalized in `config/tools/*.json` for easy customization.
 
+### New in 0.1.3
+
+- **Persistent Memory**: Conversation history now stored in SQLite database using Sequel ORM
+- **Write & Update Tools**: Create and modify files with user approval workflow
+- **Network Resilience**: Automatic retry with exponential backoff for failed LLM requests
+- **Enhanced CLI**: Improved UI with TTY toolkit, formatted output, and progress indicators
+- **I18n Support**: Internationalized error messages and system prompts
+- **Improved Architecture**: Separated database connection management, view classes for all UI components
+- **Cross-platform Support**: Added Linux platform support for CI/CD environments
+
 ## Development
 
 After checking out the repo, run `bundle install` to install dependencies.

data/config/locales/en.yml

@@ -0,0 +1,87 @@
+en:
+  rubycode:
+    cli:
+      ready: "Ready! You can now ask questions or request code changes."
+      exit: "Goodbye!"
+      memory_cleared: "Memory cleared"
+      interrupted: "Operation cancelled by user"
+
+    welcome:
+      title: "RubyCode v%{version}"
+      subtitle: "AI Ruby/Rails Code Assistant"
+      built_with: "Built with: %{stack}"
+      stack: "Ollama + DeepSeek + TTY Toolkit"
+      commands: "Commands: exit, quit, clear"
+
+    approval:
+      bash:
+        title: "Bash Command - Approval Required"
+        command: "Command"
+        base_command: "Base Command"
+        safe_commands: "Safe Commands (no approval needed)"
+        prompt: "Execute this command?"
+
+      write:
+        title: "Write Operation - Approval Required"
+        file: "File"
+        lines: "Lines"
+        prompt: "Create this file?"
+        truncated: "... (%{count} more lines)"
+
+      update:
+        title: "Update Operation - Approval Required"
+        file: "File"
+        remove_label: "- REMOVE:"
+        add_label: "+ ADD:"
+        prompt: "Apply this update?"
+
+      skip:
+        message: "Skipping approval (auto-approve enabled)"
+
+    response_handler:
+      max_iterations:
+        title: "⚠ WARNING"
+        message: "Reached maximum iterations (%{max})\nThe agent may be stuck in a loop."
+
+      max_tool_calls:
+        title: "⚠ WARNING"
+        message: "Reached maximum tool calls (%{max})\nStopping to prevent excessive operations."
+
+      complete:
+        title: "✓ SUCCESS"
+        message: "Task completed\n%{iterations} iterations, %{tool_calls} tool calls"
+
+      agent_finished:
+        title: "✓ SUCCESS"
+        message: "Agent finished\n%{iterations} iterations, %{tool_calls} tool calls"
+
+      tool_injection_warning: "No tool calls - injecting reminder (iteration %{iteration})"
+
+    agent_loop:
+      thinking: "Thinking..."
+      response_received: "Response received"
+      iteration: "Iteration %{number}"
+      tool_error: "Tool error: %{error}"
+
+    formatter:
+      tool_result: "Result"
+      info_prefix: "ℹ"
+      debug_prefix: "[DEBUG]"
+      error_prefix: "[ERROR]"
+
+    errors:
+      unknown_adapter: "Unknown Adapter"
+      file_not_found: "File '%{path}' not found"
+      file_exists: "File '%{path}' already exists. Use 'update' tool to modify it."
+      string_not_found: "String not found in file. Searched for:\n%{string}"
+      string_not_unique: "String appears %{count} times. Must be unique for safe replacement."
+      command_failed: "Command failed with exit code %{code}:\n%{output}"
+      user_cancelled_bash: "USER CANCELLED: The user declined to execute '%{command}'. Do not retry this command. Either use a whitelisted command (%{safe_commands}) or call 'done' to finish."
+      user_cancelled_update: "USER CANCELLED: The user declined this change. Do not retry this exact update. Either move to the next change or call 'done' to finish."
+      user_cancelled_write: "USER CANCELLED: The user declined to create this file. Do not retry this operation. Ask the user if they want to make a different change or call 'done' to finish."
+      max_iterations_reached: "Reached maximum iterations"
+      max_tool_calls_reached: "Reached maximum tool calls"
+      adapter_timeout: "LLM request timed out after %{timeout}s"
+      adapter_connection: "Cannot connect to LLM at %{url}: %{error}"
+      adapter_retry: "Request failed: %{error}. Retrying in %{delay}s... (attempt %{attempt}/%{max_retries})"
+      adapter_failed: "LLM adapter failed: %{error}"

data/config/system_prompt.md

@@ -0,0 +1,54 @@
+# Ruby on Rails Coding Assistant
+
+You are a helpful Ruby on Rails coding assistant.
+
+## CRITICAL RULE
+
+You MUST call a tool in EVERY response. You MUST NEVER respond with just text.
+
+## Available tools
+
+- **bash**: run commands (whitelisted commands run directly, others require user approval)
+  - Whitelisted: ls, pwd, find, tree, cat, head, tail, wc, file, which, echo, grep, rg
+- **search**: simplified search (use bash + grep for more control)
+- **read**: view file contents with line numbers
+- **write**: create new files (requires approval, errors if file exists)
+- **update**: modify existing files (auto-reads if needed, requires approval)
+- **done**: MUST call when task is complete (see below)
+
+## 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. Make changes with write/update if needed
+5. IMMEDIATELY call done when finished - do not continue exploring
+
+## CRITICAL: When to call 'done'
+
+You MUST call 'done' immediately after:
+- Completing file changes (write/update operations succeeded)
+- Answering a user's question
+- Finding the information the user requested
+- Unable to proceed (errors, file not found, etc.)
+
+Do NOT keep exploring after the task is done. Call 'done' right away.
+
+## CRITICAL: Handling user cancellations
+
+If you see "USER CANCELLED" in an error message:
+- The user explicitly declined that specific operation
+- Do NOT retry the exact same operation - the user has rejected it
+- Move on to other changes, or call 'done' if there's nothing else to do
+- Never get stuck in a loop retrying cancelled operations
+
+## 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
+
+## Final reminder
+
+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/config/tools/done.json

@@ -2,13 +2,13 @@
   "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.",
+    "description": "CRITICAL: Call this tool when you have completed the user's request and are ready to finish.\n\nYou MUST call 'done' after:\n- Successfully making code changes (write/update operations)\n- Answering a question or providing information\n- Completing any task the user requested\n- Unable to proceed further\n\nDo NOT continue calling other tools after the task is complete - call 'done' immediately.\n\nThe 'answer' parameter should contain:\n- For code changes: Summary of what was changed and where\n- For questions: Direct answer to the user's question\n- For searches: What you found and relevant file locations",
     "parameters": {
       "type": "object",
       "properties": {
         "answer": {
           "type": "string",
-          "description": "Your final answer showing the file, line number, current code, and suggested change"
+          "description": "Your final response to the user summarizing what was accomplished or found"
         }
       },
       "required": ["answer"]

data/config/tools/update.json

@@ -0,0 +1,25 @@
+{
+  "type": "function",
+  "function": {
+    "name": "update",
+    "description": "Update existing file by replacing old_string with new_string. Auto-reads file if not already read.\n\n- Use this to modify existing files only\n- Will error if file doesn't exist (use 'write' tool instead)\n- Automatically reads file if not already read in this conversation\n- Requires exact unique string match for safe replacement\n- Requires user approval before updating\n- Shows colored diff (red for removed, green for added) before applying\n- old_string must appear exactly once in the file",
+    "parameters": {
+      "type": "object",
+      "properties": {
+        "file_path": {
+          "type": "string",
+          "description": "Path to file to update (relative or absolute)"
+        },
+        "old_string": {
+          "type": "string",
+          "description": "Exact string to replace (including whitespace)"
+        },
+        "new_string": {
+          "type": "string",
+          "description": "Replacement string"
+        }
+      },
+      "required": ["file_path", "old_string", "new_string"]
+    }
+  }
+}

data/config/tools/write.json

@@ -0,0 +1,21 @@
+{
+  "type": "function",
+  "function": {
+    "name": "write",
+    "description": "Create a new file with content. File must not exist. Use 'update' for existing files.\n\n- Use this to create brand new files only\n- Will error if file already exists (use 'update' tool instead)\n- Requires user approval before writing\n- Shows preview of content before creating file\n- Automatically creates parent directories if needed",
+    "parameters": {
+      "type": "object",
+      "properties": {
+        "file_path": {
+          "type": "string",
+          "description": "Path to new file (relative or absolute)"
+        },
+        "content": {
+          "type": "string",
+          "description": "Complete file content to write"
+        }
+      },
+      "required": ["file_path", "content"]
+    }
+  }
+}

data/lib/rubycode/adapters/ollama.rb

@@ -14,7 +14,7 @@ module RubyCode
 
         debug_request(uri, payload) if @config.debug
 
-        body = send_request(uri, request)
+        body = send_request_with_retry(uri, request)
 
         debug_response(body) if @config.debug
 
@@ -23,6 +23,33 @@ module RubyCode
 
       private
 
+      def send_request_with_retry(uri, request)
+        attempt = 0
+
+        begin
+          attempt += 1
+          send_request(uri, request)
+        rescue AdapterTimeoutError, AdapterConnectionError => e
+          unless attempt <= @config.max_retries
+            raise AdapterRetryExhaustedError, "Failed after #{@config.max_retries} retries: #{e.message}"
+          end
+
+          delay = @config.retry_base_delay * (2**(attempt - 1))
+          display_retry_status(attempt, @config.max_retries, delay, e)
+          sleep(delay)
+          retry
+        end
+      end
+
+      def display_retry_status(attempt, max_retries, delay, error)
+        puts Views::AgentLoop::RetryStatus.build(
+          attempt: attempt,
+          max_retries: max_retries,
+          delay: delay,
+          error: error.message
+        )
+      end
+
       def build_payload(messages, system, tools)
         payload = { model: @config.model, messages: messages, stream: false }
         payload[:system] = system if system
@@ -38,8 +65,54 @@ module RubyCode
       end
 
       def send_request(uri, request)
-        response = Net::HTTP.start(uri.hostname, uri.port) { |http| http.request(request) }
-        JSON.parse(response.body)
+        response = perform_http_request(uri, request)
+        handle_response(response)
+      rescue Net::ReadTimeout, Net::OpenTimeout, Errno::ECONNREFUSED, Errno::ETIMEDOUT, SocketError => e
+        handle_network_error(e, uri)
+      rescue JSON::ParserError => e
+        raise AdapterError, "Invalid JSON response from server: #{e.message}"
+      rescue StandardError => e
+        raise AdapterError, "Unexpected error: #{e.message}"
+      end
+
+      def perform_http_request(uri, request)
+        Net::HTTP.start(
+          uri.hostname,
+          uri.port,
+          read_timeout: @config.http_read_timeout,
+          open_timeout: @config.http_open_timeout
+        ) { |http| http.request(request) }
+      end
+
+      def handle_network_error(error, uri)
+        case error
+        when Net::ReadTimeout
+          raise AdapterTimeoutError, "Request timed out after #{@config.http_read_timeout}s: #{error.message}"
+        when Net::OpenTimeout
+          raise AdapterTimeoutError, "Connection timed out after #{@config.http_open_timeout}s: #{error.message}"
+        when Errno::ECONNREFUSED
+          raise AdapterConnectionError, "Connection refused to #{uri}: #{error.message}"
+        when Errno::ETIMEDOUT
+          raise AdapterConnectionError, "Connection timed out to #{uri}: #{error.message}"
+        when SocketError
+          raise AdapterConnectionError, "Cannot resolve host #{uri.hostname}: #{error.message}"
+        end
+      end
+
+      def handle_response(response)
+        body = JSON.parse(response.body)
+
+        # Check for HTTP errors
+        case response.code.to_i
+        when 200..299
+          body
+        when 500..599
+          # Server errors are retriable
+          raise AdapterConnectionError, "Server error (#{response.code}): #{response.message}"
+        else
+          # Client errors are not retriable
+          raise AdapterError, "HTTP error (#{response.code}): #{response.message}"
+        end
       end
 
       def debug_request(uri, payload)

data/lib/rubycode/agent_loop.rb

@@ -2,6 +2,7 @@
 
 require_relative "client/response_handler"
 require_relative "client/display_formatter"
+require_relative "client/approval_handler"
 
 module RubyCode
   # Manages the agent loop - iterates until task completion or limits reached
@@ -9,13 +10,16 @@ module RubyCode
     MAX_ITERATIONS = 25
     MAX_TOOL_CALLS = 50
 
-    def initialize(adapter:, history:, config:, system_prompt:)
+    def initialize(adapter:, memory:, config:, system_prompt:, options: {})
       @adapter = adapter
-      @history = history
+      @memory = memory
       @config = config
       @system_prompt = system_prompt
-      @response_handler = Client::ResponseHandler.new(history: @history, config: @config)
+      @read_files = options[:read_files]
+      @tty_prompt = options[:tty_prompt]
+      @response_handler = Client::ResponseHandler.new(memory: @memory, config: @config)
       @display_formatter = Client::DisplayFormatter.new(config: @config)
+      @approval_handler = Client::ApprovalHandler.new(tty_prompt: @tty_prompt, config: @config)
     end
 
     def run
@@ -47,23 +51,36 @@ module RubyCode
     private
 
     def llm_response
-      messages = @history.to_llm_format
+      puts Views::AgentLoop::ThinkingStatus.build unless @config.debug
+
+      messages = @memory.to_llm_format
       response_body = @adapter.generate(
         messages: messages,
         system: @system_prompt,
         tools: Tools.definitions
       )
 
+      puts Views::AgentLoop::ResponseReceived.build unless @config.debug
+
       assistant_message = response_body["message"]
       content = assistant_message["content"] || ""
       tool_calls = assistant_message["tool_calls"] || []
 
-      @history.add_message(role: "assistant", content: content)
+      @memory.add_message(role: "assistant", content: content)
       [content, tool_calls]
+    rescue AdapterError => e
+      handle_adapter_error(e)
+      [nil, []] # Return empty to continue loop
+    end
+
+    def handle_adapter_error(error)
+      error_msg = I18n.t("rubycode.errors.adapter_failed", error: error.message)
+      puts Views::AgentLoop::AdapterError.build(message: error_msg)
+      @memory.add_message(role: "user", content: error_msg)
     end
 
     def execute_tool_calls(tool_calls, iteration)
-      puts "\n🤖 Iteration #{iteration}: Calling #{tool_calls.length} tool(s)..." unless @config.debug
+      puts Views::AgentLoop::IterationHeader.build(iteration: iteration, tool_calls: tool_calls) unless @config.debug
 
       done_result = nil
       tool_calls.each do |tool_call|
@@ -74,6 +91,8 @@ module RubyCode
           break
         end
       end
+
+      puts Views::AgentLoop::IterationFooter.build unless @config.debug
       done_result
     end
 
@@ -90,7 +109,7 @@ module RubyCode
       return nil unless result
 
       @display_formatter.display_result(result)
-      add_tool_result_to_history(tool_name, result)
+      add_tool_result_to_memory(tool_name, result)
       result
     rescue ToolError, StandardError => e
       # Handle all errors - add to history and continue
@@ -101,13 +120,19 @@ module RubyCode
       arguments.is_a?(Hash) ? arguments : JSON.parse(arguments)
     rescue JSON::ParserError => e
       error_msg = "Error parsing tool arguments: #{e.message}"
-      puts "   ✗ #{error_msg}"
-      @history.add_message(role: "user", content: error_msg)
+      puts Views::AgentLoop::ToolError.build(message: error_msg)
+      @memory.add_message(role: "user", content: error_msg)
       nil
     end
 
     def run_tool(tool_name, params)
-      context = { root_path: @config.root_path }
+      context = {
+        root_path: @config.root_path,
+        read_files: @read_files,
+        tty_prompt: @tty_prompt,
+        approval_handler: @approval_handler,
+        display_formatter: @display_formatter
+      }
       Tools.execute(tool_name: tool_name, params: params, context: context)
     rescue ToolError => e
       # Re-raise tool errors to be caught by execute_tool
@@ -115,19 +140,19 @@ module RubyCode
     rescue StandardError => e
       # Wrap unexpected errors
       error_msg = "Error executing tool: #{e.message}"
-      puts "   ✗ #{error_msg}"
-      @history.add_message(role: "user", content: error_msg)
+      puts Views::AgentLoop::ToolError.build(message: error_msg)
+      @memory.add_message(role: "user", content: error_msg)
       nil
     end
 
-    def add_tool_result_to_history(tool_name, result)
-      @history.add_message(role: "user", content: "Tool '#{tool_name}' result:\n#{result}")
+    def add_tool_result_to_memory(tool_name, result)
+      @memory.add_message(role: "user", content: "Tool '#{tool_name}' result:\n#{result}")
     end
 
     def handle_tool_error(error)
       error_msg = "Error: #{error.message}"
-      puts "   ✗ #{error_msg}"
-      @history.add_message(role: "user", content: error_msg)
+      puts Views::AgentLoop::ToolError.build(message: error_msg)
+      @memory.add_message(role: "user", content: error_msg)
       nil
     end
   end

data/lib/rubycode/client/approval_handler.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RubyCode
+  class Client
+    # Handles user approval prompts for tools
+    class ApprovalHandler
+      def initialize(tty_prompt:, config:)
+        @prompt = tty_prompt
+        @config = config
+      end
+
+      def request_bash_approval(command, base_command, safe_commands)
+        display = Views::BashApproval.build(
+          command: command,
+          base_command: base_command,
+          safe_commands: safe_commands
+        )
+        puts display
+
+        approved = request_approval("Execute this command?")
+
+        puts Views::SkipNotification.build(message: "User declined to execute '#{base_command}'") unless approved
+
+        approved
+      end
+
+      def request_write_approval(file_path, content)
+        display = Views::WriteApproval.build(
+          file_path: file_path,
+          content: content
+        )
+        puts display
+
+        approved = request_approval("Create this file?")
+
+        puts Views::SkipNotification.build(message: "User declined to create #{file_path}") unless approved
+
+        approved
+      end
+
+      def request_update_approval(file_path, old_string, new_string)
+        display = Views::UpdateApproval.build(
+          file_path: file_path,
+          old_string: old_string,
+          new_string: new_string
+        )
+        puts display
+
+        approved = request_approval("Apply this update?")
+
+        puts Views::SkipNotification.build(message: "User declined to update #{file_path}") unless approved
+
+        approved
+      end
+
+      private
+
+      def request_approval(question)
+        # Flush output to ensure prompt is visible
+        $stdout.flush
+
+        # Always create a fresh prompt instance to ensure stdin is available
+        prompt = TTY::Prompt.new(input: $stdin, output: $stdout, interrupt: :exit)
+        prompt.yes?(question) do |q|
+          q.default false
+        end
+      end
+    end
+  end
+end