console_agent 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fdcfb3c48b2f8421b2187980a453b80324e6dec40ab80e8e55aa1a938355c79c
-  data.tar.gz: 12fec02740fde7a87bb81e26dd6857263c96f9ebe5a8402040c72279e882e31f
+  metadata.gz: 5f82de0e3bdd6d1e3189c3b1bd0c88c386a6b31b4dff317656365352490f06c9
+  data.tar.gz: 1347a93e946c254809cdf6bfa90e3dea0378b7aef9a5e04950bdf0151569cd79
 SHA512:
-  metadata.gz: 7af9a3c4fdbdf71abb7452d8e6747ba2b22c64cd08d123b761c5ca7ebb870c3ba9a01e458defe0308dcbf9435ec71879f7f3562503defdfd54e2026d3069679d
-  data.tar.gz: c84e401d6b6f5c6c7840b5d701d3a0e653ba3ea46651141ae5101b2c93bdca35487566786a87e284dbba97f902c5dad597a00b8dc9fce6e1c01885b01e99a48d
+  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/app/controllers/console_agent/application_controller.rb

@@ -13,7 +13,10 @@ module ConsoleAgent
         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) &

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/repl.rb

@@ -241,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'
@@ -265,6 +270,16 @@ 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
@@ -384,18 +399,11 @@ module ConsoleAgent
         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. Auto-compacting history...\e[0m"
-          compact_history
-          begin
-            result, tool_messages = send_query(nil, conversation: @history)
-          rescue Providers::ProviderError => e2
-            $stderr.puts "\e[31m  Still too large after compaction: #{e2.message}\e[0m"
-            return :error
-          end
+          $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"
-          return :error
         end
+        return :error
       rescue Interrupt
         $stdout.puts "\n\e[33m  Aborted.\e[0m"
         return :interrupted
@@ -564,18 +572,8 @@ module ConsoleAgent
       last_tool_names = []
 
       exhausted = false
-      thinking_suggested = false
 
       max_rounds.times do |round|
-        if round == 5 && !thinking_suggested && !on_thinking_model?
-          thinking_suggested = true
-          thinking_name = ConsoleAgent.configuration.resolved_thinking_model
-          $stdout.puts "\e[33m  This query is using many tool rounds. Switch to thinking model (#{thinking_name})? [y/N]\e[0m"
-          answer = Readline.readline("  ", false).to_s.strip.downcase
-          if answer == 'y'
-            upgrade_to_thinking_model
-          end
-        end
         if round == 0
           $stdout.puts "\e[2m  Thinking...\e[0m"
         else
@@ -593,17 +591,7 @@ module ConsoleAgent
             provider.chat_with_tools(messages, tools: tools, system_prompt: active_system_prompt)
           end
         rescue Providers::ProviderError => e
-          if e.message.include?("prompt is too long") && messages.length >= 6
-            $stdout.puts "\e[33m  Context limit hit mid-session. Compacting messages...\e[0m"
-            messages = compact_messages(messages)
-            unless @_retried_compact
-              @_retried_compact = true
-              retry
-            end
-          end
           raise
-        ensure
-          @_retried_compact = nil
         end
         total_input += result.input_tokens || 0
         total_output += result.output_tokens || 0
@@ -990,10 +978,7 @@ module ConsoleAgent
     def warn_if_history_large
       chars = @history.sum { |m| m[:content].to_s.length }
 
-      if chars > 120_000 && @history.length >= 6
-        $stdout.puts "\e[33m  Context growing large (~#{format_tokens(chars)} chars). Auto-compacting...\e[0m"
-        compact_history
-      elsif chars > 50_000 && !@compact_warned
+      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
@@ -1008,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
@@ -1018,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
@@ -1037,32 +1025,128 @@ 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
 
-    def compact_messages(messages)
-      return messages if messages.length < 6
+    # 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
 
-      to_summarize = messages[0...-4]
-      to_keep = messages[-4..]
+        # 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
 
-      history_text = to_summarize.map { |m| "#{m[:role]}: #{m[:content].to_s[0..500]}" }.join("\n\n")
+    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
 
-      summary_result = provider.chat(
-        [{ role: :user, content: "Summarize this conversation context concisely, preserving key facts, IDs, and findings:\n\n#{history_text}" }],
-        system_prompt: "You are a conversation summarizer. Be concise but preserve all actionable information."
-      )
+    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
 
-      [{ role: :user, content: "CONTEXT SUMMARY:\n#{summary_result.text}" }] + to_keep
+    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

data/lib/console_agent/version.rb

@@ -1,3 +1,3 @@
 module ConsoleAgent
-  VERSION = '0.8.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.8.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