ruby_coded 0.1.1

data/lib/ruby_coded/chat/state.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require_relative "state/model_selection"
+require_relative "state/messages"
+require_relative "state/message_assistant"
+require_relative "state/message_token_tracking"
+require_relative "state/scrollable"
+require_relative "state/tool_confirmation"
+require_relative "state/plan_tracking"
+require_relative "state/token_cost"
+
+module RubyCoded
+  module Chat
+    # This class is used to manage the state of the chat
+    class State
+      include ModelSelection
+      include Messages
+      include MessageAssistant
+      include MessageTokenTracking
+      include Scrollable
+      include ToolConfirmation
+      include PlanTracking
+      include TokenCost
+
+      attr_reader :input_buffer, :cursor_position, :input_scroll_offset, :messages, :scroll_offset,
+                  :mode, :model_list, :model_select_index, :model_select_filter,
+                  :streaming, :mutex
+      attr_accessor :model, :should_quit
+
+      MIN_RENDER_INTERVAL = 0.05
+
+      def initialize(model:)
+        @model = model
+        # String.new: literals like "" are frozen under frozen_string_literal
+        @input_buffer = String.new
+        @cursor_position = 0
+        @input_scroll_offset = 0
+        @messages = []
+        @streaming = false
+        @should_quit = false
+        @agentic_mode = false
+        @mutex = Mutex.new
+        @dirty = true
+        @last_render_at = 0.0
+        @scroll_offset = 0
+        @total_lines = 0
+        @visible_height = 0
+        @mode = :chat
+        @model_list = []
+        @model_select_index = 0
+        @model_select_filter = String.new
+        @model_select_show_all = false
+        init_messages
+        init_tool_confirmation
+        init_plan_tracking
+        init_token_cost
+        init_plugin_state
+      end
+
+      def streaming=(value)
+        @streaming = value
+        mark_dirty!
+      end
+
+      def streaming?
+        @streaming
+      end
+
+      def agentic_mode?
+        @agentic_mode
+      end
+
+      def agentic_mode=(value)
+        @agentic_mode = value
+        mark_dirty!
+      end
+
+      def should_quit?
+        @should_quit
+      end
+
+      def dirty?
+        @mutex.synchronize do
+          return false unless @dirty
+          return true unless @streaming
+
+          now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          (now - @last_render_at) >= MIN_RENDER_INTERVAL
+        end
+      end
+
+      def mark_clean!
+        @mutex.synchronize do
+          @dirty = false
+          @last_render_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        end
+      end
+
+      def mark_dirty!
+        @mutex.synchronize { @dirty = true }
+      end
+
+      # Updates the horizontal scroll offset of the input area so the
+      # cursor is always visible.  Call this after every cursor / buffer
+      # change.  +visible_width+ is set by the renderer each frame via
+      # +update_input_visible_width+.
+      def update_input_scroll_offset
+        visible = @input_visible_width || 0
+        return if visible <= 0
+
+        if @cursor_position < @input_scroll_offset
+          @input_scroll_offset = @cursor_position
+        elsif @cursor_position >= @input_scroll_offset + visible
+          @input_scroll_offset = @cursor_position - visible + 1
+        end
+      end
+
+      # Called by the renderer so the state knows how many characters
+      # fit on screen (inner width minus the prompt prefix).
+      def update_input_visible_width(width)
+        @input_visible_width = width
+      end
+
+      def append_to_input(text)
+        @input_buffer.insert(@cursor_position, text)
+        @cursor_position += text.length
+        update_input_scroll_offset
+        mark_dirty!
+        reset_command_completion_index if respond_to?(:reset_command_completion_index, true)
+      end
+
+      def delete_last_char
+        return if @cursor_position <= 0
+
+        @input_buffer.slice!(@cursor_position - 1)
+        @cursor_position -= 1
+        update_input_scroll_offset
+        mark_dirty!
+        reset_command_completion_index if respond_to?(:reset_command_completion_index, true)
+      end
+
+      def move_cursor_left
+        return if @cursor_position <= 0
+
+        @cursor_position -= 1
+        update_input_scroll_offset
+        mark_dirty!
+      end
+
+      def move_cursor_right
+        return if @cursor_position >= @input_buffer.length
+
+        @cursor_position += 1
+        update_input_scroll_offset
+        mark_dirty!
+      end
+
+      def move_cursor_to_start
+        return if @cursor_position == 0
+
+        @cursor_position = 0
+        update_input_scroll_offset
+        mark_dirty!
+      end
+
+      def move_cursor_to_end
+        return if @cursor_position == @input_buffer.length
+
+        @cursor_position = @input_buffer.length
+        update_input_scroll_offset
+        mark_dirty!
+      end
+
+      def clear_input!
+        @input_buffer.clear
+        @cursor_position = 0
+        @input_scroll_offset = 0
+        mark_dirty!
+      end
+
+      def consume_input!
+        input = @input_buffer.dup
+        @input_buffer.clear
+        @cursor_position = 0
+        @input_scroll_offset = 0
+        input
+      end
+
+      private
+
+      # Calls plugin state initializers (e.g. init_command_completion).
+      def init_plugin_state
+        return unless RubyCoded.respond_to?(:plugin_registry)
+
+        RubyCoded.plugin_registry.plugins.each do |plugin|
+          ext = plugin.state_extension
+          next unless ext
+
+          init_method = :"init_#{plugin.plugin_name}"
+          send(init_method) if respond_to?(init_method, true)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/config/user_config.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module RubyCoded
+  # This class is used to manage the users configurations for this gem
+  class UserConfig
+    CONFIG_DIR = File.join(Dir.home, ".ruby_coded").freeze
+    CONFIG_PATH = File.join(CONFIG_DIR, "config.yaml").freeze
+
+    def initialize(config_path: CONFIG_PATH)
+      @config_path = config_path
+      @config_dir = File.dirname(@config_path)
+      @user_config = find_or_create_config_file
+    end
+
+    def full_config
+      @user_config
+    end
+
+    def get_config(key)
+      full_config["user_config"][key]
+    end
+
+    def set_config(key, value)
+      full_config["user_config"][key] = value
+      File.write(@config_path, full_config.to_yaml)
+    end
+
+    def save
+      File.write(@config_path, full_config.to_yaml)
+    end
+
+    def directory_trusted?(dir = Dir.pwd)
+      trusted = get_config("trusted_directories") || []
+      trusted.include?(resolve_path(dir))
+    end
+
+    def trust_directory!(dir = Dir.pwd)
+      trusted = get_config("trusted_directories") || []
+      resolved = resolve_path(dir)
+      return if trusted.include?(resolved)
+
+      trusted << resolved
+      set_config("trusted_directories", trusted)
+    end
+
+    private
+
+    def find_or_create_config_file
+      migrate_legacy_config
+      FileUtils.mkdir_p(@config_dir)
+
+      config = File.exist?(@config_path) ? YAML.load_file(@config_path) : nil
+
+      if config.is_a?(Hash) && config["user_config"]
+        config
+      else
+        default = user_config_info
+        File.write(@config_path, default.to_yaml)
+        default
+      end
+    end
+
+    def migrate_legacy_config
+      legacy_path = File.join(Dir.pwd, ".config.yaml")
+      return unless File.exist?(legacy_path) && !File.exist?(@config_path)
+
+      legacy_config = load_legacy_config(legacy_path)
+      write_migrated_config(legacy_config, legacy_path)
+    end
+
+    def load_legacy_config(legacy_path)
+      FileUtils.mkdir_p(@config_dir)
+      config = YAML.load_file(legacy_path)
+      normalize_legacy_permissions(config)
+      config
+    end
+
+    def normalize_legacy_permissions(config)
+      return unless config.is_a?(Hash) && config["user_config"]
+
+      if config["user_config"]["current_directory_permission"]
+        config["user_config"]["trusted_directories"] = [resolve_path(Dir.pwd)]
+      end
+      config["user_config"].delete("current_directory_permission")
+    end
+
+    def write_migrated_config(config, legacy_path)
+      File.write(@config_path, config.to_yaml)
+      File.delete(legacy_path)
+    end
+
+    def resolve_path(path)
+      File.realpath(File.expand_path(path))
+    rescue Errno::ENOENT
+      File.expand_path(path)
+    end
+
+    def user_config_info
+      {
+        "user_config" => {
+          "trusted_directories" => [],
+          "model" => nil
+        }
+      }
+    end
+  end
+end

data/lib/ruby_coded/errors/auth_error.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Errors
+    # Authentication error
+    class AuthError < StandardError
+      def initialize(message = "Authentication failed")
+        super(message)
+      end
+    end
+  end
+end

data/lib/ruby_coded/initializer/cover.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  class Initializer
+    # Cover class for printing the cover of the RubyCoded gem
+    module Cover
+      BANNER = <<~'COVER'
+
+             /\
+            /  \
+           /    \         ____        _              ____          _          _
+          /------\       |  _ \ _   _| |__  _   _   / ___|___   __| | ___  __| |
+         /  \  /  \      | |_) | | | | '_ \| | | | | |   / _ \ / _` |/ _ \/ _` |
+        /    \/    \     |  _ <| |_| | |_) | |_| | | |__| (_) | (_| |  __/ (_| |
+        \    /\    /     |_| \_\\__,_|_.__/ \__, |  \____\___/ \__,_|\___|\__,_|
+         \  /  \  /                         |___/
+          \/    \/
+           \    /                           v%<version>s
+            \  /
+             \/
+
+      COVER
+
+      def self.print_cover_message
+        puts BANNER.sub("%<version>s", RubyCoded::VERSION)
+      end
+    end
+  end
+end

data/lib/ruby_coded/initializer.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "ruby_llm"
+require "tty-prompt"
+
+require_relative "initializer/cover"
+require_relative "config/user_config"
+require_relative "auth/auth_manager"
+require_relative "chat/app"
+
+module RubyCoded
+  # Initializer class for the RubyCoded gem (think of it as a main class)
+  class Initializer
+    PROVIDER_DEFAULT_MODELS = {
+      openai: "gpt-5-codex",
+      anthropic: "claude-sonnet-4-6"
+    }.freeze
+
+    def initialize
+      @user_cfg = UserConfig.new
+      @prompt = TTY::Prompt.new
+      @auth_manager = Auth::AuthManager.new
+
+      ask_for_directory_permission unless @user_cfg.directory_trusted?
+      @auth_manager.check_authentication
+      @auth_manager.configure_ruby_llm!
+      start_chat
+    end
+
+    private
+
+    def ask_for_directory_permission
+      if @prompt.yes?("Do you trust this directory? (#{Dir.pwd})")
+        @user_cfg.trust_directory!
+      else
+        exit 0
+      end
+    end
+
+    def start_chat
+      Chat::App.new(model: resolved_chat_model, user_config: @user_cfg).run
+    end
+
+    def resolved_chat_model
+      stored = @user_cfg.get_config("model")
+      return stored.to_s if stored && !stored.to_s.strip.empty?
+
+      provider = @auth_manager.authenticated_provider_names.first
+      PROVIDER_DEFAULT_MODELS.fetch(provider, RubyLLM.config.default_model).to_s
+    end
+  end
+end

data/lib/ruby_coded/plugins/base.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Plugins
+    # Abstract base class for all plugins. Subclass this and override
+    # the class methods to declare what your plugin contributes.
+    class Base
+      class << self
+        # Unique identifier for the plugin (Symbol).
+        def plugin_name
+          raise NotImplementedError, "#{name} must implement .plugin_name"
+        end
+
+        # Module to include in Chat::State (or nil).
+        def state_extension = nil
+
+        # Module to include in Chat::InputHandler (or nil).
+        def input_extension = nil
+
+        # Module to include in Chat::Renderer (or nil).
+        def renderer_extension = nil
+
+        # Module to include in Chat::CommandHandler (or nil).
+        def command_handler_extension = nil
+
+        # Symbol — method name defined by input_extension that processes
+        # keyboard events. Signature: method(event) -> action_symbol | nil
+        def input_handler_method = nil
+
+        # Symbol — method name defined by renderer_extension that draws
+        # the plugin overlay. Signature: method(frame, chat_area, input_area)
+        def render_method = nil
+
+        # Hash mapping command strings to method symbols,
+        # e.g. { "/deploy" => :cmd_deploy }
+        def commands = {}
+
+        # Hash mapping command strings to human-readable descriptions,
+        # e.g. { "/deploy" => "Deploy the application" }
+        def command_descriptions = {}
+      end
+    end
+  end
+end

data/lib/ruby_coded/plugins/command_completion/input_extension.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Plugins
+    module CommandCompletion
+      # Mixed into Chat::InputHandler to intercept Tab and arrow keys
+      # when command completion suggestions are visible.
+      module InputExtension
+        private
+
+        def handle_command_completion_input(event)
+          return nil unless @state.command_completion_active?
+          return :plugin_handled if dispatch_completion(event)
+
+          nil
+        end
+
+        def dispatch_completion(event)
+          if event.tab?
+            @state.accept_command_completion!
+          elsif event.up?
+            @state.command_completion_up
+          elsif event.down?
+            @state.command_completion_down
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/plugins/command_completion/plugin.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "state_extension"
+require_relative "input_extension"
+require_relative "renderer_extension"
+
+module RubyCoded
+  module Plugins
+    module CommandCompletion
+      # Built-in plugin that shows a filtered list of slash-command
+      # suggestions as the user types, with Tab to accept.
+      class Plugin < Base
+        def self.plugin_name = :command_completion
+
+        def self.state_extension = StateExtension
+
+        def self.input_extension = InputExtension
+
+        def self.renderer_extension = RendererExtension
+
+        def self.input_handler_method = :handle_command_completion_input
+
+        def self.render_method = :render_command_completer
+      end
+    end
+  end
+end

data/lib/ruby_coded/plugins/command_completion/renderer_extension.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Plugins
+    module CommandCompletion
+      # Mixed into Chat::Renderer to draw a compact suggestion popup
+      # directly above the input panel when completions are active.
+      module RendererExtension
+        private
+
+        def render_command_completer(frame, chat_area, _input_area)
+          return unless @state.command_completion_active?
+
+          suggestions = @state.command_suggestions
+          return if suggestions.empty?
+
+          popup_area = completer_popup_area(chat_area, suggestions.size)
+          frame.render_widget(@tui.clear, popup_area)
+
+          items = suggestions.map { |cmd, desc| format_suggestion(cmd, desc) }
+          widget = completer_list_widget(items)
+          frame.render_widget(widget, popup_area)
+        end
+
+        def completer_popup_area(chat_area, count)
+          height = [count + 2, 10].min
+          popup_y = [chat_area.y + chat_area.height - height, chat_area.y].max
+          popup_width = [chat_area.width / 2, 40].max
+
+          @tui.rect(
+            x: chat_area.x,
+            y: popup_y,
+            width: [popup_width, chat_area.width].min,
+            height: height
+          )
+        end
+
+        def completer_list_widget(items)
+          @tui.list(
+            items: items,
+            selected_index: @state.command_completion_index,
+            highlight_style: @tui.style(bg: :blue, fg: :white, modifiers: [:bold]),
+            highlight_symbol: "> ",
+            block: @tui.block(borders: [:all])
+          )
+        end
+
+        def format_suggestion(cmd, desc)
+          "#{cmd.ljust(16)} #{desc}"
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/plugins/command_completion/state_extension.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Plugins
+    module CommandCompletion
+      # Mixed into Chat::State to add command-completion tracking.
+      module StateExtension
+        COMMAND_INFO = {
+          "/help" => "Show help message",
+          "/model" => "Select or switch model",
+          "/clear" => "Clear conversation history",
+          "/history" => "Show conversation summary",
+          "/tokens" => "Show detailed token usage and cost",
+          "/agent" => "Toggle agent mode (on/off)",
+          "/plan" => "Toggle plan mode (on/off/save)",
+          "/exit" => "Exit the chat",
+          "/quit" => "Exit the chat"
+        }.freeze
+
+        def self.included(base)
+          base.attr_reader :command_completion_index
+        end
+
+        def init_command_completion
+          @command_completion_index = 0
+        end
+
+        def command_completion_active?
+          buf = @input_buffer
+          buf.start_with?("/") && !buf.include?(" ") && !command_suggestions.empty?
+        end
+
+        # Returns an array of [command, description] pairs matching the
+        # current input buffer prefix.
+        def command_suggestions
+          prefix = @input_buffer.downcase
+          all_descriptions = merged_command_descriptions
+          all_descriptions.select { |cmd, _| cmd.start_with?(prefix) }
+                          .sort_by { |cmd, _| cmd }
+        end
+
+        def current_command_suggestion
+          suggestions = command_suggestions
+          return nil if suggestions.empty?
+
+          idx = @command_completion_index % suggestions.size
+          suggestions[idx]
+        end
+
+        def command_completion_up
+          suggestions = command_suggestions
+          return if suggestions.empty?
+
+          @command_completion_index = (@command_completion_index - 1) % suggestions.size
+        end
+
+        def command_completion_down
+          suggestions = command_suggestions
+          return if suggestions.empty?
+
+          @command_completion_index = (@command_completion_index + 1) % suggestions.size
+        end
+
+        def accept_command_completion!
+          suggestion = current_command_suggestion
+          return unless suggestion
+
+          cmd, = suggestion
+          @input_buffer.clear
+          @input_buffer << cmd
+          @cursor_position = @input_buffer.length
+          @command_completion_index = 0
+        end
+
+        # Reset index when the buffer changes so selection stays coherent.
+        def reset_command_completion_index
+          @command_completion_index = 0
+        end
+
+        private
+
+        def merged_command_descriptions
+          base = COMMAND_INFO.dup
+          base.merge!(RubyCoded.plugin_registry.all_command_descriptions) if RubyCoded.respond_to?(:plugin_registry)
+          base
+        end
+      end
+    end
+  end
+end