rubycode 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ebef8daeefbc9617af948b51c30e6884d661c5522876bb59e6c49767d0339878
-  data.tar.gz: cbb374c17da942ba865c2e352c0efee5444321f7d23a43ff99722db4065ca464
+  metadata.gz: 8da87e3aaf4fd3001f396d9394df720eff277f65a2074ab639f5ca881490fb5f
+  data.tar.gz: b5ef26c288070a2b9a2a01914765b95e9778b71473a118e6d0cc7ec9084afafd
 SHA512:
-  metadata.gz: db0237c601c7beacd7482cb03cb2f001ed59381a19813a419d4377a0cc354f6554b05d6bc5f215cbbb2ad8337d165dccc01b4d94b2732a45d09b23bf960d5fc8
-  data.tar.gz: 4134769796321d582bea29d5fc3cb1a3879fa8b05fc7b04b7486615a50c8c01ad1699164371e42aa942ac30f2cbe7712c5c6b88de29e090a962dd0bbb586fbb4
+  metadata.gz: 24f9e8016eb87418822608cfd72cdc158c45c3712767b6b18da41b4be52fa58bf49f402e4e0b9c3a5d761a0625eec0e90fb41301c340e51987201d467d4b51fb
+  data.tar.gz: 607b13e698d45693ef2041aa89095c91c9286e1939bbb800f823e1e1c64e9d2c8e538ddde11e9f41cbec56447ab12585ff2df5c0b0bc3df236ec0ce35654614c

data/USAGE.md

@@ -0,0 +1,93 @@
+# RubyCode - Interactive AI Code Assistant
+
+An OpenCode-inspired AI agent for Ruby/Rails development that can autonomously explore codebases and suggest changes.
+
+## Quick Start
+
+```bash
+ruby rubycode_cli.rb
+```
+
+You'll be prompted for:
+1. **Directory**: Path to your Rails project (default: current directory)
+2. **Debug mode**: Enable to see JSON requests/responses (default: no)
+
+## Example Usage
+
+```
+💬 You: Change the button color to red
+
+🤖 Agent:
+   💻 ls -la
+   🔍 button
+   📖 app/assets/stylesheets/buttons.css
+
+I found the button styling in `app/assets/stylesheets/buttons.css:15`
+
+To change the button color to red, modify line 15:
+
+```css
+/* Change this: */
+background-color: blue;
+
+/* To this: */
+background-color: red;
+```
+```
+
+## Available Commands
+
+- **Regular prompts**: Ask questions or request code changes
+- **`clear`**: Clear conversation history
+- **`exit`** or **`quit`**: Exit the CLI
+
+## How It Works
+
+The agent has access to three safe tools:
+
+1. **bash**: Execute read-only commands (ls, find, cat, etc.)
+2. **read**: Read file contents with line numbers
+3. **search**: Search for patterns using grep
+
+The agent autonomously decides which tools to use to:
+- Understand your codebase
+- Find relevant files
+- Suggest specific code changes
+
+## Features
+
+✅ **Safe**: Only read-only operations, no destructive commands
+✅ **Autonomous**: Agent explores codebase on its own
+✅ **Transparent**: See what the agent is doing (enable debug mode)
+✅ **Rails-aware**: Optimized for Ruby on Rails projects
+✅ **Conversational**: Maintains history across multiple questions
+
+## Architecture
+
+Built following OpenCode's design:
+- **Tools**: Controlled, safe operations with validation
+- **Agent Loop**: LLM calls tools, we execute, loop until done
+- **History**: Maintains conversation context
+- **JSON Visibility**: Full transparency in debug mode
+
+## Workaround for Weak Tool-Calling Models
+
+If you're testing with models that have poor tool-calling capabilities (like qwen3-coder), enable the injection workaround:
+
+```ruby
+Rubycode.configure do |config|
+  config.enable_tool_injection_workaround = true
+end
+```
+
+**What this does:**
+- When the model generates text instead of calling a tool, it injects a reminder message
+- Forces the model to keep calling tools until it finds the answer
+- **OpenCode does NOT use this** - they rely on strong tool-calling models (Claude, GPT-4)
+- This is ONLY for testing/development with weaker models
+
+**When to disable:**
+- When using Claude (Anthropic)
+- When using GPT-4 (OpenAI)  
+- When using Gemini (Google)
+- In production

data/lib/rubycode/adapters/base.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Rubycode
+  module Adapters
+    class Base
+      def initialize(config)
+        @config = config
+      end
+
+      def generate(prompt:)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/rubycode/adapters/ollama.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+
+module Rubycode
+  module Adapters
+    class Ollama < Base
+      def generate(messages:, system: nil, tools: nil)
+        uri = URI("#{@config.url}/api/chat")
+
+        request = Net::HTTP::Post.new(uri)
+        request["Content-Type"] = "application/json"
+
+        payload = {
+          model: @config.model,
+          messages: messages,
+          stream: false
+        }
+        payload[:system] = system if system
+        payload[:tools] = tools if tools
+
+        request.body = payload.to_json
+
+        # DEBUG: Show request if debug mode enabled
+        if @config.debug
+          puts "\n" + "=" * 80
+          puts "📤 REQUEST TO LLM"
+          puts "=" * 80
+          puts "URL: #{uri}"
+          puts "Model: #{@config.model}"
+          puts "\nPayload:"
+          puts JSON.pretty_generate(payload)
+          puts "=" * 80
+        end
+
+        response = Net::HTTP.start(uri.hostname, uri.port) do |http|
+          http.request(request)
+        end
+
+        body = JSON.parse(response.body)
+
+        # DEBUG: Show response if debug mode enabled
+        if @config.debug
+          puts "\n" + "=" * 80
+          puts "📥 RESPONSE FROM LLM"
+          puts "=" * 80
+          puts JSON.pretty_generate(body)
+          puts "=" * 80 + "\n"
+        end
+
+        # /api/chat always returns this structure:
+        # { "message": { "role": "assistant", "content": "...", "tool_calls": [...] } }
+        body
+      end
+    end
+  end
+end

data/lib/rubycode/client.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+module Rubycode
+  class Client
+    attr_reader :history
+
+    def initialize
+      @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
+    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
+        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.strip
+        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: explore directories (ls, find)
+        - search: find text inside files (supports case_insensitive parameter)
+        - 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
+
+        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,22 @@
+# frozen_string_literal: true
+
+module Rubycode
+  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"
+      @root_path = Dir.pwd
+      @debug = false  # Set to true to see JSON requests/responses
+
+      # WORKAROUND for weak tool-calling models (qwen3-coder, etc.)
+      # 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
+    end
+  end
+end

data/lib/rubycode/context_builder.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Rubycode
+  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/history.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Rubycode
+  class History
+    def initialize
+      @messages = []
+    end
+
+    def add_message(role:, content:)
+      @messages << {
+        role: role,
+        content: content,
+        timestamp: Time.now
+      }
+    end
+
+    def to_llm_format
+      @messages.map { |msg| { role: msg[:role], content: msg[:content] } }
+    end
+
+    def clear
+      @messages = []
+    end
+
+    def messages
+      @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/bash.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "shellwords"
+
+module Rubycode
+  module Tools
+    class Bash
+      # Whitelist of safe commands
+      SAFE_COMMANDS = %w[
+        ls
+        pwd
+        find
+        tree
+        cat
+        head
+        tail
+        wc
+        file
+        which
+        echo
+      ].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
+
+      def self.execute(params:, context:)
+        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
+
+        # Execute in the project's root directory
+        Dir.chdir(context[:root_path]) do
+          output = `#{command} 2>&1`
+          exit_code = $?.exitstatus
+
+          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
+        end
+      rescue => e
+        "Error executing command: #{e.message}"
+      end
+    end
+  end
+end

data/lib/rubycode/tools/done.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+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
+
+      def self.execute(params:, context:)
+        # Just return the answer - this is the final response
+        params["answer"]
+      end
+    end
+  end
+end

data/lib/rubycode/tools/read.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+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
+
+      def self.execute(params:, context:)
+        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
+
+        unless File.exist?(full_path)
+          return "Error: File '#{file_path}' does not exist"
+        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
+
+        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
+
+        result.join("\n")
+      rescue => e
+        "Error reading file: #{e.message}"
+      end
+    end
+  end
+end

data/lib/rubycode/tools/search.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "shellwords"
+
+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
+
+      def self.execute(params:, context:)
+        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
+
+        unless File.exist?(full_path)
+          return "Error: Path '#{path}' does not exist"
+        end
+
+        # 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)
+
+        command = cmd_parts.join(" ")
+
+        output = `#{command} 2>&1`
+        exit_code = $?.exitstatus
+
+        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
+          "No matches found for pattern: #{pattern}"
+        else
+          # Error occurred
+          "Error running search: #{output}"
+        end
+      rescue => e
+        "Error: #{e.message}"
+      end
+    end
+  end
+end

data/lib/rubycode/tools.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "tools/bash"
+require_relative "tools/read"
+require_relative "tools/search"
+require_relative "tools/done"
+
+module Rubycode
+  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 }
+
+      unless tool_class
+        return "Error: Unknown tool '#{tool_name}'"
+      end
+
+      tool_class.execute(params: params, context: context)
+    end
+  end
+end

data/lib/rubycode/version.rb

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

data/lib/rubycode.rb

@@ -1,8 +1,27 @@
 # frozen_string_literal: true
 
 require_relative "rubycode/version"
+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/client"
 
 module Rubycode
   class Error < StandardError; end
-  # Your code goes here...
+
+  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

data/rubycode_cli.rb

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "lib/rubycode"
+require "readline"
+
+puts "\n" + "=" * 80
+puts "🚀 RubyCode - AI Ruby/Rails Code Assistant"
+puts "=" * 80
+
+# Ask for directory
+print "\nWhat directory do you want to work on? (default: current directory): "
+directory = gets.chomp
+directory = Dir.pwd if directory.empty?
+
+# Resolve the full path
+full_path = File.expand_path(directory)
+
+unless Dir.exist?(full_path)
+  puts "\n❌ Error: Directory '#{full_path}' does not exist!"
+  exit 1
+end
+
+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'
+
+# Configure the client
+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
+end
+
+puts "🐛 Debug mode: #{debug_mode ? 'ON' : 'OFF'}" if debug_mode
+
+# Create a client
+client = Rubycode::Client.new
+
+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
+
+# Interactive loop
+loop do
+  print "\n💬 You: "
+  prompt = Readline.readline("", true)
+
+  # Handle empty input
+  next if prompt.nil? || prompt.strip.empty?
+
+  # Handle commands
+  case prompt.strip.downcase
+  when 'exit', 'quit'
+    puts "\n👋 Goodbye!"
+    break
+  when 'clear'
+    client.clear_history
+    puts "\n🗑️  History cleared!"
+    next
+  end
+
+  puts "\n" + "-" * 80
+
+  begin
+    # Get response from agent
+    response = client.ask(prompt: prompt)
+
+    puts "\n🤖 Agent:"
+    puts "-" * 80
+    puts response
+    puts "-" * 80
+  rescue Interrupt
+    puts "\n\n⚠️  Interrupted! Type 'exit' to quit or continue chatting."
+  rescue => e
+    puts "\n❌ Error: #{e.message}"
+    puts e.backtrace.first(3).join("\n")
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubycode
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Jonas Medeiros
@@ -21,8 +21,22 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- USAGE.md
 - lib/rubycode.rb
+- lib/rubycode/adapters/base.rb
+- lib/rubycode/adapters/ollama.rb
+- lib/rubycode/client.rb
+- lib/rubycode/configuration.rb
+- lib/rubycode/context_builder.rb
+- lib/rubycode/history.rb
+- lib/rubycode/tools.rb
+- lib/rubycode/tools/bash.rb
+- lib/rubycode/tools/done.rb
+- lib/rubycode/tools/read.rb
+- lib/rubycode/tools/search.rb
 - lib/rubycode/version.rb
+- rubycode-0.1.0.gem
+- rubycode_cli.rb
 - sig/rubycode.rbs
 homepage: https://example.com
 licenses: