ruby_coded 0.1.1

data/lib/ruby_coded/auth/oauth_callback_server.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "webrick"
+require "timeout"
+
+require_relative "callback_servlet"
+
+module RubyCoded
+  module Auth
+    # This class is used to start a local webrick server for the
+    # OAuth authentication callback
+    class OAuthCallbackServer
+      PORT = 1_455
+      TIMEOUT = 120
+
+      def initialize
+        @result_queue = Queue.new
+        @server = WEBrick::HTTPServer.new(Port: PORT, Logger: WEBrick::Log.new(File::NULL), AccessLog: [])
+        @server.mount "/auth/callback", CallbackServlet, @result_queue
+      end
+
+      def start
+        @thread = Thread.new { @server.start }
+      end
+
+      def wait_for_callback
+        Timeout.timeout(TIMEOUT) { @result_queue.pop }
+      ensure
+        shutdown
+      end
+
+      def shutdown
+        @server.shutdown
+        @thread&.join(5)
+      end
+    end
+  end
+end

data/lib/ruby_coded/auth/pkce.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "base64"
+require "digest"
+
+module RubyCoded
+  module Auth
+    # Generates a Proof Key for Code Exchange
+    # This will be used to authenticate the user with some AI providers
+    module PKCE
+      def self.generate
+        verifier = SecureRandom.urlsafe_base64(32)
+        challenge = Base64.urlsafe_encode64(Digest::SHA256.digest(verifier), padding: false)
+        { verifier: verifier, challenge: challenge }
+      end
+    end
+  end
+end

data/lib/ruby_coded/auth/providers/anthropic.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Auth
+    module Providers
+      # Anthropic provider's configuration
+      module Anthropic
+        def self.display_name
+          "Anthropic"
+        end
+
+        def self.auth_methods
+          [
+            { key: :api_key, label: "With an Anthropic API key (requires API credits at console.anthropic.com)" }
+          ]
+        end
+
+        def self.console_url
+          "https://console.anthropic.com/settings/keys"
+        end
+
+        def self.key_pattern
+          /\Ask-ant-/
+        end
+
+        def self.ruby_llm_key
+          :anthropic_api_key
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/auth/providers/openai.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Auth
+    module Providers
+      # OpenAI provider's configuration
+      module OpenAI
+        def self.display_name
+          "OpenAI"
+        end
+
+        def self.client_id
+          "app_EMoamEEZ73f0CkXaXp7hrann"
+        end
+
+        def self.auth_methods
+          [
+            { key: :oauth,
+              label: "With your OpenAI account (requires API credits, " \
+                     "your ChatGPT subscription does not cover API usage)" },
+            { key: :api_key, label: "With an OpenAI API key (requires API credits at platform.openai.com)" }
+          ]
+        end
+
+        def self.auth_url
+          "https://auth.openai.com/oauth/authorize"
+        end
+
+        def self.token_url
+          "https://auth.openai.com/oauth/token"
+        end
+
+        def self.console_url
+          "https://platform.openai.com/account/api-keys"
+        end
+
+        def self.key_pattern
+          /\Ask-/
+        end
+
+        def self.redirect_uri
+          "http://localhost:1455/auth/callback"
+        end
+
+        def self.scopes
+          "offline_access"
+        end
+
+        def self.ruby_llm_key
+          :openai_api_key
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/app/event_dispatch.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class App
+      # Routes TUI events to the appropriate handler methods.
+      module EventDispatch
+        private
+
+        def dispatch_event(event)
+          action = @input_handler.process(event)
+          case action
+          when :quit then :quit
+          when :submit then handle_submit
+          when :model_selected, :model_select_cancel then dispatch_model_action(action)
+          when :cancel_streaming, :tool_approved, :tool_approved_all, :tool_rejected then dispatch_llm_action(action)
+          when :plan_clarification_selected, :plan_clarification_custom, :plan_clarification_skip
+            dispatch_plan_clarification(action)
+          when :scroll_up, :scroll_down, :scroll_top, :scroll_bottom then handle_scroll(action)
+          end
+        end
+
+        def handle_submit
+          input = @state.consume_input!
+          if input.start_with?("/")
+            @command_handler.handle(input)
+            :quit if @state.should_quit?
+          else
+            @state.add_message(:user, input)
+            @llm_bridge.send_async(input)
+          end
+        end
+
+        def dispatch_model_action(action)
+          case action
+          when :model_selected then apply_selected_model
+          when :model_select_cancel then @state.exit_model_select!
+          end
+        end
+
+        def dispatch_llm_action(action)
+          case action
+          when :cancel_streaming then @llm_bridge.cancel!
+          when :tool_approved then @llm_bridge.approve_tool!
+          when :tool_approved_all then @llm_bridge.approve_all_tools!
+          when :tool_rejected then @llm_bridge.reject_tool!
+          end
+        end
+
+        def dispatch_plan_clarification(action)
+          case action
+          when :plan_clarification_selected
+            handle_plan_clarification_response(@state.selected_clarification_option)
+          when :plan_clarification_custom
+            handle_plan_clarification_response(@state.clarification_custom_input.dup)
+          when :plan_clarification_skip
+            @state.exit_plan_clarification!
+          end
+        end
+
+        def handle_plan_clarification_response(response)
+          @state.exit_plan_clarification!
+          @state.add_message(:user, response)
+          @llm_bridge.send_async(response)
+        end
+
+        def handle_scroll(action)
+          case action
+          when :scroll_up then @state.scroll_up
+          when :scroll_down then @state.scroll_down
+          when :scroll_top then @state.scroll_to_top
+          when :scroll_bottom then @state.scroll_to_bottom
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/app.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "ratatui_ruby"
+
+require_relative "state"
+require_relative "input_handler"
+require_relative "renderer"
+require_relative "command_handler"
+require_relative "llm_bridge"
+require_relative "../auth/credentials_store"
+require_relative "app/event_dispatch"
+
+module RubyCoded
+  module Chat
+    # Main class for the AI chat interface
+    class App
+      include EventDispatch
+
+      def initialize(model:, user_config: nil)
+        @model = model
+        @user_config = user_config
+        apply_plugin_extensions!
+        @state = State.new(model: model)
+        @llm_bridge = LLMBridge.new(@state)
+        @input_handler = InputHandler.new(@state)
+        @credentials_store = Auth::CredentialsStore.new
+        @command_handler = build_command_handler
+      end
+
+      IDLE_POLL_TIMEOUT = 0.016
+      STREAMING_POLL_TIMEOUT = 0.05
+
+      def run
+        RatatuiRuby.run do |tui|
+          init_tui(tui)
+          run_event_loop
+        end
+      end
+
+      private
+
+      def init_tui(tui)
+        @tui = tui
+        @renderer = Renderer.new(tui, @state)
+      end
+
+      def run_event_loop
+        loop do
+          refresh_screen
+          event = @tui.poll_event(timeout: poll_timeout)
+          next if event.none?
+
+          break if dispatch_event(event) == :quit
+        end
+      end
+
+      def refresh_screen
+        return unless @state.dirty?
+
+        @renderer.draw
+        @state.mark_clean!
+      end
+
+      def poll_timeout
+        @state.streaming? ? STREAMING_POLL_TIMEOUT : IDLE_POLL_TIMEOUT
+      end
+
+      def apply_plugin_extensions!
+        RubyCoded.plugin_registry.apply_extensions!(
+          state_class: State,
+          input_handler_class: InputHandler,
+          renderer_class: Renderer,
+          command_handler_class: CommandHandler
+        )
+      end
+
+      def build_command_handler
+        CommandHandler.new(
+          @state, llm_bridge: @llm_bridge, user_config: @user_config, credentials_store: @credentials_store
+        )
+      end
+
+      def apply_selected_model
+        selected = @state.selected_model
+        return @state.exit_model_select! unless selected
+
+        switch_model(selected)
+      rescue StandardError => e
+        @state.exit_model_select!
+        @state.add_message(:system, "Failed to switch model: #{e.message}")
+      end
+
+      def switch_model(selected)
+        model_name = selected.respond_to?(:id) ? selected.id : selected.to_s
+        @state.model = model_name
+        @llm_bridge.reset_chat!(model_name)
+        @user_config&.set_config("model", model_name)
+        @state.exit_model_select!
+        @state.add_message(:system, "Model switched to #{model_name}.")
+      end
+
+    end
+  end
+end

data/lib/ruby_coded/chat/command_handler/agent_commands.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class CommandHandler
+      # Slash commands for toggling agentic mode on/off.
+      module AgentCommands
+        private
+
+        def cmd_agent(rest)
+          case rest&.strip&.downcase
+          when "on"
+            enable_agent_mode
+          when "off"
+            disable_agent_mode
+          when nil, ""
+            show_agent_status
+          else
+            @state.add_message(:system, "Usage: /agent [on|off]")
+          end
+        end
+
+        def enable_agent_mode
+          if @llm_bridge.agentic_mode
+            @llm_bridge.reset_agent_session!
+            @state.add_message(:system,
+                               "Agent session reset. Tool call counters cleared — ready for a new task.")
+            return
+          end
+
+          @llm_bridge.toggle_agentic_mode!(true)
+          @state.add_message(:system,
+                             "Agent mode enabled. The model can now use tools to interact with your project files.")
+        end
+
+        def disable_agent_mode
+          unless @llm_bridge.agentic_mode
+            @state.add_message(:system, "Agent mode is already disabled.")
+            return
+          end
+
+          @llm_bridge.toggle_agentic_mode!(false)
+          @state.add_message(:system, "Agent mode disabled. Switched back to chat-only mode.")
+        end
+
+        def show_agent_status
+          status = @llm_bridge.agentic_mode ? "enabled" : "disabled"
+          @state.add_message(:system, "Agent mode: #{status}. Use /agent on or /agent off to toggle.")
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/command_handler/history_commands.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class CommandHandler
+      # Slash commands for viewing conversation history.
+      module HistoryCommands
+        private
+
+        def cmd_history(_rest)
+          conv = conversation_messages
+          if conv.empty?
+            @state.add_message(:system, "No conversation history yet.")
+            return
+          end
+
+          @state.add_message(:system, format_history(conv))
+        end
+
+        def conversation_messages
+          @state.messages_snapshot.reject { |m| m[:role] == :system }
+        end
+
+        def format_history(conv)
+          lines = conv.map.with_index(1) { |msg, i| format_history_line(msg, i) }
+          "Conversation history (#{conv.size} messages):\n#{lines.join("\n")}"
+        end
+
+        def format_history_line(msg, index)
+          role = msg[:role].to_s.capitalize
+          preview = msg[:content].to_s.lines.first&.strip || ""
+          preview = "#{preview[0..60]}..." if preview.length > 60
+          "  #{index}. [#{role}] #{preview}"
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/command_handler/model_commands.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative "../model_filter"
+
+module RubyCoded
+  module Chat
+    class CommandHandler
+      # This module contains the logic for the CLI commands' management
+      module ModelCommands
+        private
+
+        def cmd_model(rest)
+          return open_model_selector if rest.nil? || rest.strip.empty?
+
+          name = rest.strip
+          return open_model_selector(show_all: true) if name == "--all"
+          return unless model_match?(name)
+
+          switch_to_model(name)
+        rescue StandardError => e
+          @state.add_message(:system, "Failed to switch model: #{e.message}")
+        end
+
+        def model_match?(name)
+          models = fetch_chat_models
+          return true unless models.any?
+          return true if models.find { |m| model_id(m) == name }
+
+          suggest_models(name, models)
+          false
+        end
+
+        def suggest_models(name, models)
+          suggestions = models.select { |m| model_id(m).include?(name) }.map { |m| model_id(m) }.first(5)
+          msg = "Model '#{name}' not found."
+          msg += " Did you mean: #{suggestions.join(", ")}?" if suggestions.any?
+          @state.add_message(:system, msg)
+        end
+
+        def switch_to_model(name)
+          @state.model = name
+          @llm_bridge.reset_chat!(name)
+          @user_config&.set_config("model", name)
+          @state.add_message(:system, "Model switched to #{name}.")
+        end
+
+        def open_model_selector(show_all: false)
+          models = fetch_models_for_authenticated_providers
+          models = ModelFilter.filter(models) unless show_all
+
+          if models.empty?
+            @state.add_message(:system,
+                               "Current model: #{@state.model}. " \
+                               "No available models found for your authenticated providers.")
+            return
+          end
+
+          @state.enter_model_select!(models, show_all: show_all)
+        end
+
+        def fetch_models_for_authenticated_providers
+          return fetch_chat_models unless @credentials_store
+
+          models = []
+
+          Auth::AuthManager::PROVIDERS.each_key do |name|
+            next unless @credentials_store.retrieve(name)
+
+            provider_models = RubyLLM.models.by_provider(name).chat_models.to_a
+            models.concat(provider_models)
+          end
+          models
+        rescue StandardError
+          fetch_chat_models
+        end
+
+        def fetch_chat_models
+          RubyLLM.models.chat_models.to_a
+        rescue StandardError
+          []
+        end
+
+        def model_id(model)
+          return model.id if model.respond_to?(:id)
+
+          model.to_s
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/command_handler/plan_commands.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class CommandHandler
+      # Slash commands for toggling plan mode and saving plans.
+      module PlanCommands
+        private
+
+        def cmd_plan(rest)
+          case rest&.strip&.downcase
+          when "on"          then enable_plan_mode
+          when "off"         then disable_plan_mode(force: false)
+          when "off --force" then disable_plan_mode(force: true)
+          when nil, ""       then show_plan_status
+          else                    handle_plan_subcommand(rest.strip)
+          end
+        end
+
+        def handle_plan_subcommand(rest)
+          if rest.downcase.start_with?("save")
+            filename = rest.sub(/\Asave\s*/i, "").strip
+            save_plan(filename.empty? ? nil : filename)
+          else
+            @state.add_message(:system, "Usage: /plan [on|off|save [filename]]")
+          end
+        end
+
+        def enable_plan_mode
+          if @state.plan_mode_active?
+            @state.add_message(:system, "Plan mode is already enabled.")
+            return
+          end
+
+          deactivate_agent_if_needed
+          @llm_bridge.toggle_plan_mode!(true)
+          @state.activate_plan_mode!
+          @state.add_message(:system,
+                             "Plan mode enabled. Describe what you want to build and the model " \
+                             "will help you create a structured plan.")
+        end
+
+        def deactivate_agent_if_needed
+          return unless @llm_bridge.agentic_mode
+
+          @llm_bridge.toggle_agentic_mode!(false)
+          @state.add_message(:system, "Agent mode disabled.")
+        end
+
+        def disable_plan_mode(force:)
+          unless @state.plan_mode_active?
+            @state.add_message(:system, "Plan mode is already disabled.")
+            return
+          end
+
+          return if unsaved_plan_warned?(force)
+
+          @llm_bridge.toggle_plan_mode!(false)
+          @state.deactivate_plan_mode!
+          @state.add_message(:system, "Plan mode disabled. Switched back to chat mode.")
+        end
+
+        def unsaved_plan_warned?(force)
+          return false if force || !@state.has_unsaved_plan?
+
+          @state.add_message(:system,
+                             "You have an unsaved plan. Use /plan save [filename] first, " \
+                             "or /plan off --force to discard.")
+          true
+        end
+
+        def show_plan_status
+          if @state.plan_mode_active?
+            saved_status = @state.has_unsaved_plan? ? " (unsaved changes)" : ""
+            @state.add_message(:system, "Plan mode: enabled#{saved_status}. Use /plan off to disable.")
+          else
+            @state.add_message(:system, "Plan mode: disabled. Use /plan on to enable.")
+          end
+        end
+
+        def save_plan(filename)
+          plan_content = @state.current_plan
+
+          unless plan_content
+            @state.add_message(:system, "No plan to save. Generate a plan first.")
+            return
+          end
+
+          filename ||= generate_plan_filename(plan_content)
+          write_plan_file(filename, plan_content)
+        end
+
+        def write_plan_file(filename, content)
+          path = File.join(@llm_bridge.project_root, filename)
+          File.write(path, content)
+          @state.mark_plan_saved!
+          @state.add_message(:system, "Plan saved to #{filename}")
+        rescue StandardError => e
+          @state.add_message(:system, "Failed to save plan: #{e.message}")
+        end
+
+        def generate_plan_filename(content)
+          date = Time.now.strftime("%Y-%m-%d")
+          first_line = content.lines.first&.strip || "plan"
+          slug = first_line.gsub(/[^a-zA-Z0-9\s]/, "").split.first(4).join("_").downcase
+          slug = "plan" if slug.empty?
+          "plan_#{date}_#{slug}.md"
+        end
+      end
+    end
+  end
+end