ruby_coded 0.2.1 → 0.3.0

data/lib/ruby_coded/chat/command_handler.rb

@@ -9,12 +9,13 @@ require_relative "command_handler/token_commands"
 require_relative "command_handler/agent_commands"
 require_relative "command_handler/plan_commands"
 require_relative "command_handler/login_commands"
+require_relative "command_handler/custom_commands"
 
 module RubyCoded
   module Chat
     # Handles slash commands entered in the chat input.
-    # Base commands are always available; plugins can contribute
-    # additional commands via the plugin registry.
+    # Commands are resolved from a unified command catalog, which may
+    # include core commands, plugin commands, and markdown commands.
     class CommandHandler
       include ModelCommands
       include HistoryCommands
@@ -23,28 +24,17 @@ module RubyCoded
       include AgentCommands
       include PlanCommands
       include LoginCommands
-
-      BASE_COMMANDS = {
-        "/help" => :cmd_help,
-        "/exit" => :cmd_exit,
-        "/quit" => :cmd_exit,
-        "/clear" => :cmd_clear,
-        "/model" => :cmd_model,
-        "/history" => :cmd_history,
-        "/tokens" => :cmd_tokens,
-        "/agent" => :cmd_agent,
-        "/plan" => :cmd_plan,
-        "/login" => :cmd_login
-      }.freeze
+      include CustomCommands
 
       HELP_TEXT = File.read(File.join(__dir__, "help.txt")).freeze
 
-      def initialize(state, llm_bridge:, user_config: nil, credentials_store: nil, auth_manager: nil)
+      def initialize(state, llm_bridge:, command_catalog: nil, **deps)
         @state = state
         @llm_bridge = llm_bridge
-        @user_config = user_config
-        @credentials_store = credentials_store
-        @auth_manager = auth_manager
+        @user_config = deps[:user_config]
+        @credentials_store = deps[:credentials_store]
+        @auth_manager = deps[:auth_manager]
+        @command_catalog = command_catalog
         @commands = build_command_map
       end
 
@@ -53,31 +43,49 @@ module RubyCoded
         return if stripped.empty?
 
         command, rest = stripped.split(" ", 2)
-        method_name = @commands[command.downcase]
-
-        if method_name
-          send(method_name, rest)
-        else
-          @state.add_message(:system, "Unknown command: #{command}. Type /help for available commands.")
-        end
+        dispatch_command(command, rest)
       end
 
       private
 
+      def dispatch_command(command, rest)
+        normalized = command.downcase
+        method_name = @commands[normalized]
+        return send(method_name, rest) if method_name
+
+        dispatch_dynamic_command(command, normalized, rest)
+      end
+
+      def dispatch_dynamic_command(command, normalized, rest)
+        definition = @command_catalog&.find(normalized)
+        return handle_markdown_command(definition, rest) if definition&.markdown?
+
+        @state.add_message(:system, "Unknown command: #{command}. Type /help for available commands.")
+      end
+
       def build_command_map
-        cmds = BASE_COMMANDS.dup
-        cmds.merge!(RubyCoded.plugin_registry.all_commands)
-        cmds
+        return {} unless @command_catalog
+
+        @command_catalog.command_map
       end
 
       def cmd_help(_rest)
-        text = HELP_TEXT.dup
-        plugin_descs = RubyCoded.plugin_registry.all_command_descriptions
-        unless plugin_descs.empty?
-          text += "\nPlugin commands:\n"
-          plugin_descs.each { |cmd, desc| text += "  #{cmd.ljust(18)} #{desc}\n" }
-        end
-        @state.add_message(:system, text)
+        lines = ["Available commands:"]
+        lines.concat(command_help_lines)
+        append_static_help(lines)
+        @state.add_message(:system, lines.join("\n"))
+      end
+
+      def command_help_lines
+        @command_catalog.all_definitions.map { |definition| formatted_command_line(definition) }
+      end
+
+      def append_static_help(lines)
+        static_help = HELP_TEXT.strip
+        return if static_help.empty?
+
+        lines << ""
+        lines << static_help
       end
 
       def cmd_exit(_rest)
@@ -88,6 +96,26 @@ module RubyCoded
         @state.clear_messages!
         @state.add_message(:system, "Conversation cleared.")
       end
+
+      def handle_markdown_command(definition, rest)
+        prompt = build_markdown_prompt(definition, rest)
+
+        @state.add_message(:system, "Running custom command #{definition.name}...")
+        @state.add_message(:user, prompt)
+        @llm_bridge.send_async(prompt)
+      end
+
+      def build_markdown_prompt(definition, rest)
+        extra = rest.to_s.strip
+        return definition.content if extra.empty?
+
+        <<~PROMPT
+          #{definition.content}
+
+          Additional user input:
+          #{extra}
+        PROMPT
+      end
     end
   end
 end

data/lib/ruby_coded/chat/help.txt

@@ -1,23 +1,3 @@
-Available commands:
-  /help              Show this help message
-  /model             Select a model from available providers
-  /model <name>      Switch directly to a named model
-  /model --all       Select from all models (including deprecated)
-  /clear             Clear the conversation history
-  /history           Show conversation summary
-  /tokens            Show detailed token usage and cost for this session
-  /agent             Show agent mode status
-  /agent on          Enable agent mode (tools for file operations)
-  /agent off         Disable agent mode (chat only)
-  /plan              Show plan mode status
-  /plan on           Enable plan mode (structured development planning)
-  /plan off          Disable plan mode (warns if unsaved plan)
-  /plan off --force  Disable plan mode discarding unsaved plan
-  /plan save [file]  Save current plan to a markdown file
-  /login             Authenticate with an AI provider
-  /login <provider>  Authenticate directly with a specific provider (openai, anthropic)
-  /exit, /quit       Exit the chat
-
 Tool confirmations (agent mode):
   [y] / Enter        Approve the current tool call
   [n] / Esc          Reject the current tool call

data/lib/ruby_coded/chat/renderer/model_selector.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../codex_models"
+
 module RubyCoded
   module Chat
     class Renderer
@@ -88,7 +90,8 @@ module RubyCoded
           id = model.respond_to?(:id) ? model.id : model.to_s
           provider = model.respond_to?(:provider) ? model.provider : "unknown"
           current_marker = id == @state.model ? " *" : ""
-          "#{id} (#{provider})#{current_marker}"
+          pro_marker = CodexModels.pro_only?(id) ? " (Pro only)" : ""
+          "#{id} (#{provider})#{pro_marker}#{current_marker}"
         end
       end
     end

data/lib/ruby_coded/chat/renderer/status_bar.rb

@@ -30,9 +30,16 @@ module RubyCoded
           left = " ↑#{format_number(input_tok)} ↓#{format_number(output_tok)}"
           left << " 💭#{format_number(thinking_tok)}" if thinking_tok.positive?
           left << " (#{format_number(total_tok)} tokens)"
+          left << " | #{format_context_usage(@state.session_context_usage_percentage)}"
           left
         end
 
+        def format_context_usage(percentage)
+          return "Ctx: N/A" if percentage.nil?
+
+          "Ctx: #{percentage}%"
+        end
+
         def format_number(num)
           num.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
         end

data/lib/ruby_coded/chat/state/context_window.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "ruby_llm"
+require_relative "../codex_models"
+
+module RubyCoded
+  module Chat
+    class State
+      # Resolves current model context window and computes live context usage
+      # based on the last turn's server-reported `usage` block. This reflects
+      # the size of the prompt actually sent to the model on the most recent
+      # request, not the total tokens spent in the session.
+      module ContextWindow
+        def current_model_context_window
+          model_name = @model
+          return unless model_name
+
+          codex_model = CodexModels.find(model_name)
+          return codex_model.context_window if codex_model.respond_to?(:context_window)
+
+          resolve_ruby_llm_context_window(model_name)
+        end
+
+        def session_context_tokens_used
+          last_turn_context_tokens
+        end
+
+        def session_context_usage_percentage
+          context_window = current_model_context_window
+          return nil unless context_window.to_i.positive?
+
+          percentage = ((session_context_tokens_used.to_f / context_window) * 100).round
+          percentage.clamp(0, 100)
+        end
+
+        private
+
+        def resolve_ruby_llm_context_window(model_name)
+          info = RubyLLM.models.find(model_name)
+          return info.context_window if info.respond_to?(:context_window) && info.context_window
+          return info.max_context_window if info.respond_to?(:max_context_window) && info.max_context_window
+
+          metadata_context_window(info)
+        rescue StandardError
+          nil
+        end
+
+        def metadata_context_window(info)
+          return unless info.respond_to?(:metadata)
+
+          metadata = info.metadata
+          return unless metadata.is_a?(Hash)
+
+          metadata[:context_window] || metadata["context_window"]
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/state/message_token_tracking.rb

@@ -35,6 +35,22 @@ module RubyCoded
           end
         end
 
+        # Live size of the model's context window as reported by the last
+        # turn that carried usage info. Bridges (both API and Codex) are
+        # effectively stateless: every request re-sends the full history,
+        # so the server-reported `input_tokens` of the latest turn already
+        # represents the full live prompt. Summing across turns would
+        # double-count. We fall back to 0 when no turn has reported usage
+        # yet.
+        def last_turn_context_tokens
+          @mutex.synchronize do
+            last = @messages.reverse_each.find { |m| m[:input_tokens].to_i.positive? }
+            return 0 unless last
+
+            last[:input_tokens].to_i + last[:output_tokens].to_i + last[:thinking_tokens].to_i
+          end
+        end
+
         def token_usage_by_model
           @mutex.synchronize do
             @token_usage_by_model.transform_values(&:dup)

data/lib/ruby_coded/chat/state.rb

@@ -8,6 +8,7 @@ require_relative "state/scrollable"
 require_relative "state/tool_confirmation"
 require_relative "state/plan_tracking"
 require_relative "state/token_cost"
+require_relative "state/context_window"
 require_relative "state/login_flow"
 
 module RubyCoded
@@ -22,17 +23,19 @@ module RubyCoded
       include ToolConfirmation
       include PlanTracking
       include TokenCost
+      include ContextWindow
       include LoginFlow
 
       attr_reader :input_buffer, :cursor_position, :input_scroll_offset, :messages, :scroll_offset,
                   :mode, :model_list, :model_select_index, :model_select_filter,
-                  :streaming, :mutex, :tui_suspend_reason
-      attr_accessor :model, :should_quit, :codex_mode
+                  :streaming, :mutex, :tui_suspend_reason, :command_catalog, :model
+      attr_accessor :should_quit, :codex_mode
 
       MIN_RENDER_INTERVAL = 0.05
 
-      def initialize(model:)
+      def initialize(model:, command_catalog: nil)
         @model = model
+        @command_catalog = command_catalog
         # String.new: literals like "" are frozen under frozen_string_literal
         @input_buffer = String.new
         @cursor_position = 0
@@ -61,6 +64,13 @@ module RubyCoded
         init_plugin_state
       end
 
+      def model=(value)
+        return if @model == value
+
+        @model = value
+        mark_dirty!
+      end
+
       def streaming=(value)
         @streaming = value
         mark_dirty!
@@ -83,6 +93,12 @@ module RubyCoded
         @should_quit
       end
 
+      def command_descriptions
+        return {} unless @command_catalog
+
+        @command_catalog.command_descriptions
+      end
+
       def dirty?
         @mutex.synchronize do
           return false unless @dirty

data/lib/ruby_coded/commands/catalog.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require_relative "core_provider"
+require_relative "plugin_provider"
+require_relative "markdown_provider"
+
+module RubyCoded
+  module Commands
+    # Merges core, plugin, and markdown commands into a single catalog.
+    # rubocop:disable Metrics/ClassLength
+    class Catalog
+      SOURCE_PRIORITY = {
+        markdown: 1,
+        plugin: 2,
+        core: 3
+      }.freeze
+
+      def initialize(project_root:, plugin_registry:)
+        @project_root = project_root
+        @plugin_registry = plugin_registry
+        @last_reload_report = nil
+      end
+
+      def all_definitions
+        merged.values.sort_by { |definition| definition.name.downcase }
+      end
+
+      def command_map
+        all_definitions.filter_map { |definition| command_pair(definition) }.to_h
+      end
+
+      def command_descriptions
+        all_definitions.to_h { |definition| [definition.name, definition.description] }
+      end
+
+      def find(name)
+        merged[name.downcase]
+      end
+
+      def definitions_for_source(source)
+        all_definitions.select { |definition| definition.source == source }
+      end
+
+      def reload!
+        previous_markdown_names = cached_markdown_names
+        clear_cached_reports!
+        current_markdown_names = markdown_names
+        @last_reload_report = build_reload_report(previous_markdown_names, current_markdown_names)
+      end
+
+      def last_reload_report
+        @last_reload_report || default_reload_report
+      end
+
+      private
+
+      def command_pair(definition)
+        return unless definition.handler
+
+        [definition.name.downcase, definition.handler]
+      end
+
+      def cached_markdown_names
+        return [] unless @merged
+
+        definitions_for_source(:markdown).map { |definition| definition.name.downcase }
+      end
+
+      def markdown_names
+        definitions_for_source(:markdown).map { |definition| definition.name.downcase }
+      end
+
+      def clear_cached_reports!
+        @markdown_report = nil
+        @merged = nil
+      end
+
+      def build_reload_report(previous_names, current_names)
+        conflicts = markdown_conflicts
+
+        base_reload_report(previous_names, current_names).merge(
+          conflicts: conflicts.size,
+          conflict_commands: conflicts.map { |conflict| conflict[:command] },
+          conflict_files: conflicts.map { |conflict| conflict[:file] }
+        )
+      end
+
+      def base_reload_report(previous_names, current_names)
+        {
+          total: current_names.size,
+          added: (current_names - previous_names).size,
+          removed: (previous_names - current_names).size,
+          invalid: markdown_report[:invalid_count],
+          invalid_files: markdown_report[:invalid_files]
+        }
+      end
+
+      def default_reload_report
+        build_reload_report([], markdown_names).merge(added: 0)
+      end
+
+      def merged
+        @merged ||= begin
+          result = {}
+          providers.each { |provider| merge_provider!(result, provider) }
+          result
+        end
+      end
+
+      def merge_provider!(result, provider)
+        provider.definitions.each { |definition| merge_definition!(result, definition) }
+      end
+
+      def merge_definition!(result, definition)
+        key = definition.name.downcase
+        existing = result[key]
+        return if existing && priority(definition.source) <= priority(existing.source)
+
+        result[key] = definition
+      end
+
+      def providers
+        [
+          markdown_provider,
+          PluginProvider.new(registry: @plugin_registry),
+          CoreProvider.new
+        ]
+      end
+
+      def markdown_provider
+        @markdown_provider ||= MarkdownProvider.new(project_root: @project_root)
+      end
+
+      def markdown_report
+        @markdown_report ||= markdown_provider.load_report
+      end
+
+      def markdown_conflicts
+        markdown_report[:definitions].filter_map { |definition| build_conflict(definition) }
+      end
+
+      def build_conflict(definition)
+        return unless reserved_command_names.include?(definition.name.downcase)
+
+        {
+          command: definition.name,
+          file: definition.path ? File.basename(definition.path) : definition.name
+        }
+      end
+
+      def reserved_command_names
+        @reserved_command_names ||= (core_command_names + plugin_command_names).uniq
+      end
+
+      def core_command_names
+        CoreProvider.new.definitions.map { |definition| definition.name.downcase }
+      end
+
+      def plugin_command_names
+        provider = PluginProvider.new(registry: @plugin_registry)
+        provider.definitions.map { |definition| definition.name.downcase }
+      end
+
+      def priority(source)
+        SOURCE_PRIORITY.fetch(source, 0)
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/ruby_coded/commands/command_definition.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Commands
+    # Normalized command metadata shared by core, plugin, and markdown commands.
+    class CommandDefinition
+      ATTRIBUTES = %i[name description handler source usage content path].freeze
+
+      attr_reader(*ATTRIBUTES)
+
+      def initialize(**attrs)
+        ATTRIBUTES.each { |name| instance_variable_set(ivar(name), attrs[name]) }
+      end
+
+      def markdown?
+        @source == :markdown
+      end
+
+      def executable?
+        !@handler.nil? || markdown?
+      end
+
+      private
+
+      def ivar(name)
+        :"@#{name}"
+      end
+    end
+  end
+end

data/lib/ruby_coded/commands/core_provider.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative "command_definition"
+
+module RubyCoded
+  module Commands
+    # Provides built-in slash commands.
+    class CoreProvider
+      DEFINITIONS = [
+        {
+          name: "/help",
+          description: "Show help message",
+          handler: :cmd_help,
+          source: :core,
+          usage: "/help"
+        },
+        {
+          name: "/exit",
+          description: "Exit the chat",
+          handler: :cmd_exit,
+          source: :core,
+          usage: "/exit"
+        },
+        {
+          name: "/quit",
+          description: "Exit the chat",
+          handler: :cmd_exit,
+          source: :core,
+          usage: "/quit"
+        },
+        {
+          name: "/clear",
+          description: "Clear conversation history",
+          handler: :cmd_clear,
+          source: :core,
+          usage: "/clear"
+        },
+        {
+          name: "/model",
+          description: "Select a model from available providers",
+          handler: :cmd_model,
+          source: :core,
+          usage: "/model [name|--all]"
+        },
+        {
+          name: "/history",
+          description: "Show conversation summary",
+          handler: :cmd_history,
+          source: :core,
+          usage: "/history"
+        },
+        {
+          name: "/tokens",
+          description: "Show detailed token usage and cost",
+          handler: :cmd_tokens,
+          source: :core,
+          usage: "/tokens"
+        },
+        {
+          name: "/agent",
+          description: "Toggle agent mode (on/off)",
+          handler: :cmd_agent,
+          source: :core,
+          usage: "/agent [on|off]"
+        },
+        {
+          name: "/plan",
+          description: "Toggle plan mode (on/off/save)",
+          handler: :cmd_plan,
+          source: :core,
+          usage: "/plan [on|off|save [file]]"
+        },
+        {
+          name: "/login",
+          description: "Authenticate with an AI provider",
+          handler: :cmd_login,
+          source: :core,
+          usage: "/login [provider]"
+        },
+        {
+          name: "/commands",
+          description: "Manage custom markdown commands",
+          handler: :cmd_commands,
+          source: :core,
+          usage: "/commands [reload|list]"
+        }
+      ].freeze
+
+      def definitions
+        DEFINITIONS.map { |attrs| CommandDefinition.new(**attrs) }
+      end
+    end
+  end
+end