console_agent 0.10.0 → 0.12.0

data/lib/console_agent/executor.rb

@@ -43,11 +43,12 @@ module ConsoleAgent
   class Executor
     CODE_REGEX = /```ruby\s*\n(.*?)```/m
 
-    attr_reader :binding_context, :last_error
+    attr_reader :binding_context, :last_error, :last_safety_error, :last_safety_exception
     attr_accessor :on_prompt
 
-    def initialize(binding_context)
+    def initialize(binding_context, channel: nil)
       @binding_context = binding_context
+      @channel = channel
       @omitted_outputs = {}
       @omitted_counter = 0
       @output_store = {}
@@ -59,18 +60,27 @@ module ConsoleAgent
       match ? match[1].strip : ''
     end
 
+    # Matches any fenced code block (```anything ... ```)
+    ANY_CODE_FENCE_REGEX = /```\w*\s*\n.*?```/m
+
     def display_response(response)
       code = extract_code(response)
-      explanation = response.gsub(CODE_REGEX, '').strip
-
-      $stdout.puts
-      $stdout.puts colorize(explanation, :cyan) unless explanation.empty?
+      explanation = response.gsub(ANY_CODE_FENCE_REGEX, '').strip
 
-      unless code.empty?
+      if @channel
         $stdout.puts
-        $stdout.puts colorize("# Generated code:", :yellow)
-        $stdout.puts highlight_code(code)
+        @channel.display(explanation) unless explanation.empty?
+        @channel.display_code(code) unless code.empty?
+      else
         $stdout.puts
+        $stdout.puts colorize(explanation, :cyan) unless explanation.empty?
+
+        unless code.empty?
+          $stdout.puts
+          $stdout.puts colorize("# Generated code:", :yellow)
+          $stdout.puts highlight_code(code)
+          $stdout.puts
+        end
       end
 
       code
@@ -80,29 +90,58 @@ module ConsoleAgent
       return nil if code.nil? || code.strip.empty?
 
       @last_error = nil
+      @last_safety_error = false
+      @last_safety_exception = nil
       captured_output = StringIO.new
       old_stdout = $stdout
       # Tee output: capture it and also print to the real stdout
       $stdout = TeeIO.new(old_stdout, captured_output)
 
-      result = binding_context.eval(code, "(console_agent)", 1)
+      result = with_safety_guards do
+        binding_context.eval(code, "(console_agent)", 1)
+      end
 
       $stdout = old_stdout
+
+      # Send captured puts output through channel before the return value
+      if @channel && !captured_output.string.empty?
+        @channel.display_result_output(captured_output.string)
+      end
+
       display_result(result)
 
       @last_output = captured_output.string
       result
+    rescue ConsoleAgent::SafetyError => e
+      $stdout = old_stdout if old_stdout
+      @last_error = "SafetyError: #{e.message}"
+      @last_safety_error = true
+      @last_safety_exception = e
+      display_error("Blocked: #{e.message}")
+      @last_output = captured_output&.string
+      nil
     rescue SyntaxError => e
       $stdout = old_stdout if old_stdout
       @last_error = "SyntaxError: #{e.message}"
-      $stderr.puts colorize(@last_error, :red)
+      display_error(@last_error)
       @last_output = nil
       nil
     rescue => e
       $stdout = old_stdout if old_stdout
+      # Check if a SafetyError is wrapped (e.g. ActiveRecord::StatementInvalid wrapping our error)
+      if safety_error?(e)
+        safety_exc = extract_safety_exception(e)
+        safety_msg = safety_exc ? safety_exc.message : e.message
+        @last_error = "SafetyError: #{safety_msg}"
+        @last_safety_error = true
+        @last_safety_exception = safety_exc
+        display_error("Blocked: #{safety_msg}")
+        @last_output = captured_output&.string
+        return nil
+      end
       @last_error = "#{e.class}: #{e.message}"
-      $stderr.puts colorize("Error: #{@last_error}", :red)
-      e.backtrace.first(3).each { |line| $stderr.puts colorize("  #{line}", :red) }
+      display_error("Error: #{@last_error}")
+      e.backtrace.first(3).each { |line| display_error("  #{line}") }
       @last_output = captured_output&.string
       nil
     end
@@ -138,24 +177,54 @@ module ConsoleAgent
 
       @last_cancelled = false
       @last_answer = nil
-      $stdout.print colorize("Execute? [y/N/edit] ", :yellow)
-      @on_prompt&.call
-      answer = $stdin.gets.to_s.strip.downcase
+      prompt = execute_prompt
+
+      if @channel
+        answer = @channel.confirm(prompt)
+      else
+        $stdout.print colorize(prompt, :yellow)
+        @on_prompt&.call
+        answer = $stdin.gets.to_s.strip.downcase
+        echo_stdin(answer)
+      end
       @last_answer = answer
-      echo_stdin(answer)
 
       loop do
         case answer
         when 'y', 'yes', 'a'
-          return execute(code)
+          result = execute(code)
+          if @last_safety_error
+            return nil unless danger_allowed?
+            return offer_danger_retry(code)
+          end
+          return result
+        when 'd', 'danger'
+          unless danger_allowed?
+            display_error("Safety guards cannot be disabled in this channel.")
+            return nil
+          end
+          if @channel
+            @channel.display_error("Executing with safety guards disabled.")
+          else
+            $stdout.puts colorize("Executing with safety guards disabled.", :red)
+          end
+          return execute_unsafe(code)
         when 'e', 'edit'
-          edited = open_in_editor(code)
+          edited = if @channel && @channel.supports_editing?
+                     @channel.edit_code(code)
+                   else
+                     open_in_editor(code)
+                   end
           if edited && edited != code
             $stdout.puts colorize("# Edited code:", :yellow)
             $stdout.puts highlight_code(edited)
-            $stdout.print colorize("Execute edited code? [y/N] ", :yellow)
-            edit_answer = $stdin.gets.to_s.strip.downcase
-            echo_stdin(edit_answer)
+            if @channel
+              edit_answer = @channel.confirm("Execute edited code? [y/N] ")
+            else
+              $stdout.print colorize("Execute edited code? [y/N] ", :yellow)
+              edit_answer = $stdin.gets.to_s.strip.downcase
+              echo_stdin(edit_answer)
+            end
             if edit_answer == 'y'
               return execute(edited)
             else
@@ -170,43 +239,166 @@ module ConsoleAgent
           @last_cancelled = true
           return nil
         else
-          $stdout.print colorize("Execute? [y/N/edit] ", :yellow)
-          @on_prompt&.call
-          answer = $stdin.gets.to_s.strip.downcase
+          if @channel
+            answer = @channel.confirm(prompt)
+          else
+            $stdout.print colorize(prompt, :yellow)
+            @on_prompt&.call
+            answer = $stdin.gets.to_s.strip.downcase
+            echo_stdin(answer)
+          end
           @last_answer = answer
-          echo_stdin(answer)
         end
       end
     end
 
+    def offer_danger_retry(code)
+      return nil unless danger_allowed?
+
+      exc = @last_safety_exception
+      blocked_key = exc&.blocked_key
+      guard = exc&.guard
+
+      if blocked_key && guard
+        allow_desc = allow_description(guard, blocked_key)
+        $stdout.puts colorize("  [d] re-run with all safe mode disabled", :yellow)
+        $stdout.puts colorize("  [a] allow #{allow_desc} for this session", :yellow)
+        $stdout.puts colorize("  [N] cancel", :yellow)
+        prompt_text = "Choice: "
+      else
+        prompt_text = "Re-run with safe mode disabled? [y/N] "
+      end
+
+      if @channel
+        answer = @channel.confirm(prompt_text)
+      else
+        $stdout.print colorize(prompt_text, :yellow)
+        answer = $stdin.gets.to_s.strip.downcase
+        echo_stdin(answer)
+      end
+
+      case answer
+      when 'a', 'allow'
+        if blocked_key && guard
+          ConsoleAgent.configuration.safety_guards.allow(guard, blocked_key)
+          allow_desc = allow_description(guard, blocked_key)
+          $stdout.puts colorize("Allowed #{allow_desc} for this session.", :green)
+          return execute(code)
+        else
+          if @channel
+            answer = @channel.confirm("Nothing to allow — re-run with safe mode disabled instead? [y/N] ")
+          else
+            $stdout.puts colorize("Nothing to allow — re-run with safe mode disabled instead? [y/N]", :yellow)
+            answer = $stdin.gets.to_s.strip.downcase
+            echo_stdin(answer)
+          end
+        end
+      when 'd', 'danger', 'y', 'yes'
+        $stdout.puts colorize("Executing with safety guards disabled.", :red)
+        return execute_unsafe(code)
+      end
+
+      $stdout.puts colorize("Cancelled.", :yellow)
+      nil
+    end
+
     private
 
+    def danger_allowed?
+      @channel.nil? || @channel.supports_danger?
+    end
+
+    def display_error(msg)
+      if @channel
+        @channel.display_error(msg)
+      else
+        $stderr.puts colorize(msg, :red)
+      end
+    end
+
+    def allow_description(guard, blocked_key)
+      case guard
+      when :database_writes
+        "all writes to #{blocked_key}"
+      when :http_mutations
+        "all HTTP mutations to #{blocked_key}"
+      else
+        "#{blocked_key} for :#{guard}"
+      end
+    end
+
+    def execute_unsafe(code)
+      guards = ConsoleAgent.configuration.safety_guards
+      guards.disable!
+      execute(code)
+    ensure
+      guards.enable!
+    end
+
+    def execute_prompt
+      guards = ConsoleAgent.configuration.safety_guards
+      if !guards.empty? && guards.enabled? && danger_allowed?
+        "Execute? [y/N/edit/danger] "
+      else
+        "Execute? [y/N/edit] "
+      end
+    end
+
+    def with_safety_guards(&block)
+      ConsoleAgent.configuration.safety_guards.wrap(&block)
+    end
+
+    # Check if an exception is or wraps a SafetyError (e.g. AR::StatementInvalid wrapping it)
+    def safety_error?(exception)
+      return true if exception.is_a?(ConsoleAgent::SafetyError)
+      return true if exception.message.include?("ConsoleAgent safe mode")
+      cause = exception.cause
+      while cause
+        return true if cause.is_a?(ConsoleAgent::SafetyError)
+        cause = cause.cause
+      end
+      false
+    end
+
+    def extract_safety_exception(exception)
+      return exception if exception.is_a?(ConsoleAgent::SafetyError)
+      cause = exception.cause
+      while cause
+        return cause if cause.is_a?(ConsoleAgent::SafetyError)
+        cause = cause.cause
+      end
+      nil
+    end
+
     MAX_DISPLAY_LINES = 10
     MAX_DISPLAY_CHARS = 2000
 
     def display_result(result)
-      full = "=> #{result.inspect}"
-      lines = full.lines
-      total_lines = lines.length
-      total_chars = full.length
-
-      if total_lines <= MAX_DISPLAY_LINES && total_chars <= MAX_DISPLAY_CHARS
-        $stdout.puts colorize(full, :green)
+      if @channel
+        @channel.display_result(result)
       else
-        # Truncate by lines first, then by chars
-        truncated = lines.first(MAX_DISPLAY_LINES).join
-        truncated = truncated[0, MAX_DISPLAY_CHARS] if truncated.length > MAX_DISPLAY_CHARS
-        $stdout.puts colorize(truncated, :green)
-
-        omitted_lines = [total_lines - MAX_DISPLAY_LINES, 0].max
-        omitted_chars = [total_chars - truncated.length, 0].max
-        parts = []
-        parts << "#{omitted_lines} lines" if omitted_lines > 0
-        parts << "#{omitted_chars} chars" if omitted_chars > 0
-
-        @omitted_counter += 1
-        @omitted_outputs[@omitted_counter] = full
-        $stdout.puts colorize("  (omitting #{parts.join(', ')})  /expand #{@omitted_counter} to see all", :yellow)
+        full = "=> #{result.inspect}"
+        lines = full.lines
+        total_lines = lines.length
+        total_chars = full.length
+
+        if total_lines <= MAX_DISPLAY_LINES && total_chars <= MAX_DISPLAY_CHARS
+          $stdout.puts colorize(full, :green)
+        else
+          truncated = lines.first(MAX_DISPLAY_LINES).join
+          truncated = truncated[0, MAX_DISPLAY_CHARS] if truncated.length > MAX_DISPLAY_CHARS
+          $stdout.puts colorize(truncated, :green)
+
+          omitted_lines = [total_lines - MAX_DISPLAY_LINES, 0].max
+          omitted_chars = [total_chars - truncated.length, 0].max
+          parts = []
+          parts << "#{omitted_lines} lines" if omitted_lines > 0
+          parts << "#{omitted_chars} chars" if omitted_chars > 0
+
+          @omitted_counter += 1
+          @omitted_outputs[@omitted_counter] = full
+          $stdout.puts colorize("  (omitting #{parts.join(', ')})  /expand #{@omitted_counter} to see all", :yellow)
+        end
       end
     end
 

data/lib/console_agent/providers/base.rb

@@ -30,8 +30,9 @@ module ConsoleAgent
 
       def build_connection(url, headers = {})
         Faraday.new(url: url) do |f|
-          f.options.timeout = config.timeout
-          f.options.open_timeout = config.timeout
+          t = config.respond_to?(:resolved_timeout) ? config.resolved_timeout : config.timeout
+          f.options.timeout = t
+          f.options.open_timeout = t
           f.headers.update(headers)
           f.headers['Content-Type'] = 'application/json'
           f.adapter Faraday.default_adapter
@@ -101,6 +102,10 @@ module ConsoleAgent
       when :openai
         require 'console_agent/providers/openai'
         OpenAI.new(config)
+      when :local
+        require 'console_agent/providers/openai'
+        require 'console_agent/providers/local'
+        Local.new(config)
       else
         raise ConfigurationError, "Unknown provider: #{config.provider}"
       end

data/lib/console_agent/providers/local.rb

@@ -0,0 +1,112 @@
+module ConsoleAgent
+  module Providers
+    class Local < OpenAI
+      private
+
+      def call_api(messages, system_prompt: nil, tools: nil)
+        base_url = config.local_url
+
+        headers = { 'Content-Type' => 'application/json' }
+        api_key = config.local_api_key
+        if api_key && api_key != 'no-key' && !api_key.empty?
+          headers['Authorization'] = "Bearer #{api_key}"
+        end
+
+        conn = build_connection(base_url, headers)
+
+        formatted = []
+        formatted << { role: 'system', content: system_prompt } if system_prompt
+        formatted.concat(format_messages(messages))
+
+        body = {
+          model: config.resolved_model,
+          max_tokens: config.resolved_max_tokens,
+          temperature: config.temperature,
+          messages: formatted
+        }
+        body[:tools] = tools.to_openai_format if tools
+
+        estimated_input_tokens = estimate_tokens(formatted, system_prompt, tools)
+
+        json_body = JSON.generate(body)
+        debug_request("#{base_url}/v1/chat/completions", body)
+        response = conn.post('/v1/chat/completions', json_body)
+        debug_response(response.body)
+        data = parse_response(response)
+        usage = data['usage'] || {}
+
+        prompt_tokens = usage['prompt_tokens']
+        if prompt_tokens && estimated_input_tokens > 0 && prompt_tokens < estimated_input_tokens * 0.5
+          raise ProviderError,
+            "Context truncated by local server: sent ~#{estimated_input_tokens} estimated tokens " \
+            "but server only used #{prompt_tokens}. Increase the model's context window " \
+            "(e.g. num_ctx for Ollama) or reduce conversation length."
+        end
+
+        choice = (data['choices'] || []).first || {}
+        message = choice['message'] || {}
+        finish_reason = choice['finish_reason']
+
+        tool_calls = extract_tool_calls(message)
+
+        # Fallback: some local models (e.g. Ollama) emit tool calls as JSON
+        # in the content field instead of using the structured tool_calls format.
+        # Only match when the JSON "name" is a known tool name to avoid false positives.
+        if tool_calls.empty? && tools
+          tool_names = tools.to_openai_format.map { |t| t.dig('function', 'name') }.compact
+          text_calls = extract_tool_calls_from_text(message['content'], tool_names)
+          if text_calls.any?
+            tool_calls = text_calls
+            finish_reason = 'tool_calls'
+            message['content'] = ''
+          end
+        end
+
+        stop = finish_reason == 'tool_calls' ? :tool_use : :end_turn
+
+        ChatResult.new(
+          text: message['content'] || '',
+          input_tokens: usage['prompt_tokens'],
+          output_tokens: usage['completion_tokens'],
+          tool_calls: tool_calls,
+          stop_reason: stop
+        )
+      end
+
+      def estimate_tokens(messages, system_prompt, tools)
+        chars = system_prompt.to_s.length
+        messages.each { |m| chars += m[:content].to_s.length + (m[:tool_calls].to_s.length) }
+        chars += tools.to_openai_format.to_s.length if tools
+        chars / 4
+      end
+
+      # Parse tool calls emitted as JSON text in the content field.
+      # Only recognizes calls whose "name" matches a known tool name.
+      def extract_tool_calls_from_text(content, tool_names)
+        return [] if content.nil? || content.strip.empty?
+
+        text = content.strip
+        parsed = begin
+                   JSON.parse(text)
+                 rescue JSON::ParserError
+                   match = text.match(/```(?:json)?\s*(\{[\s\S]*?\}|\[[\s\S]*?\])\s*```/)
+                   match ? (JSON.parse(match[1]) rescue nil) : nil
+                 end
+
+        return [] unless parsed
+
+        calls = parsed.is_a?(Array) ? parsed : [parsed]
+        calls.filter_map do |call|
+          next unless call.is_a?(Hash) && tool_names.include?(call['name'])
+          {
+            id: "local_#{SecureRandom.hex(4)}",
+            name: call['name'],
+            arguments: call['arguments'] || {}
+          }
+        end
+      rescue
+        []
+      end
+    end
+  end
+end

data/lib/console_agent/railtie.rb

@@ -2,6 +2,10 @@ require 'console_agent'
 
 module ConsoleAgent
   class Railtie < Rails::Railtie
+    rake_tasks do
+      load File.expand_path('../tasks/console_agent.rake', __dir__)
+    end
+
     console do
       require 'console_agent/console_methods'