console_agent 0.7.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 662ece5e5732e350b22871c8029421edf06ed4d9f98183f5cee7e95a3c1099f6
-  data.tar.gz: 483642598de39d23ace26f5d90863a8712b8799357c7809b2ba770f2bdc2522a
+  metadata.gz: 5f82de0e3bdd6d1e3189c3b1bd0c88c386a6b31b4dff317656365352490f06c9
+  data.tar.gz: 1347a93e946c254809cdf6bfa90e3dea0378b7aef9a5e04950bdf0151569cd79
 SHA512:
-  metadata.gz: 5095d8f4cb0706e84c81be1b4a859de6ac48336ccb9c950feeb0dcf0df676d78fddc53a2314a21cbe6ee9d79b808f5edf0d854f3262b72c5befbb4420d9b979b
-  data.tar.gz: 4c96f0e1664c1357cc7ec3f53aada9d1dcf4e05cbc92e19edfd052b2e99c75d1596d5a49440b8b9478fd576140b36929589a87e009dd971b4599cfa8ab149520
+  metadata.gz: cec5e56aaddea19c5d1b9046fcbd7fd4707d16efa3fab65f9977703e24d28d177c12331c9cba7590048b1ad2f412d67bcb9ffe78c5cef288d6da40916cb53a86
+  data.tar.gz: 9e67f0c30bbd38561c400523ca19240f931ff5c08b353fa545037472b6b2195f931b5987b21d3c643a35e2cb3377647447cc676aa7544ba5a2ccec2a505f7e16

data/CHANGELOG.md

@@ -0,0 +1,58 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.8.0]
+
+- Add authentication function support so host apps can avoid using basic auth
+- Add `/think` and `/cost` commands with Sonnet vs Opus support
+- Gracefully handle token limit exceeded errors
+
+## [0.7.0]
+
+- Include binding variables and their classes in the Rails console context
+- Add `ai_setup` command
+- Add `/compact` mechanism for conversation management
+- Catch errors and attempt to auto-fix them
+
+## [0.6.0]
+
+- Add core memory (`console_agent.md`) that persists across sessions in the system prompt
+- Add `ai_init` command to seed core memory
+- Allow reading partial files
+- Fix rspec hanging issues
+
+## [0.5.0]
+
+- Auto-accept single-step plans
+- Support `>` shorthand to run code directly
+- Add `script/release` for releases
+
+## [0.4.0]
+
+- Fix resuming sessions repeatedly
+- Fix terminal flashing/loading in production (kubectl)
+- Better escaping during thinking output
+
+## [0.3.0]
+
+- Add plan mechanism with "auto" execution mode
+- Add session logging to DB with `/console_agent` admin UI
+- List and resume past sessions with pagination
+- Add shift-tab for auto-execute mode
+- Add usage display and debug toggle
+- Store sessions incrementally; improved code segment display
+
+## [0.2.0]
+
+- Add memory system with individual file storage
+- Add `ask_user` tool
+- Add registry cache
+- Fix REPL up-key and ctrl-a navigation
+- Show tool usage and model processing info
+- Add token count information and debug ability
+- Use tools-based approach instead of sending everything at once
+
+## [0.1.0]
+
+- Initial implementation

data/README.md

@@ -77,15 +77,21 @@ end
 | `/auto` | Toggle auto-execute (skip confirmations) |
 | `/compact` | Compress history into a summary (saves tokens) |
 | `/usage` | Show token stats |
+| `/cost` | Show per-model cost breakdown |
+| `/think` | Upgrade to thinking model (Opus) for the rest of the session |
 | `/debug` | Toggle raw API output |
 | `/name <label>` | Name the session for easy resume |
 
 Prefix input with `>` to run Ruby directly (no LLM round-trip). The result is added to conversation context.
 
+Say "think harder" in any query to auto-upgrade to the thinking model for that session. After 5+ tool rounds, you'll also be prompted to switch.
+
 ## Features
 
 - **Tool use** — AI introspects your schema, models, files, and code to write accurate queries
 - **Multi-step plans** — complex tasks are broken into steps, executed sequentially with `step1`/`step2` references
+- **Two-tier models** — defaults to Sonnet for speed/cost; `/think` upgrades to Opus when you need it
+- **Cost tracking** — `/cost` shows per-model token usage and estimated spend
 - **Memories** — AI saves what it learns about your app across sessions
 - **App guide** — `ai_init` generates a guide injected into every system prompt
 - **Sessions** — name, list, and resume interactive conversations (`ai_setup` to enable)
@@ -98,9 +104,43 @@ ConsoleAgent.configure do |config|
   config.provider = :anthropic       # or :openai
   config.auto_execute = false         # true to skip confirmations
   config.session_logging = true       # requires ai_setup
+  config.model = 'claude-sonnet-4-6'  # model used by /think (default)
+  config.thinking_model = 'claude-opus-4-6'  # model used by /think (default)
+end
+```
+
+The default model is `claude-sonnet-4-6` (Anthropic) or `gpt-5.3-codex` (OpenAI). The thinking model defaults to `claude-opus-4-6` and is activated via `/think` or by saying "think harder".
+
+## Web UI Authentication
+
+The engine mounts a session viewer at `/console_agent`. By default it's open — you can protect it with basic auth or a custom authentication function.
+
+### Basic Auth
+
+```ruby
+ConsoleAgent.configure do |config|
+  config.admin_username = 'admin'
+  config.admin_password = ENV['CONSOLE_AGENT_PASSWORD']
 end
 ```
 
+### Custom Authentication
+
+For apps with their own auth system, pass a proc to `authenticate`. It runs in the controller context, so you have access to `session`, `request`, `redirect_to`, etc.
+
+```ruby
+ConsoleAgent.configure do |config|
+  config.authenticate = proc {
+    user = User.find_by(id: session[:user_id])
+    unless user&.admin?
+      redirect_to '/login'
+    end
+  }
+end
+```
+
+When `authenticate` is set, `admin_username` / `admin_password` are ignored.
+
 ## Requirements
 
 Ruby >= 2.5, Rails >= 5.0, Faraday >= 1.0

data/app/controllers/console_agent/application_controller.rb

@@ -2,19 +2,26 @@ module ConsoleAgent
   class ApplicationController < ActionController::Base
     protect_from_forgery with: :exception
 
-    before_action :authenticate!
+    before_action :console_agent_authenticate!
 
     private
 
-    def authenticate!
-      username = ConsoleAgent.configuration.admin_username
-      password = ConsoleAgent.configuration.admin_password
+    def console_agent_authenticate!
+      if (auth = ConsoleAgent.configuration.authenticate)
+        instance_exec(&auth)
+      else
+        username = ConsoleAgent.configuration.admin_username
+        password = ConsoleAgent.configuration.admin_password
 
-      return unless username && password
+        unless username && password
+          head :unauthorized
+          return
+        end
 
-      authenticate_or_request_with_http_basic('ConsoleAgent Admin') do |u, p|
-        ActiveSupport::SecurityUtils.secure_compare(u, username) &
-          ActiveSupport::SecurityUtils.secure_compare(p, password)
+        authenticate_or_request_with_http_basic('ConsoleAgent Admin') do |u, p|
+          ActiveSupport::SecurityUtils.secure_compare(u, username) &
+            ActiveSupport::SecurityUtils.secure_compare(p, password)
+        end
       end
     end
   end

data/lib/console_agent/configuration.rb

@@ -2,29 +2,44 @@ module ConsoleAgent
   class Configuration
     PROVIDERS = %i[anthropic openai].freeze
 
-    attr_accessor :provider, :api_key, :model, :max_tokens,
+    PRICING = {
+      'claude-sonnet-4-6' => { input: 3.0 / 1_000_000, output: 15.0 / 1_000_000 },
+      'claude-opus-4-6'   => { input: 15.0 / 1_000_000, output: 75.0 / 1_000_000 },
+      'claude-haiku-4-5-20251001' => { input: 0.80 / 1_000_000, output: 4.0 / 1_000_000 },
+    }.freeze
+
+    DEFAULT_MAX_TOKENS = {
+      'claude-sonnet-4-6' => 16_000,
+      'claude-haiku-4-5-20251001' => 16_000,
+      'claude-opus-4-6'   => 4_096,
+    }.freeze
+
+    attr_accessor :provider, :api_key, :model, :thinking_model, :max_tokens,
                   :auto_execute, :temperature,
                   :timeout, :debug, :max_tool_rounds,
                   :storage_adapter, :memories_enabled,
                   :session_logging, :connection_class,
-                  :admin_username, :admin_password
+                  :admin_username, :admin_password,
+                  :authenticate
 
     def initialize
       @provider     = :anthropic
       @api_key      = nil
       @model        = nil
-      @max_tokens   = 4096
+      @thinking_model = nil
+      @max_tokens   = nil
       @auto_execute = false
       @temperature  = 0.2
       @timeout      = 30
       @debug        = false
-      @max_tool_rounds = 100
+      @max_tool_rounds = 200
       @storage_adapter  = nil
       @memories_enabled = true
       @session_logging  = true
       @connection_class = nil
       @admin_username   = nil
       @admin_password   = nil
+      @authenticate     = nil
     end
 
     def resolved_api_key
@@ -41,6 +56,23 @@ module ConsoleAgent
     def resolved_model
       return @model if @model && !@model.empty?
 
+      case @provider
+      when :anthropic
+        'claude-sonnet-4-6'
+      when :openai
+        'gpt-5.3-codex'
+      end
+    end
+
+    def resolved_max_tokens
+      return @max_tokens if @max_tokens
+
+      DEFAULT_MAX_TOKENS.fetch(resolved_model, 4096)
+    end
+
+    def resolved_thinking_model
+      return @thinking_model if @thinking_model && !@thinking_model.empty?
+
       case @provider
       when :anthropic
         'claude-opus-4-6'

data/lib/console_agent/executor.rb

@@ -84,7 +84,7 @@ module ConsoleAgent
       result = binding_context.eval(code, "(console_agent)", 1)
 
       $stdout = old_stdout
-      $stdout.puts colorize("=> #{result.inspect}", :green)
+      display_result(result)
 
       @last_output = captured_output.string
       result
@@ -126,35 +126,69 @@ module ConsoleAgent
       @last_answer = answer
       echo_stdin(answer)
 
-      case answer
-      when 'y', 'yes'
-        execute(code)
-      when 'e', 'edit'
-        edited = open_in_editor(code)
-        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 edit_answer == 'y'
-            execute(edited)
+      loop do
+        case answer
+        when 'y', 'yes', 'a'
+          return execute(code)
+        when 'e', 'edit'
+          edited = open_in_editor(code)
+          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 edit_answer == 'y'
+              return execute(edited)
+            else
+              $stdout.puts colorize("Cancelled.", :yellow)
+              return nil
+            end
           else
-            $stdout.puts colorize("Cancelled.", :yellow)
-            nil
+            return execute(code)
           end
+        when 'n', 'no', ''
+          $stdout.puts colorize("Cancelled.", :yellow)
+          @last_cancelled = true
+          return nil
         else
-          execute(code)
+          $stdout.print colorize("Execute? [y/N/edit] ", :yellow)
+          @on_prompt&.call
+          answer = $stdin.gets.to_s.strip.downcase
+          @last_answer = answer
+          echo_stdin(answer)
         end
-      else
-        $stdout.puts colorize("Cancelled.", :yellow)
-        @last_cancelled = true
-        nil
       end
     end
 
     private
 
+    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)
+      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
+        $stdout.puts colorize("  (omitting #{parts.join(', ')})", :yellow)
+      end
+    end
+
     # Write stdin input to the capture IO only (avoids double-echo on terminal)
     def echo_stdin(text)
       $stdout.secondary.write("#{text}\n") if $stdout.respond_to?(:secondary)

data/lib/console_agent/providers/anthropic.rb

@@ -50,7 +50,7 @@ module ConsoleAgent
 
         body = {
           model: config.resolved_model,
-          max_tokens: config.max_tokens,
+          max_tokens: config.resolved_max_tokens,
           temperature: config.temperature,
           messages: format_messages(messages)
         }

data/lib/console_agent/providers/openai.rb

@@ -50,7 +50,7 @@ module ConsoleAgent
 
         body = {
           model: config.resolved_model,
-          max_tokens: config.max_tokens,
+          max_tokens: config.resolved_max_tokens,
           temperature: config.temperature,
           messages: formatted
         }

data/lib/console_agent/repl.rb

@@ -11,6 +11,7 @@ module ConsoleAgent
       @history = []
       @total_input_tokens = 0
       @total_output_tokens = 0
+      @token_usage = Hash.new { |h, k| h[k] = { input: 0, output: 0 } }
       @input_history = []
     end
 
@@ -209,6 +210,7 @@ module ConsoleAgent
       @history = []
       @total_input_tokens = 0
       @total_output_tokens = 0
+      @token_usage = Hash.new { |h, k| h[k] = { input: 0, output: 0 } }
       @interactive_query = nil
       @interactive_session_id = nil
       @interactive_session_name = nil
@@ -224,7 +226,7 @@ module ConsoleAgent
       name_display = @interactive_session_name ? " (#{@interactive_session_name})" : ""
       # Write banner to real stdout (bypass TeeIO) so it doesn't accumulate on resume
       @interactive_old_stdout.puts "\e[36mConsoleAgent interactive mode#{name_display}. Type 'exit' or 'quit' to leave.\e[0m"
-      @interactive_old_stdout.puts "\e[2m  Auto-execute: #{auto ? 'ON' : 'OFF'} (Shift-Tab or /auto to toggle) | > code to run directly | /usage | /compact | /name <label>\e[0m"
+      @interactive_old_stdout.puts "\e[2m  Auto-execute: #{auto ? 'ON' : 'OFF'} (Shift-Tab or /auto to toggle) | > code | /usage | /cost | /compact | /think | /name <label>\e[0m"
 
       # Bind Shift-Tab to insert /auto command and submit
       if Readline.respond_to?(:parse_and_bind)
@@ -239,6 +241,11 @@ module ConsoleAgent
         break if input.downcase == 'exit' || input.downcase == 'quit'
         next if input.empty?
 
+        if input == '?' || input == '/'
+          display_help
+          next
+        end
+
         if input == '/auto'
           ConsoleAgent.configuration.auto_execute = !ConsoleAgent.configuration.auto_execute
           mode = ConsoleAgent.configuration.auto_execute ? 'ON' : 'OFF'
@@ -263,6 +270,26 @@ module ConsoleAgent
           next
         end
 
+        if input == '/system'
+          @interactive_old_stdout.puts "\e[2m#{context}\e[0m"
+          next
+        end
+
+        if input == '/context'
+          display_conversation
+          next
+        end
+
+        if input == '/cost'
+          display_cost_summary
+          next
+        end
+
+        if input == '/think'
+          upgrade_to_thinking_model
+          next
+        end
+
         if input.start_with?('/name')
           name = input.sub('/name', '').strip
           if name.empty?
@@ -314,6 +341,11 @@ module ConsoleAgent
         # Add to Readline history (avoid consecutive duplicates)
         Readline::HISTORY.push(input) unless input == Readline::HISTORY.to_a.last
 
+        # Auto-upgrade to thinking model on "think harder" phrases
+        if input =~ /think\s*harder/i
+          upgrade_to_thinking_model
+        end
+
         @interactive_query ||= input
         @history << { role: :user, content: input }
 
@@ -365,6 +397,13 @@ module ConsoleAgent
     def send_and_execute
       begin
         result, tool_messages = send_query(nil, conversation: @history)
+      rescue Providers::ProviderError => e
+        if e.message.include?("prompt is too long") && @history.length >= 6
+          $stdout.puts "\e[33m  Context limit reached. Run /compact to reduce context size, then try again.\e[0m"
+        else
+          $stderr.puts "\e[31mConsoleAgent Error: #{e.class}: #{e.message}\e[0m"
+        end
+        return :error
       rescue Interrupt
         $stdout.puts "\n\e[33m  Aborted.\e[0m"
         return :interrupted
@@ -547,8 +586,12 @@ module ConsoleAgent
           $stdout.puts "\e[2m  #{llm_status(round, messages, total_input, last_thinking, last_tool_names)}\e[0m"
         end
 
-        result = with_escape_monitoring do
-          provider.chat_with_tools(messages, tools: tools, system_prompt: active_system_prompt)
+        begin
+          result = with_escape_monitoring do
+            provider.chat_with_tools(messages, tools: tools, system_prompt: active_system_prompt)
+          end
+        rescue Providers::ProviderError => e
+          raise
         end
         total_input += result.input_tokens || 0
         total_output += result.output_tokens || 0
@@ -776,6 +819,10 @@ module ConsoleAgent
     def track_usage(result)
       @total_input_tokens += result.input_tokens || 0
       @total_output_tokens += result.output_tokens || 0
+
+      model = ConsoleAgent.configuration.resolved_model
+      @token_usage[model][:input] += result.input_tokens || 0
+      @token_usage[model][:output] += result.output_tokens || 0
     end
 
     def display_usage(result, show_session: false)
@@ -883,12 +930,58 @@ module ConsoleAgent
       $stdout.puts "\e[2m[session totals — in: #{@total_input_tokens} | out: #{@total_output_tokens} | total: #{@total_input_tokens + @total_output_tokens}]\e[0m"
     end
 
+    def display_cost_summary
+      if @token_usage.empty?
+        $stdout.puts "\e[2m  No usage yet.\e[0m"
+        return
+      end
+
+      total_cost = 0.0
+      $stdout.puts "\e[36m  Cost estimate:\e[0m"
+
+      @token_usage.each do |model, usage|
+        pricing = Configuration::PRICING[model]
+        input_str = "in: #{format_tokens(usage[:input])}"
+        output_str = "out: #{format_tokens(usage[:output])}"
+
+        if pricing
+          cost = (usage[:input] * pricing[:input]) + (usage[:output] * pricing[:output])
+          total_cost += cost
+          $stdout.puts "\e[2m    #{model}:  #{input_str}  #{output_str}  ~$#{'%.2f' % cost}\e[0m"
+        else
+          $stdout.puts "\e[2m    #{model}:  #{input_str}  #{output_str}  (pricing unknown)\e[0m"
+        end
+      end
+
+      $stdout.puts "\e[36m    Total: ~$#{'%.2f' % total_cost}\e[0m"
+    end
+
+    def upgrade_to_thinking_model
+      config = ConsoleAgent.configuration
+      current = config.resolved_model
+      thinking = config.resolved_thinking_model
+
+      if current == thinking
+        $stdout.puts "\e[36m  Already using thinking model (#{current}).\e[0m"
+      else
+        config.model = thinking
+        @provider = nil
+        $stdout.puts "\e[36m  Switched to thinking model: #{thinking}\e[0m"
+      end
+    end
+
+    def on_thinking_model?
+      config = ConsoleAgent.configuration
+      config.resolved_model == config.resolved_thinking_model
+    end
+
     def warn_if_history_large
       chars = @history.sum { |m| m[:content].to_s.length }
-      return if chars < 50_000 || @compact_warned
 
-      @compact_warned = true
-      $stdout.puts "\e[33m  Conversation is getting large (~#{format_tokens(chars)} chars). Consider running /compact to reduce context size.\e[0m"
+      if chars > 50_000 && !@compact_warned
+        @compact_warned = true
+        $stdout.puts "\e[33m  Conversation is getting large (~#{format_tokens(chars)} chars). Consider running /compact to reduce context size.\e[0m"
+      end
     end
 
     def compact_history
@@ -900,6 +993,9 @@ module ConsoleAgent
       before_chars = @history.sum { |m| m[:content].to_s.length }
       before_count = @history.length
 
+      # Extract successfully executed code before summarizing
+      executed_code = extract_executed_code(@history)
+
       $stdout.puts "\e[2m  Compacting #{before_count} messages (~#{format_tokens(before_chars)} chars)...\e[0m"
 
       system_prompt = <<~PROMPT
@@ -910,8 +1006,8 @@ module ConsoleAgent
         - Key findings and data discovered (include specific values, IDs, record counts)
         - Current state: what worked, what failed, where things stand
         - Important variable names, model names, or table names referenced
-        - Any code that was executed and its results
 
+        Do NOT include code that was executed — that will be preserved separately.
         Be concise but preserve all information that would be needed to continue the conversation naturally.
         Do NOT include any preamble — just output the summary directly.
       PROMPT
@@ -929,18 +1025,130 @@ module ConsoleAgent
           return
         end
 
-        @history = [{ role: :user, content: "CONVERSATION SUMMARY (compacted):\n#{summary}" }]
+        content = "CONVERSATION SUMMARY (compacted):\n#{summary}"
+        unless executed_code.empty?
+          content += "\n\nCODE EXECUTED THIS SESSION (preserved for continuation):\n#{executed_code}"
+        end
+
+        @history = [{ role: :user, content: content }]
         @compact_warned = false
 
         after_chars = @history.first[:content].length
         $stdout.puts "\e[36m  Compacted: #{before_count} messages -> 1 summary (~#{format_tokens(before_chars)} -> ~#{format_tokens(after_chars)} chars)\e[0m"
         summary.each_line { |line| $stdout.puts "\e[2m  #{line.rstrip}\e[0m" }
+        if !executed_code.empty?
+          $stdout.puts "\e[2m  (preserved #{executed_code.scan(/```ruby/).length} executed code block(s))\e[0m"
+        end
         display_usage(result)
       rescue => e
         $stdout.puts "\e[31m  Compaction failed: #{e.message}\e[0m"
       end
     end
 
+    # Extracts code blocks that were successfully executed from conversation history.
+    # Looks for:
+    # 1. Assistant messages with ```ruby blocks followed by "Code was executed." user messages
+    # 2. execute_plan tool calls followed by results without ERROR
+    # Skips code that failed or was declined.
+    def extract_executed_code(history)
+      code_blocks = []
+      history.each_cons(2) do |msg, next_msg|
+        # Pattern 1: Assistant ```ruby blocks with successful execution
+        if msg[:role].to_s == 'assistant' && next_msg[:role].to_s == 'user'
+          content = msg[:content].to_s
+          next_content = next_msg[:content].to_s
+
+          if next_content.start_with?('Code was executed.')
+            content.scan(/```ruby\s*\n(.*?)```/m).each do |match|
+              code = match[0].strip
+              next if code.empty?
+              result_summary = next_content[0..200].gsub("\n", "\n# ")
+              code_blocks << "```ruby\n#{code}\n```\n# #{result_summary}"
+            end
+          end
+        end
+
+        # Pattern 2: execute_plan tool calls in provider-formatted messages
+        if msg[:role].to_s == 'assistant' && msg[:content].is_a?(Array)
+          msg[:content].each do |block|
+            next unless block.is_a?(Hash) && block['type'] == 'tool_use' && block['name'] == 'execute_plan'
+            input = block['input'] || {}
+            steps = input['steps'] || []
+
+            # Find the matching tool_result in subsequent messages
+            tool_id = block['id']
+            result_msg = find_tool_result(history, tool_id)
+            next unless result_msg
+
+            result_text = result_msg.to_s
+            # Extract only steps that succeeded (no ERROR in their result)
+            steps.each_with_index do |step, i|
+              step_num = i + 1
+              # Check if this specific step had an error
+              step_section = result_text[/Step #{step_num}\b.*?(?=Step #{step_num + 1}\b|\z)/m] || ''
+              next if step_section.include?('ERROR:')
+              next if step_section.include?('User declined')
+
+              code = step['code'].to_s.strip
+              next if code.empty?
+              desc = step['description'] || "Step #{step_num}"
+              code_blocks << "```ruby\n# #{desc}\n#{code}\n```"
+            end
+          end
+        end
+      end
+      code_blocks.join("\n\n")
+    end
+
+    def find_tool_result(history, tool_id)
+      history.each do |msg|
+        next unless msg[:content].is_a?(Array)
+        msg[:content].each do |block|
+          next unless block.is_a?(Hash)
+          if block['type'] == 'tool_result' && block['tool_use_id'] == tool_id
+            return block['content']
+          end
+          # OpenAI format
+          if msg[:role].to_s == 'tool' && msg[:tool_call_id] == tool_id
+            return msg[:content]
+          end
+        end
+      end
+      nil
+    end
+
+    def display_conversation
+      if @history.empty?
+        @interactive_old_stdout.puts "\e[2m  (no conversation history yet)\e[0m"
+        return
+      end
+
+      @interactive_old_stdout.puts "\e[36m  Conversation (#{@history.length} messages):\e[0m"
+      @history.each_with_index do |msg, i|
+        role = msg[:role].to_s
+        content = msg[:content].to_s
+        label = role == 'user' ? "\e[33m[user]\e[0m" : "\e[36m[assistant]\e[0m"
+        @interactive_old_stdout.puts "#{label} #{content}"
+        @interactive_old_stdout.puts if i < @history.length - 1
+      end
+    end
+
+    def display_help
+      auto = ConsoleAgent.configuration.auto_execute ? 'ON' : 'OFF'
+      @interactive_old_stdout.puts "\e[36m  Commands:\e[0m"
+      @interactive_old_stdout.puts "\e[2m    /auto        Toggle auto-execute (currently #{auto}) (Shift-Tab)\e[0m"
+      @interactive_old_stdout.puts "\e[2m    /think       Switch to thinking model\e[0m"
+      @interactive_old_stdout.puts "\e[2m    /compact     Summarize conversation to reduce context\e[0m"
+      @interactive_old_stdout.puts "\e[2m    /usage       Show session token totals\e[0m"
+      @interactive_old_stdout.puts "\e[2m    /cost        Show cost estimate by model\e[0m"
+      @interactive_old_stdout.puts "\e[2m    /name <lbl>  Name this session for easy resume\e[0m"
+      @interactive_old_stdout.puts "\e[2m    /context     Show conversation history sent to the LLM\e[0m"
+      @interactive_old_stdout.puts "\e[2m    /system      Show the system prompt\e[0m"
+      @interactive_old_stdout.puts "\e[2m    /debug       Toggle debug mode\e[0m"
+      @interactive_old_stdout.puts "\e[2m    > code       Execute Ruby directly (skip LLM)\e[0m"
+      @interactive_old_stdout.puts "\e[2m    exit/quit    Leave interactive mode\e[0m"
+    end
+
     def display_exit_info
       display_session_summary
       if @interactive_session_id

data/lib/console_agent/version.rb

@@ -1,3 +1,3 @@
 module ConsoleAgent
-  VERSION = '0.7.0'.freeze
+  VERSION = '0.9.0'.freeze
 end

data/lib/generators/console_agent/templates/initializer.rb

@@ -35,7 +35,7 @@ ConsoleAgent.configure do |config|
   # config.connection_class = Sharding::CentralizedModel
 
   # Admin UI credentials (mount ConsoleAgent::Engine => '/console_agent' in routes.rb)
-  # When nil, no authentication is required (convenient for development)
+  # When nil, all requests are denied. Set credentials or use config.authenticate.
   # config.admin_username = 'admin'
   # config.admin_password = 'changeme'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: console_agent
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Cortfr
@@ -86,6 +86,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE
 - README.md
 - app/controllers/console_agent/application_controller.rb