ruby_coded 0.3.1 → 0.4.0

data/lib/ruby_coded/chat/codex_bridge/tool_approval.rb

@@ -3,46 +3,22 @@
 module RubyCoded
   module Chat
     class CodexBridge
-      # Manages interactive approval flow for tool calls in agentic mode.
+      # Interactive approval flow for tool calls in the Codex backend.
+      # Uses the shared ExecutionPolicy for the confirmation decision
+      # and BridgeCommon for polling/applying the user's response.
       module ToolApproval
         private
 
         def request_approval(_tool_call, display_name, args, risk)
           args_summary = args.map { |k, v| "#{k}: #{v}" }.join(", ")
 
-          if risk == Tools::BaseTool::SAFE_RISK || @state.auto_approve_tools?
-            @state.add_message(:tool_call, "[#{display_name}] #{args_summary}")
-          else
-            risk_label = risk == Tools::BaseTool::DANGEROUS_RISK ? "DANGEROUS" : "WRITE"
-            @state.request_tool_confirmation!(display_name, args, risk_label: risk_label)
+          if @policy.requires_confirmation?(risk, @mode)
+            @state.request_tool_confirmation!(display_name, args,
+                                              risk_label: @policy.risk_label_for(risk))
             decision = poll_tool_decision
             apply_tool_decision(decision, display_name)
-          end
-        end
-
-        def poll_tool_decision
-          @state.mutex.synchronize do
-            loop do
-              return :cancelled if @cancel_requested
-
-              resp = @state.instance_variable_get(:@tool_confirmation_response)
-              return resp if %i[approved rejected].include?(resp)
-
-              @state.tool_cv.wait(@state.mutex, 0.1)
-            end
-          end
-        end
-
-        def apply_tool_decision(decision, display_name)
-          case decision
-          when :cancelled
-            @state.clear_tool_confirmation!
-            raise Tools::AgentCancelledError, "Operation cancelled by user"
-          when :approved
-            @state.resolve_tool_confirmation!(:approved)
-          when :rejected
-            @state.resolve_tool_confirmation!(:rejected)
-            raise Tools::ToolRejectedError, "User rejected #{display_name}"
+          else
+            @state.add_message(:tool_call, "[#{display_name}] #{args_summary}")
           end
         end
       end

data/lib/ruby_coded/chat/codex_bridge/tool_handling.rb

@@ -29,11 +29,9 @@ module RubyCoded
           name = tool_call[:name]
           args = parse_tool_arguments(tool_call[:arguments])
           display_name = short_tool_name(name)
-          risk = @tool_registry.risk_level_for(name)
 
-          increment_call_counts(risk)
-          check_tool_limits!
-          warn_approaching_limit
+          risk = @policy.register_call!(name)
+          @policy.warn_if_approaching_limit!
 
           request_approval(tool_call, display_name, args, risk)
           result = run_tool(name, args)
@@ -49,7 +47,7 @@ module RubyCoded
         end
 
         def run_tool(name, args)
-          tool_instances = @agentic_mode ? @tool_registry.build_tools : @tool_registry.build_readonly_tools
+          tool_instances = @mode.allows_mutation? ? @tool_registry.build_tools : @tool_registry.build_readonly_tools
           tool = tool_instances.find { |t| tool_name_match?(t, name) }
 
           return { error: "Unknown tool: #{name}" } unless tool
@@ -90,35 +88,6 @@ module RubyCoded
           perform_codex_request(nil)
         end
 
-        def increment_call_counts(risk)
-          @tool_call_count += 1
-          @write_tool_call_count += 1 unless risk == Tools::BaseTool::SAFE_RISK
-        end
-
-        def check_tool_limits!
-          if @write_tool_call_count >= MAX_WRITE_TOOL_ROUNDS
-            @write_tool_call_count = 0
-            @state.add_message(:system,
-                               "Write tool call budget (#{MAX_WRITE_TOOL_ROUNDS}) reached — auto-resetting counter.")
-          end
-
-          return unless @tool_call_count > MAX_TOTAL_TOOL_ROUNDS
-
-          raise Tools::AgentIterationLimitError,
-                "Reached maximum of #{MAX_TOTAL_TOOL_ROUNDS} total tool calls. " \
-                "Send a new message to continue, or use /agent on to reset counters."
-        end
-
-        def warn_approaching_limit
-          threshold = (MAX_TOTAL_TOOL_ROUNDS * TOOL_ROUNDS_WARNING_THRESHOLD).to_i
-          return unless @tool_call_count == threshold
-
-          remaining = MAX_TOTAL_TOOL_ROUNDS - threshold
-          @state.add_message(:system,
-                             "Approaching total tool call limit: #{remaining} calls remaining. " \
-                             "Prioritize completing the most important work.")
-        end
-
         def short_tool_name(name)
           name.split("--").last
         end

data/lib/ruby_coded/chat/codex_bridge.rb

@@ -9,7 +9,12 @@ require_relative "../tools/system_prompt"
 require_relative "../tools/plan_system_prompt"
 require_relative "../tools/agent_cancelled_error"
 require_relative "../tools/agent_iteration_limit_error"
+require_relative "../tools/execution_policy"
+require_relative "../skills"
 require_relative "../auth/jwt_decoder"
+require_relative "runtime_mode"
+require_relative "bridge_common"
+require_relative "prompt_builder"
 require_relative "codex_bridge/request_builder"
 require_relative "codex_bridge/sse_parser"
 require_relative "codex_bridge/tool_handling"
@@ -32,6 +37,7 @@ module RubyCoded
     # Implements the same public interface as LLMBridge so App can
     # swap between them based on the active auth_method.
     class CodexBridge
+      include BridgeCommon
       include RequestBuilder
       include SSEParser
       include ToolHandling
@@ -44,22 +50,27 @@ module RubyCoded
 
       MAX_RATE_LIMIT_RETRIES = 2
       RATE_LIMIT_BASE_DELAY = 2
-      MAX_WRITE_TOOL_ROUNDS = 50
-      MAX_TOTAL_TOOL_ROUNDS = 200
-      TOOL_ROUNDS_WARNING_THRESHOLD = 0.8
+      MAX_WRITE_TOOL_ROUNDS = Tools::ExecutionPolicy::MAX_WRITE_TOOL_ROUNDS
+      MAX_TOTAL_TOOL_ROUNDS = Tools::ExecutionPolicy::MAX_TOTAL_TOOL_ROUNDS
       MAX_TOOL_RESULT_CHARS = 10_000
 
-      attr_reader :agentic_mode, :plan_mode, :project_root
+      attr_reader :mode, :project_root
 
-      def initialize(state, credentials_store:, auth_manager:, project_root: Dir.pwd)
+      def initialize(state, credentials_store:, auth_manager:, project_root: Dir.pwd, skill_catalog: nil)
         @state = state
         @credentials_store = credentials_store
         @auth_manager = auth_manager
         @project_root = project_root
-        @cancel_requested = @agentic_mode = @plan_mode = false
-        @model = state.model
+        @skill_catalog = skill_catalog || RubyCoded::Skills::Catalog.new(project_root: @project_root)
+        initialize_runtime_state
+      end
+
+      def initialize_runtime_state
+        @cancel_requested = false
+        @mode = RuntimeMode.chat
+        @model = @state.model
         @conversation_history = []
-        @tool_registry = Tools::Registry.new(project_root: @project_root)
+        setup_agent_pipeline!
         reset_call_counts
         @conn = build_connection
       end
@@ -74,52 +85,26 @@ module RubyCoded
         end
       end
 
-      def cancel!
-        @cancel_requested = true
-        @state.mutex.synchronize { @state.tool_cv.signal }
-      end
-
       def reset_chat!(model_name)
         @model = model_name
         @conversation_history = []
       end
 
-      def toggle_agentic_mode!(enabled)
-        @agentic_mode = enabled
-        @state.agentic_mode = enabled
-        if enabled && @plan_mode
-          @plan_mode = false
-          @state.deactivate_plan_mode!
-        end
-        @state.disable_auto_approve! unless enabled
-      end
-
-      def toggle_plan_mode!(enabled)
-        @plan_mode = enabled
-        return unless enabled && @agentic_mode
-
-        @agentic_mode = false
-        @state.agentic_mode = false
-        @state.disable_auto_approve!
-      end
-
-      def approve_tool!
-        @state.tool_confirmation_response = :approved
+      def reset_agent_session!
+        @policy.reset_counters!
+        @conversation_history = []
       end
 
-      def approve_all_tools!
-        @state.enable_auto_approve!
-        @state.tool_confirmation_response = :approved
-      end
+      private
 
-      def reject_tool!
-        @state.tool_confirmation_response = :rejected
-      end
-
-      def reset_agent_session!
-        @tool_call_count = 0
-        @write_tool_call_count = 0
-        @conversation_history = []
+      def setup_agent_pipeline!
+        @tool_registry = Tools::Registry.new(project_root: @project_root)
+        @policy = Tools::ExecutionPolicy.new(state: @state, registry: @tool_registry)
+        @prompt_builder = PromptBuilder.new(
+          project_root: @project_root,
+          skill_catalog: @skill_catalog,
+          chat_base: :simple
+        )
       end
     end
   end

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

@@ -21,7 +21,7 @@ module RubyCoded
         end
 
         def enable_agent_mode
-          if @llm_bridge.agentic_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.")
@@ -34,7 +34,7 @@ module RubyCoded
         end
 
         def disable_agent_mode
-          unless @llm_bridge.agentic_mode
+          unless @llm_bridge.agentic_mode?
             @state.add_message(:system, "Agent mode is already disabled.")
             return
           end
@@ -44,7 +44,7 @@ module RubyCoded
         end
 
         def show_agent_status
-          status = @llm_bridge.agentic_mode ? "enabled" : "disabled"
+          status = @llm_bridge.agentic_mode? ? "enabled" : "disabled"
           @state.add_message(:system, "Agent mode: #{status}. Use /agent on or /agent off to toggle.")
         end
       end

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

@@ -41,7 +41,7 @@ module RubyCoded
         end
 
         def deactivate_agent_if_needed
-          return unless @llm_bridge.agentic_mode
+          return unless @llm_bridge.agentic_mode?
 
           @llm_bridge.toggle_agentic_mode!(false)
           @state.add_message(:system, "Agent mode disabled.")

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class CommandHandler
+      # Slash commands for managing project-local skills.
+      module SkillCommands
+        private
+
+        def cmd_skills(rest)
+          case rest&.strip&.downcase
+          when "reload"
+            reload_skills
+          when "list"
+            list_skills
+          else
+            @state.add_message(:system, "Usage: /skills [reload|list]")
+          end
+        end
+
+        def reload_skills
+          return missing_skill_catalog unless @skill_catalog
+
+          report = @skill_catalog.reload!
+          @state.add_message(:system, format_skill_reload_message(report))
+        end
+
+        def list_skills
+          return missing_skill_catalog unless @skill_catalog
+
+          skills = @skill_catalog.all_skills
+          return show_empty_skills if skills.empty?
+
+          @state.add_message(:system, formatted_skills(skills))
+        end
+
+        def missing_skill_catalog
+          @state.add_message(:system, "Skill catalog is not available.")
+        end
+
+        def show_empty_skills
+          @state.add_message(
+            :system,
+            "No project skills loaded. Add markdown files under .rubycoded/skills and run /skills reload."
+          )
+        end
+
+        def formatted_skills(skills)
+          lines = ["Project skills:"]
+          skills.each do |skill|
+            lines << format_skill_line(skill)
+          end
+          lines.join("\n")
+        end
+
+        def format_skill_line(skill)
+          modes = skill.modes.join(", ")
+          "  #{skill.name.ljust(24)} #{skill.description} [modes: #{modes}]"
+        end
+
+        def format_skill_reload_message(report)
+          message = skill_reload_summary(report)
+          details = skill_reload_details(report)
+
+          details.empty? ? message : "#{message}\n#{details.join("\n")}"
+        end
+
+        def skill_reload_summary(report)
+          "Skills reloaded. " \
+            "Added: #{report[:added]}, removed: #{report[:removed]}, " \
+            "total skills: #{report[:total]}, invalid files ignored: #{report[:invalid]}, " \
+            "duplicates ignored: #{report[:duplicates]}."
+        end
+
+        def skill_reload_details(report)
+          invalid_files = Array(report[:invalid_files])
+          duplicate_skills = Array(report[:duplicate_skills])
+
+          details = []
+          details << "Invalid files: #{invalid_files.join(", ")}" if invalid_files.any?
+          details << "Duplicate skills: #{duplicate_skills.join(", ")}" if duplicate_skills.any?
+          details
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/command_handler.rb

@@ -10,6 +10,7 @@ require_relative "command_handler/agent_commands"
 require_relative "command_handler/plan_commands"
 require_relative "command_handler/login_commands"
 require_relative "command_handler/custom_commands"
+require_relative "command_handler/skill_commands"
 
 module RubyCoded
   module Chat
@@ -25,6 +26,7 @@ module RubyCoded
       include PlanCommands
       include LoginCommands
       include CustomCommands
+      include SkillCommands
 
       HELP_TEXT = File.read(File.join(__dir__, "help.txt")).freeze
 
@@ -35,6 +37,7 @@ module RubyCoded
         @credentials_store = deps[:credentials_store]
         @auth_manager = deps[:auth_manager]
         @command_catalog = command_catalog
+        @skill_catalog = deps[:skill_catalog]
         @commands = build_command_map
       end
 

data/lib/ruby_coded/chat/llm_bridge/chat_configuration.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class LLMBridge
+      # Applies tool/instruction configuration to the RubyLLM chat based on
+      # the active mode (agentic, plan, or plain chat).
+      module ChatConfiguration
+        private
+
+        def apply_instructions_if_supported(chat, instructions)
+          return unless chat.respond_to?(:with_instructions)
+
+          chat.with_instructions(instructions)
+        end
+
+        def reconfigure_chat!
+          @chat_mutex.synchronize do
+            apply_mode_config!(@chat)
+          end
+        end
+
+        def apply_mode_config!(chat)
+          case @mode.name
+          when :agent then configure_agentic!(chat)
+          when :plan then configure_plan!(chat)
+          else configure_chat!(chat)
+          end
+        end
+
+        def configure_chat!(chat)
+          chat.with_tools(replace: true)
+          apply_instructions_if_supported(chat, @prompt_builder.build(RuntimeMode.chat))
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/llm_bridge/plan_mode.rb

@@ -3,44 +3,15 @@
 module RubyCoded
   module Chat
     class LLMBridge
-      # Plan mode configuration, auto-switching to agent, and clarification handling.
+      # Plan mode configuration and plan/clarification post-processing.
+      # Auto-switch heuristic lives in BridgeCommon.
       module PlanMode
-        IMPLEMENTATION_PATTERNS = [
-          /\bimplement/i,
-          /\bgo ahead/i,
-          /\bproceed/i,
-          /\bexecut/i,
-          /\bejecutar?/i,
-          /\bcomenz/i,
-          /\bcomienz/i,
-          /\bhazlo/i,
-          /\bconstru[iy]/i,
-          /\badelante/i,
-          /\bdale\b/i,
-          /\bdo it/i,
-          /\bbuild it/i
-        ].freeze
-
         private
 
-        def should_auto_switch_to_agent?(input)
-          @plan_mode && @state.current_plan && implementation_request?(input)
-        end
-
-        def implementation_request?(input)
-          IMPLEMENTATION_PATTERNS.any? { |pattern| input.match?(pattern) }
-        end
-
-        def auto_switch_to_agent!
-          toggle_agentic_mode!(true)
-          @state.add_message(:system,
-                             "Plan mode disabled — switching to agent mode to implement the plan.")
-        end
-
         def configure_plan!(chat)
           readonly_tools = @tool_registry.build_readonly_tools
           chat.with_tools(*readonly_tools, replace: true)
-          chat.with_instructions(Tools::PlanSystemPrompt.build(project_root: @project_root))
+          apply_instructions_if_supported(chat, @prompt_builder.build(RuntimeMode.plan))
 
           chat.on_tool_call { |tool_call| handle_tool_call(tool_call) }
           chat.on_tool_result { |result| handle_tool_result(result) }

data/lib/ruby_coded/chat/llm_bridge/tool_call_handling.rb

@@ -8,13 +8,8 @@ module RubyCoded
         private
 
         def configure_agentic!(chat)
-          tools = @tool_registry.build_tools
-          chat.with_tools(*tools, replace: true)
-          chat.with_instructions(Tools::SystemPrompt.build(
-                                   project_root: @project_root,
-                                   max_write_rounds: MAX_WRITE_TOOL_ROUNDS,
-                                   max_total_rounds: MAX_TOTAL_TOOL_ROUNDS
-                                 ))
+          chat.with_tools(*@tool_registry.build_tools, replace: true)
+          apply_instructions_if_supported(chat, @prompt_builder.build(RuntimeMode.agent))
 
           chat.on_tool_call { |tool_call| handle_tool_call(tool_call) }
           chat.on_tool_result { |result| handle_tool_result(result) }
@@ -24,29 +19,21 @@ module RubyCoded
           raise Tools::AgentCancelledError, "Operation cancelled by user" if @cancel_requested
 
           display_name = short_tool_name(tool_call.name)
-          risk = @tool_registry.risk_level_for(tool_call.name)
-
-          increment_call_counts(risk)
-          check_tool_limits!
-          warn_approaching_limit
+          risk = @policy.register_call!(tool_call.name)
+          @policy.warn_if_approaching_limit!
 
           process_tool_approval(tool_call, display_name, risk)
         end
 
-        def increment_call_counts(risk)
-          @tool_call_count += 1
-          @write_tool_call_count += 1 unless risk == Tools::BaseTool::SAFE_RISK
-        end
-
         def process_tool_approval(tool_call, display_name, risk)
           args_summary = tool_call.arguments.map { |k, v| "#{k}: #{v}" }.join(", ")
 
-          if risk == Tools::BaseTool::SAFE_RISK || @state.auto_approve_tools?
-            @state.add_message(:tool_call, "[#{display_name}] #{args_summary}")
-          else
-            risk_label = risk == Tools::BaseTool::DANGEROUS_RISK ? "DANGEROUS" : "WRITE"
-            @state.request_tool_confirmation!(display_name, tool_call.arguments, risk_label: risk_label)
+          if @policy.requires_confirmation?(risk, @mode)
+            @state.request_tool_confirmation!(display_name, tool_call.arguments,
+                                              risk_label: @policy.risk_label_for(risk))
             wait_for_confirmation(tool_call)
+          else
+            @state.add_message(:tool_call, "[#{display_name}] #{args_summary}")
           end
         end
 
@@ -92,34 +79,6 @@ module RubyCoded
           @state.add_message(:tool_result, text)
         end
 
-        def check_tool_limits!
-          if @write_tool_call_count >= MAX_WRITE_TOOL_ROUNDS
-            @write_tool_call_count = 0
-            @state.add_message(:system,
-                               "Write tool call budget (#{MAX_WRITE_TOOL_ROUNDS}) reached — auto-resetting counter.")
-          end
-
-          return unless @tool_call_count > MAX_TOTAL_TOOL_ROUNDS
-
-          raise Tools::AgentIterationLimitError,
-                "Reached maximum of #{MAX_TOTAL_TOOL_ROUNDS} total tool calls. " \
-                "Send a new message to continue, or use /agent on to reset counters."
-        end
-
-        def warn_approaching_limit
-          warn_limit(@tool_call_count, MAX_TOTAL_TOOL_ROUNDS, "total")
-        end
-
-        def warn_limit(count, max, label)
-          warning_at = (max * TOOL_ROUNDS_WARNING_THRESHOLD).to_i
-          return unless count == warning_at
-
-          remaining = max - count
-          @state.add_message(:system,
-                             "Approaching #{label} tool call limit: #{remaining} calls remaining. " \
-                             "Prioritize completing the most important work.")
-        end
-
         def short_tool_name(name)
           name.split("--").last
         end