ruby_coded 0.1.1

data/lib/ruby_coded/plugins/registry.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Plugins
+    # Stores registered plugins and provides access to their extensions.
+    # Used by Chat::App at boot time to wire everything together.
+    class Registry
+      attr_reader :plugins
+
+      def initialize
+        @plugins = []
+      end
+
+      def register(plugin_class)
+        validate!(plugin_class)
+        return if @plugins.include?(plugin_class)
+
+        @plugins << plugin_class
+      end
+
+      def state_extensions
+        @plugins.filter_map(&:state_extension)
+      end
+
+      def input_extensions
+        @plugins.filter_map(&:input_extension)
+      end
+
+      def renderer_extensions
+        @plugins.filter_map(&:renderer_extension)
+      end
+
+      def command_handler_extensions
+        @plugins.filter_map(&:command_handler_extension)
+      end
+
+      # Returns an array of { method: Symbol } for each plugin that
+      # contributes an input handler hook.
+      def input_handler_configs
+        @plugins.filter_map do |plugin|
+          next unless plugin.input_handler_method
+
+          { method: plugin.input_handler_method }
+        end
+      end
+
+      # Returns an array of { method: Symbol } for each plugin that
+      # contributes a render overlay.
+      def render_configs
+        @plugins.filter_map do |plugin|
+          next unless plugin.render_method
+
+          { method: plugin.render_method }
+        end
+      end
+
+      def all_commands
+        @plugins.each_with_object({}) { |p, h| h.merge!(p.commands) }
+      end
+
+      def all_command_descriptions
+        @plugins.each_with_object({}) { |p, h| h.merge!(p.command_descriptions) }
+      end
+
+      # Includes all plugin modules into the target classes in one pass.
+      def apply_extensions!(state_class:, input_handler_class:, renderer_class:, command_handler_class:)
+        safe_include(state_class, state_extensions)
+        safe_include(input_handler_class, input_extensions)
+        safe_include(renderer_class, renderer_extensions)
+        safe_include(command_handler_class, command_handler_extensions)
+      end
+
+      private
+
+      def validate!(plugin_class)
+        return if plugin_class.is_a?(Class) && plugin_class < Base
+
+        raise ArgumentError, "#{plugin_class} must be a subclass of RubyCoded::Plugins::Base"
+      end
+
+      def safe_include(target_class, modules)
+        modules.each do |mod|
+          target_class.include(mod) unless target_class.ancestors.include?(mod)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/plugins.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "plugins/base"
+require_relative "plugins/registry"
+
+module RubyCoded # :nodoc:
+  # Returns the global plugin registry.
+  def self.plugin_registry
+    @plugin_registry ||= Plugins::Registry.new
+  end
+
+  # Register a plugin class that extends the chat functionality.
+  def self.register_plugin(plugin_class)
+    plugin_registry.register(plugin_class)
+  end
+end
+
+require_relative "plugins/command_completion/plugin"
+
+# Register built-in plugins
+RubyCoded.register_plugin(RubyCoded::Plugins::CommandCompletion::Plugin)

data/lib/ruby_coded/strategies/api_key_strategy.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+require_relative "base"
+
+module RubyCoded
+  module Strategies
+    # This class is used to authenticate using an API key
+    class APIKeyStrategy < Base
+      def authenticate
+        @prompt.say("Opening #{@provider.display_name} API key authentication in your browser...")
+        open_browser(@provider.console_url)
+
+        key = @prompt.ask("Please generate your API key and paste it here:")
+
+        raise "No API key provided" if key.nil? || key.empty?
+        raise "Invalid API key for #{@provider.display_name}" unless valid_format?(key)
+
+        @prompt.say("API key validated successfully")
+
+        { "auth_method" => "api_key", "key" => key }
+      end
+
+      def refresh(credentials)
+        credentials
+      end
+
+      def validate(credentials)
+        credentials["auth_method"] == "api_key" && valid_format?(credentials["key"])
+      end
+
+      private
+
+      def valid_format?(key)
+        @provider.key_pattern.match?(key)
+      end
+    end
+  end
+end

data/lib/ruby_coded/strategies/base.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+
+module RubyCoded
+  module Strategies
+    # Base interface for all authentication strategies
+    class Base
+      def initialize(provider)
+        @provider = provider
+        @prompt = TTY::Prompt.new
+      end
+
+      def authenticate
+        raise NotImplementedError
+      end
+
+      def refresh(credentials)
+        raise NotImplementedError
+      end
+
+      def validate(credentials)
+        raise NotImplementedError
+      end
+
+      private
+
+      def open_browser(url)
+        case RbConfig::CONFIG["host_os"]
+        when /darwin/ then system("open", url)
+        when /linux/ then system("xdg-open", url)
+        when /mswin|mingw/ then system("start", url)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/strategies/oauth_strategy.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "faraday"
+require "json"
+require "uri"
+require "time"
+
+require_relative "base"
+require_relative "../auth/pkce"
+require_relative "../auth/oauth_callback_server"
+require_relative "../errors/auth_error"
+
+module RubyCoded
+  module Strategies
+    # OAuth strategy for authentication with OAuth providers (OPENAI)
+    class OAuthStrategy < Base
+      def authenticate
+        pkce = Auth::PKCE.generate
+        state = SecureRandom.hex(16)
+
+        result = perform_oauth_flow(pkce[:challenge], state)
+        validate_callback!(result, state)
+
+        tokens = exchange_code(result[:code], pkce[:verifier])
+        build_token_response(tokens)
+      end
+
+      def refresh(credentials)
+        response = Faraday.post(@provider.token_url, {
+                                  "grant_type" => "refresh_token",
+                                  "refresh_token" => credentials["refresh_token"],
+                                  "client_id" => @provider.client_id
+                                })
+        tokens = JSON.parse(response.body)
+
+        {
+          "auth_method" => "oauth",
+          "access_token" => tokens["access_token"],
+          "refresh_token" => tokens["refresh_token"] ||
+            credentials["refresh_token"],
+          "expires_at" => (Time.now + tokens["expires_in"].to_i).iso8601
+        }
+      end
+
+      def validate(credentials)
+        return false unless credentials&.fetch("auth_method") ==
+                            "oauth" && credentials&.fetch("access_token")
+
+        Time.parse(credentials["expires_at"]) > Time.now
+      end
+
+      private
+
+      def perform_oauth_flow(challenge, state)
+        server = Auth::OAuthCallbackServer.new
+        server.start
+
+        url = build_auth_url(challenge, state)
+        puts "Please open the following URL in your browser to authenticate in #{@provider.display_name}..."
+        open_browser(url)
+        puts "Waiting authentication... (this may take a while)"
+
+        server.wait_for_callback
+      end
+
+      def validate_callback!(result, state)
+        raise RubyCoded::Errors::AuthError, result[:error] if result[:error]
+        raise RubyCoded::Errors::AuthError, "State mismatch" if result[:state] != state
+      end
+
+      def build_token_response(tokens)
+        {
+          "auth_method" => "oauth",
+          "access_token" => tokens["access_token"],
+          "refresh_token" => tokens["refresh_token"],
+          "expires_at" => (Time.now + tokens["expires_in"].to_i).iso8601
+        }
+      end
+
+      def build_auth_url(challenge, state)
+        params = URI.encode_www_form(
+          client_id: @provider.client_id,
+          redirect_uri: @provider.redirect_uri,
+          response_type: "code",
+          scope: @provider.scopes,
+          code_challenge: challenge,
+          code_challenge_method: "S256",
+          state: state
+        )
+        "#{@provider.auth_url}?#{params}"
+      end
+
+      def exchange_code(code, verifier)
+        response = Faraday.post(@provider.token_url, {
+                                  "grant_type" => "authorization_code",
+                                  "code" => code,
+                                  "redirect_uri" => @provider.redirect_uri,
+                                  "client_id" => @provider.client_id,
+                                  "code_verifier" => verifier
+                                })
+        JSON.parse(response.body)
+      end
+    end
+  end
+end

data/lib/ruby_coded/tools/agent_cancelled_error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Tools
+    class AgentCancelledError < StandardError; end
+  end
+end

data/lib/ruby_coded/tools/agent_iteration_limit_error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Tools
+    class AgentIterationLimitError < StandardError; end
+  end
+end

data/lib/ruby_coded/tools/base_tool.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "ruby_llm"
+require_relative "tool_rejected_error"
+
+module RubyCoded
+  module Tools
+    # Base class for all tools.
+    class BaseTool < RubyLLM::Tool
+      SAFE_RISK = :safe
+      CONFIRM_RISK = :confirm
+      DANGEROUS_RISK = :dangerous
+
+      class << self
+        attr_reader :risk_level
+
+        private
+
+        def risk(level)
+          @risk_level = level
+        end
+      end
+
+      def initialize(project_root:)
+        super()
+        @project_root = File.realpath(project_root)
+      end
+
+      private
+
+      def resolve_path(relative_path)
+        expanded = File.expand_path(relative_path, @project_root)
+        File.realpath(expanded)
+      rescue Errno::ENOENT
+        expanded
+      end
+
+      def inside_project?(full_path)
+        full_path.start_with?(@project_root)
+      end
+
+      def validate_path!(relative_path)
+        full = resolve_path(relative_path)
+        return full if inside_project?(full)
+
+        { error: "Path is outside the project directory. Only paths within #{@project_root} are allowed." }
+      end
+    end
+  end
+end

data/lib/ruby_coded/tools/create_directory_tool.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "base_tool"
+
+module RubyCoded
+  module Tools
+    # Create a directory (and any necessary parent directories) at the given path
+    class CreateDirectoryTool < BaseTool
+      description "Create a directory (and any necessary parent directories) at the given path"
+      risk :confirm
+
+      params do
+        string :path, description: "Relative directory path from the project root"
+      end
+
+      def execute(path:)
+        full_path = validate_path!(path)
+        return full_path if full_path.is_a?(Hash)
+
+        if File.exist?(full_path)
+          return { error: "Path already exists: #{path}" } unless File.directory?(full_path)
+
+          return "Directory already exists: #{path}"
+        end
+
+        FileUtils.mkdir_p(full_path)
+        "Directory created: #{path}"
+      rescue SystemCallError => e
+        { error: "Failed to create directory #{path}: #{e.message}" }
+      end
+    end
+  end
+end

data/lib/ruby_coded/tools/delete_path_tool.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "base_tool"
+
+module RubyCoded
+  module Tools
+    # Delete a file or an empty directory at the given path
+    class DeletePathTool < BaseTool
+      description "Delete a file or an empty directory at the given path"
+      risk :dangerous
+
+      params do
+        string :path, description: "Relative path from the project root to delete"
+      end
+
+      def execute(path:)
+        full_path = validate_path!(path)
+        return full_path if full_path.is_a?(Hash)
+        return { error: "Path not found: #{path}" } unless File.exist?(full_path)
+        return { error: "Cannot delete the project root" } if full_path == @project_root
+
+        perform_delete(path, full_path)
+      rescue SystemCallError => e
+        { error: "Failed to delete #{path}: #{e.message}" }
+      end
+
+      private
+
+      def perform_delete(path, full_path)
+        if File.directory?(full_path)
+          delete_directory(path, full_path)
+        else
+          File.delete(full_path)
+          "Deleted file: #{path}"
+        end
+      end
+
+      def delete_directory(path, full_path)
+        entries = Dir.children(full_path)
+        unless entries.empty?
+          return { error: "Directory not empty: #{path} (#{entries.length} entries). Remove contents first." }
+        end
+
+        Dir.rmdir(full_path)
+        "Deleted empty directory: #{path}"
+      end
+    end
+  end
+end

data/lib/ruby_coded/tools/edit_file_tool.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module RubyCoded
+  module Tools
+    # Replace a specific text occurrence in an existing file (search and replace)
+    class EditFileTool < BaseTool
+      description "Replace a specific text occurrence in an existing file (search and replace)"
+      risk :confirm
+
+      params do
+        string :path, description: "Relative file path from the project root"
+        string :old_text, description: "The exact text to find in the file (must match exactly)"
+        string :new_text, description: "The replacement text"
+      end
+
+      def execute(path:, old_text:, new_text:)
+        full_path = validate_path!(path)
+        return full_path if full_path.is_a?(Hash)
+        return { error: "File not found: #{path}" } unless File.exist?(full_path)
+        return { error: "Not a file: #{path}" } unless File.file?(full_path)
+
+        apply_edit(path, full_path, old_text, new_text)
+      rescue SystemCallError => e
+        { error: "Failed to edit #{path}: #{e.message}" }
+      end
+
+      private
+
+      def apply_edit(path, full_path, old_text, new_text)
+        original = File.read(full_path)
+        return { error: "old_text not found in #{path}" } unless original.include?(old_text)
+
+        File.write(full_path, original.sub(old_text, new_text))
+        "File edited: #{path}"
+      end
+    end
+  end
+end

data/lib/ruby_coded/tools/list_directory_tool.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module RubyCoded
+  module Tools
+    # List files and directories at the given path relative to the project root
+    class ListDirectoryTool < BaseTool
+      description "List files and directories at the given path relative to the project root. " \
+                  "Set include_hidden to true to include hidden/ignored directories."
+      risk :safe
+
+      IGNORED_DIRS = %w[
+        .git node_modules vendor/bundle tmp log .bundle
+        .cache coverage .yardoc pkg dist build
+      ].freeze
+
+      params do
+        string :path, description: "Relative directory path from the project root (use '.' for root)"
+        boolean :include_hidden, description: "Include hidden and commonly ignored directories (default: false)",
+                                 required: false
+      end
+
+      def execute(path:, include_hidden: false)
+        full_path = validate_path!(path)
+        return full_path if full_path.is_a?(Hash)
+        return { error: "Directory not found: #{path}" } unless File.exist?(full_path)
+        return { error: "Not a directory: #{path}" } unless File.directory?(full_path)
+
+        list_entries(full_path, include_hidden)
+      end
+
+      private
+
+      def list_entries(full_path, include_hidden)
+        children = Dir.children(full_path).sort
+        children = children.reject { |name| ignored_entry?(name) } unless include_hidden
+
+        entries = children.map do |name|
+          entry_path = File.join(full_path, name)
+          type = File.directory?(entry_path) ? "dir" : "file"
+          "#{type}  #{name}"
+        end
+
+        entries.empty? ? "(empty directory)" : entries.join("\n")
+      end
+
+      def ignored_entry?(name)
+        IGNORED_DIRS.include?(name)
+      end
+    end
+  end
+end

data/lib/ruby_coded/tools/plan_system_prompt.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Tools
+    module PlanSystemPrompt # :nodoc:
+      TEMPLATE = <<~PROMPT
+        You are a development planning assistant with access to the project directory: %<project_root>s
+
+        Your role is to help the user create structured, actionable development plans.
+
+        ## Project exploration
+
+        You have read-only tools to explore the project:
+        - **list_directory**: list files and directories at a given path.
+        - **read_file**: read the contents of a file.
+
+        Use these tools proactively to understand the project structure, conventions, and existing
+        code before creating a plan. Always start by exploring the project when you need context
+        rather than asking the user for information you can discover yourself.
+
+        Guidelines for exploration:
+        - Always use paths relative to the project root.
+        - Start with the project root directory to orient yourself.
+        - Read relevant files (READMEs, Gemfiles, configs, key source files) to understand the stack and conventions.
+        - Use the information you gather to make your plans concrete and grounded in the actual codebase.
+
+        ## Clarification protocol
+
+        After exploring the project, if you still need information that cannot be found in the
+        codebase (e.g., business decisions, user preferences, deployment constraints), ask ONE
+        question at a time using this exact XML format:
+
+        <clarification>
+          <question>Your question here</question>
+          <option>First concrete option</option>
+          <option>Second concrete option</option>
+          <option>Third concrete option (if needed)</option>
+        </clarification>
+
+        Rules for clarification:
+        - Explore the project FIRST — only ask when the answer is not in the codebase.
+        - Ask only ONE question per response.
+        - Provide between 2 and 5 concrete, actionable options.
+        - You may include explanatory text BEFORE the <clarification> tag.
+        - Do NOT include any text AFTER the closing </clarification> tag.
+        - Only ask when genuinely needed; do not over-ask.
+
+        ## Plan generation
+
+        When the request is clear enough, generate the plan directly (no clarification tags).
+
+        Structure the plan in markdown with these sections:
+        - **Objective**: one-sentence summary of what will be built.
+        - **Scope**: what is included and what is explicitly excluded.
+        - **Steps**: numbered list of concrete implementation steps, each with a brief description.
+        - **Dependencies**: libraries, services, or prerequisites needed.
+        - **Risks**: potential issues or trade-offs to consider.
+        - **Estimates**: rough time estimate per step (optional, include if enough context).
+
+        Guidelines:
+        - Be concise but thorough.
+        - Prefer small, incremental steps over large monolithic ones.
+        - Reference specific files, classes, and patterns you found during exploration.
+        - Use relative paths when referencing project files.
+      PROMPT
+
+      def self.build(project_root:)
+        format(TEMPLATE, project_root: project_root)
+      end
+    end
+  end
+end

data/lib/ruby_coded/tools/read_file_tool.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module RubyCoded
+  module Tools
+    # Read the contents of a file at the given path relative to the project root
+    class ReadFileTool < BaseTool
+      description "Read the contents of a file at the given path relative to the project root. " \
+                  "Use offset and max_lines to read specific sections of large files."
+      risk :safe
+
+      DEFAULT_MAX_LINES = 200
+
+      params do
+        string :path, description: "Relative file path from the project root"
+        integer :offset, description: "Line number to start reading from (1-based, default: 1)", required: false
+        integer :max_lines, description: "Maximum number of lines to return (default: #{DEFAULT_MAX_LINES})",
+                            required: false
+      end
+
+      def execute(path:, offset: nil, max_lines: nil)
+        full_path = validate_path!(path)
+        return full_path if full_path.is_a?(Hash)
+        return { error: "File not found: #{path}" } unless File.exist?(full_path)
+        return { error: "Not a file: #{path}" } unless File.file?(full_path)
+
+        read_file_section(full_path, offset, max_lines)
+      end
+
+      private
+
+      def read_file_section(full_path, offset, max_lines)
+        lines = File.readlines(full_path)
+        return { error: "File is empty" } if lines.empty?
+
+        start_line = [offset || 1, 1].max
+        selected = lines[start_line - 1, max_lines || DEFAULT_MAX_LINES] || []
+
+        format_lines_output(selected, start_line, lines.length)
+      end
+
+      def format_lines_output(selected, start_line, total)
+        result = selected.join
+        end_line = start_line - 1 + selected.length
+        remaining = total - end_line
+        return result unless remaining.positive?
+
+        result << "\n... (showing lines #{start_line}-#{end_line} of #{total}. " \
+                  "#{remaining} lines remaining, use offset to read more)"
+      end
+    end
+  end
+end