console_agent 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d1d37fc84ac3f2d29832d282e6db1fd394308de2b967843c3a0c9748560a7025
-  data.tar.gz: 28bd6c25529dbedfa12d2353a1648304517bab933f0a4f25e91285ccaaf08e10
+  metadata.gz: 662ece5e5732e350b22871c8029421edf06ed4d9f98183f5cee7e95a3c1099f6
+  data.tar.gz: 483642598de39d23ace26f5d90863a8712b8799357c7809b2ba770f2bdc2522a
 SHA512:
-  metadata.gz: 6451c8b62eba1159e0233be04dabbc86bcb3b6f1dcbd6cd658c8d5517a27f1ad6a20884d30d87fabcbe75d8a51d12a6dfa2d4a59ed0adb648ce56d3b81765636
-  data.tar.gz: 3448b25930e4613a4599698d98ec1c5a2d84b113a3221d98239dc0f09351455be817882b308910bfd8bf01eab00d01670c11256624bb7cd7a30745538095c2ea
+  metadata.gz: 5095d8f4cb0706e84c81be1b4a859de6ac48336ccb9c950feeb0dcf0df676d78fddc53a2314a21cbe6ee9d79b808f5edf0d854f3262b72c5befbb4420d9b979b
+  data.tar.gz: 4c96f0e1664c1357cc7ec3f53aada9d1dcf4e05cbc92e19edfd052b2e99c75d1596d5a49440b8b9478fd576140b36929589a87e009dd971b4599cfa8ab149520

data/README.md

@@ -1,40 +1,6 @@
 # ConsoleAgent
 
-Claude Code, embedded in your Rails console.
-
-Ask questions in plain English. The AI explores your schema, models, and source code on its own, then writes and runs the Ruby code for you.
-
-## Install
-
-```ruby
-# Gemfile
-gem 'console_agent', group: :development
-```
-
-```bash
-bundle install
-rails generate console_agent:install
-```
-
-Set your API key in the generated initializer or as an env var (`ANTHROPIC_API_KEY`):
-
-```ruby
-# config/initializers/console_agent.rb
-ConsoleAgent.configure do |config|
-  config.api_key = 'sk-ant-...'
-end
-```
-
-To set up session logging (OPTIONAL), create the table from the console:
-
-```ruby
-ConsoleAgent.setup!
-# => ConsoleAgent: created console_agent_sessions table.
-```
-
-To reset the table (e.g. after upgrading), run `ConsoleAgent.teardown!` then `ConsoleAgent.setup!`.
-
-## Usage
+Claude Code for your Rails Console.
 
 ```
 irb> ai "find the 5 most recent orders over $100"
@@ -50,29 +16,10 @@ Execute? [y/N/edit] y
 => [#<Order id: 4821, ...>, ...]
 ```
 
-The AI calls tools behind the scenes to learn your app — schema, models, associations, source code — so it writes accurate queries without you providing any context.
-
-### Commands
-
-| Command | What it does |
-|---------|-------------|
-| `ai "query"` | One-shot: ask, review code, confirm |
-| `ai! "query"` | Interactive: ask and keep chatting |
-| `ai? "query"` | Explain only, never executes |
-| `ai_init` | Generate/update app guide for better context |
-
-### Multi-Step Plans
-
-For complex tasks, the AI builds a plan and executes it step by step:
+For complex tasks it builds multi-step plans, executing each step sequentially:
 
 ```
 ai> get the most recent salesforce token and count events via the API
-  Thinking...
-  -> describe_table("oauth2_tokens")
-     28 columns
-  -> read_file("lib/salesforce_api.rb")
-     202 lines
-
   Plan (2 steps):
   1. Find the most recent active Salesforce OAuth2 token
      token = Oauth2Token.where(provider: "salesforce", active: true)
@@ -82,179 +29,81 @@ ai> get the most recent salesforce token and count events via the API
      api.query("SELECT COUNT(Id) FROM Event")
 
   Accept plan? [y/N/a(uto)] a
-  Step 1/2: Find the most recent active Salesforce OAuth2 token
-  ...
-=> #<Oauth2Token id: 1, provider: "salesforce", ...>
-
-  Step 2/2: Query event count via SOQL
-  ...
-=> [{"expr0"=>42}]
 ```
 
-Each step's return value is available to later steps as `step1`, `step2`, etc.
-
-Plan prompt options:
-- **y** — accept, then confirm each step one at a time
-- **a** — accept and auto-run all steps (stays in manual mode for future queries)
-- **N** — decline; you're asked what to change and the AI revises
+No context needed from you — it figures out your app on its own.
 
-### Memories
-
-The AI remembers what it learns about your codebase across sessions:
+## Install
 
+```ruby
+# Gemfile
+gem 'console_agent', group: :development
 ```
-ai> how does sharding work?
-  -> read_file("config/initializers/sharding.rb")
-  -> save_memory("Sharding architecture")
-     Memory saved
 
-  This app uses database-per-shard. User.count returns the current shard only.
+```bash
+bundle install
+rails generate console_agent:install
 ```
 
-Next time, it already knows — no re-reading files, fewer tokens.
-
-### Application Guide
+Set your API key in the generated initializer or via env var (`ANTHROPIC_API_KEY`):
 
-Run `ai_init` to have the AI explore your app and generate a guide that gets loaded into every future conversation:
-
-```
-irb> ai_init
-  No existing guide. Exploring the app...
-  Thinking...
-  -> list_models
-     240 models
-  -> describe_model("User")
-     119 associations, 6 validations
-  -> describe_model("Account")
-     25 associations
-  -> search_code("Sharding", dir: "config")
-     Found 36 matches
-  ...
-  Guide saved to .console_agent/console_agent.md (3204 chars)
+```ruby
+# config/initializers/console_agent.rb
+ConsoleAgent.configure do |config|
+  config.api_key = 'sk-ant-...'
+end
 ```
 
-The guide is a markdown file covering your app's models, relationships, data architecture, and gotchas. Unlike memories (which require a tool call to recall), the guide is injected directly into the system prompt — so the AI starts every session already knowing your app.
+## Commands
 
-Run `ai_init` again anytime to update it.
+| Command | What it does |
+|---------|-------------|
+| `ai "query"` | Ask, review generated code, confirm execution |
+| `ai!` | Enter interactive mode (multi-turn conversation) |
+| `ai? "query"` | Explain only, no execution |
+| `ai_init` | Generate app guide for better AI context |
+| `ai_setup` | Install session logging table |
+| `ai_sessions` | List recent sessions |
+| `ai_resume` | Resume a session by name or ID |
+| `ai_memories` | Show stored memories |
+| `ai_status` | Show current configuration |
 
 ### Interactive Mode
 
-```
-irb> ai!
-ConsoleAgent interactive mode. Type 'exit' to leave.
-  Auto-execute: OFF (Shift-Tab or /auto to toggle) | > code to run directly | /usage | /name <label>
-
-ai> show me all tables
-  ...
-ai> count orders by status
-  ...
-ai> /auto
-  Auto-execute: ON
-ai> delete cancelled orders older than 90 days
-  ...
-ai> exit
-```
-
-Toggle `/auto` to skip confirmation prompts. `/debug` shows raw API traffic. `/usage` shows token stats.
-
-### Direct Code Execution
-
-Prefix any input with `>` to run Ruby code directly — no LLM round-trip. The result is added to the conversation context, so the AI knows what happened:
-
-```
-ai> >User.count
-=> 8
-ai> how many users do I have?
-  Thinking...
-
-You have **8 users** in your database, as confirmed by the `User.count` you just ran.
-```
-
-Useful for quick checks, setting up variables, or giving the AI concrete data to work with.
-
-### Sessions
-
-Sessions are saved automatically when session logging is enabled. You can name, list, and resume them.
-
-```
-ai> /name sf_user_123_calendar
-  Session named: sf_user_123_calendar
-ai> exit
-Session #42 saved.
-  Resume with: ai_resume "sf_user_123_calendar"
-Left ConsoleAgent interactive mode.
-```
-
-List recent sessions:
+`ai!` starts a conversation. Slash commands available inside:
 
-```
-irb> ai_sessions
-[Sessions — showing 3]
-
-  #42 sf_user_123_calendar find user 123 with calendar issues
-     [interactive] 5m ago 2340 tokens
-
-  #41 count all active users
-     [one_shot] 1h ago 850 tokens
-
-  #40 debug_payments explain payment flow
-     [interactive] 2h ago 4100 tokens
-
-Use ai_resume(id_or_name) to resume a session.
-```
-
-Resume a session by name or ID — previous output is replayed, then you continue where you left off:
-
-```
-irb> ai_resume "sf_user_123_calendar"
---- Replaying previous session output ---
-ai> find user 123 with calendar issues
-  ...previous output...
---- End of previous output ---
-
-ConsoleAgent interactive mode (sf_user_123_calendar). Type 'exit' to leave.
-ai> now check their calendar sync status
-  ...
-```
-
-Name or rename a session after the fact:
-
-```
-irb> ai_name 41, "active_user_count"
-Session #41 named: active_user_count
-```
+| Command | What it does |
+|---------|-------------|
+| `/auto` | Toggle auto-execute (skip confirmations) |
+| `/compact` | Compress history into a summary (saves tokens) |
+| `/usage` | Show token stats |
+| `/debug` | Toggle raw API output |
+| `/name <label>` | Name the session for easy resume |
 
-Filter sessions by search term:
+Prefix input with `>` to run Ruby directly (no LLM round-trip). The result is added to conversation context.
 
-```
-irb> ai_sessions 20, search: "salesforce"
-```
+## Features
 
-If you have an existing `console_agent_sessions` table, run `ConsoleAgent.migrate!` to add the `name` column.
+- **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
+- **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)
+- **History compaction** — `/compact` summarizes long conversations to reduce cost and latency
 
 ## Configuration
 
-All settings live in `config/initializers/console_agent.rb` and can be changed at runtime:
-
 ```ruby
 ConsoleAgent.configure do |config|
   config.provider = :anthropic       # or :openai
   config.auto_execute = false         # true to skip confirmations
-  config.max_tokens = 4096             # max tokens per LLM response
-  config.max_tool_rounds = 10         # max tool calls per query
-  config.session_logging = true       # log sessions to DB (run ConsoleAgent.setup!)
+  config.session_logging = true       # requires ai_setup
 end
 ```
 
-For the admin UI, mount the engine:
-
-```ruby
-mount ConsoleAgent::Engine => '/console_agent'
-```
-
 ## Requirements
 
-- Ruby >= 2.5, Rails >= 5.0, Faraday >= 1.0
+Ruby >= 2.5, Rails >= 5.0, Faraday >= 1.0
 
 ## License
 

data/lib/console_agent/console_methods.rb

@@ -130,6 +130,10 @@ module ConsoleAgent
       nil
     end
 
+    def ai_setup
+      ConsoleAgent.setup!
+    end
+
     def ai_init
       require 'console_agent/context_builder'
       require 'console_agent/providers/base'
@@ -153,6 +157,7 @@ module ConsoleAgent
         $stderr.puts "\e[33m  ai_sessions  - list recent sessions\e[0m"
         $stderr.puts "\e[33m  ai_resume    - resume a session by name or id\e[0m"
         $stderr.puts "\e[33m  ai_name      - name a session: ai_name 42, \"my_label\"\e[0m"
+        $stderr.puts "\e[33m  ai_setup     - install session logging table\e[0m"
         $stderr.puts "\e[33m  ai_status    - show current configuration\e[0m"
         $stderr.puts "\e[33m  ai_memories  - show recent memories (ai_memories(n) for last n)\e[0m"
         return nil
@@ -249,6 +254,14 @@ module ConsoleAgent
     end
 
     def __console_agent_binding
+      # Try Pry first (pry-rails replaces IRB but IRB may still be loaded)
+      if defined?(Pry)
+        pry_inst = ObjectSpace.each_object(Pry).find { |p|
+          p.respond_to?(:binding_stack) && !p.binding_stack.empty?
+        } rescue nil
+        return pry_inst.current_binding if pry_inst
+      end
+
       # Try IRB workspace binding
       if defined?(IRB) && IRB.respond_to?(:CurrentContext)
         ctx = IRB.CurrentContext rescue nil
@@ -257,14 +270,6 @@ module ConsoleAgent
         end
       end
 
-      # Try Pry binding
-      if defined?(Pry) && respond_to?(:pry_instance, true)
-        pry_inst = pry_instance rescue nil
-        if pry_inst && pry_inst.respond_to?(:current_binding)
-          return pry_inst.current_binding
-        end
-      end
-
       # Fallback
       TOPLEVEL_BINDING
     end

data/lib/console_agent/executor.rb

@@ -43,7 +43,7 @@ module ConsoleAgent
   class Executor
     CODE_REGEX = /```ruby\s*\n(.*?)```/m
 
-    attr_reader :binding_context
+    attr_reader :binding_context, :last_error
     attr_accessor :on_prompt
 
     def initialize(binding_context)
@@ -75,6 +75,7 @@ module ConsoleAgent
     def execute(code)
       return nil if code.nil? || code.strip.empty?
 
+      @last_error = nil
       captured_output = StringIO.new
       old_stdout = $stdout
       # Tee output: capture it and also print to the real stdout
@@ -89,12 +90,14 @@ module ConsoleAgent
       result
     rescue SyntaxError => e
       $stdout = old_stdout if old_stdout
-      $stderr.puts colorize("SyntaxError: #{e.message}", :red)
+      @last_error = "SyntaxError: #{e.message}"
+      $stderr.puts colorize(@last_error, :red)
       @last_output = nil
       nil
     rescue => e
       $stdout = old_stdout if old_stdout
-      $stderr.puts colorize("Error: #{e.class}: #{e.message}", :red)
+      @last_error = "#{e.class}: #{e.message}"
+      $stderr.puts colorize("Error: #{@last_error}", :red)
       e.backtrace.first(3).each { |line| $stderr.puts colorize("  #{line}", :red) }
       @last_output = captured_output&.string
       nil

data/lib/console_agent/repl.rb

@@ -18,29 +18,25 @@ module ConsoleAgent
       start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       console_capture = StringIO.new
       exec_result = with_console_capture(console_capture) do
-        result, _ = send_query(query)
-        track_usage(result)
-        code = @executor.display_response(result.text)
-        display_usage(result)
-
-        exec_result = nil
-        executed = false
-        has_code = code && !code.strip.empty?
-
-        if has_code
-          exec_result = if ConsoleAgent.configuration.auto_execute
-                          @executor.execute(code)
-                        else
-                          @executor.confirm_and_execute(code)
-                        end
-          executed = !@executor.last_cancelled?
+        conversation = [{ role: :user, content: query }]
+        exec_result, code, executed = one_shot_round(conversation)
+
+        # Auto-retry once if execution errored
+        if executed && @executor.last_error
+          error_msg = "Code execution failed with error: #{@executor.last_error}"
+          error_msg = error_msg[0..1000] + '...' if error_msg.length > 1000
+          conversation << { role: :assistant, content: @_last_result_text }
+          conversation << { role: :user, content: error_msg }
+
+          $stdout.puts "\e[2m  Attempting to fix...\e[0m"
+          exec_result, code, executed = one_shot_round(conversation)
         end
 
         @_last_log_attrs = {
           query: query,
-          conversation: [{ role: :user, content: query }, { role: :assistant, content: result.text }],
+          conversation: conversation,
           mode: 'one_shot',
-          code_executed: has_code ? code : nil,
+          code_executed: code,
           code_output: executed ? @executor.last_output : nil,
           code_result: executed && exec_result ? exec_result.inspect : nil,
           executed: executed,
@@ -61,6 +57,31 @@ module ConsoleAgent
       nil
     end
 
+    # Executes one LLM round: send query, display, optionally execute code.
+    # Returns [exec_result, code, executed].
+    def one_shot_round(conversation)
+      result, _ = send_query(nil, conversation: conversation)
+      track_usage(result)
+      code = @executor.display_response(result.text)
+      display_usage(result)
+      @_last_result_text = result.text
+
+      exec_result = nil
+      executed = false
+      has_code = code && !code.strip.empty?
+
+      if has_code
+        exec_result = if ConsoleAgent.configuration.auto_execute
+                        @executor.execute(code)
+                      else
+                        @executor.confirm_and_execute(code)
+                      end
+        executed = !@executor.last_cancelled?
+      end
+
+      [exec_result, has_code ? code : nil, executed]
+    end
+
     def explain(query)
       start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       console_capture = StringIO.new
@@ -195,6 +216,7 @@ module ConsoleAgent
       @last_interactive_output = nil
       @last_interactive_result = nil
       @last_interactive_executed = false
+      @compact_warned = false
     end
 
     def interactive_loop
@@ -202,7 +224,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 | /name <label>\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"
 
       # Bind Shift-Tab to insert /auto command and submit
       if Readline.respond_to?(:parse_and_bind)
@@ -236,6 +258,11 @@ module ConsoleAgent
           next
         end
 
+        if input == '/compact'
+          compact_history
+          next
+        end
+
         if input.start_with?('/name')
           name = input.sub('/name', '').strip
           if name.empty?
@@ -296,65 +323,24 @@ module ConsoleAgent
         # Save immediately so the session is visible in the admin UI while the AI thinks
         log_interactive_turn
 
-        begin
-          result, tool_messages = send_query(input, conversation: @history)
-        rescue Interrupt
-          $stdout.puts "\n\e[33m  Aborted.\e[0m"
+        status = send_and_execute
+        if status == :interrupted
           @history.pop # Remove the user message that never got a response
           log_interactive_turn
           next
         end
 
-        track_usage(result)
-        code = @executor.display_response(result.text)
-        display_usage(result, show_session: true)
-
-        # Save after response is displayed so viewer shows progress before Execute prompt
-        log_interactive_turn
-
-        # Add tool call/result messages so the LLM remembers what it learned
-        @history.concat(tool_messages) if tool_messages && !tool_messages.empty?
-        @history << { role: :assistant, content: result.text }
-
-        if code && !code.strip.empty?
-          if ConsoleAgent.configuration.auto_execute
-            exec_result = @executor.execute(code)
-          else
-            exec_result = @executor.confirm_and_execute(code)
-          end
-
-          unless @executor.last_cancelled?
-            @last_interactive_code = code
-            @last_interactive_output = @executor.last_output
-            @last_interactive_result = exec_result ? exec_result.inspect : nil
-            @last_interactive_executed = true
-          end
-
-          if @executor.last_cancelled?
-            @history << { role: :user, content: "User declined to execute the code." }
-          else
-            output_parts = []
-
-            # Capture printed output (puts, print, etc.)
-            if @executor.last_output && !@executor.last_output.strip.empty?
-              output_parts << "Output:\n#{@executor.last_output.strip}"
-            end
-
-            # Capture return value
-            if exec_result
-              output_parts << "Return value: #{exec_result.inspect}"
-            end
-
-            unless output_parts.empty?
-              result_str = output_parts.join("\n\n")
-              result_str = result_str[0..1000] + '...' if result_str.length > 1000
-              @history << { role: :user, content: "Code was executed. #{result_str}" }
-            end
-          end
+        # Auto-retry once when execution fails — send error back to LLM for a fix
+        if status == :error
+          $stdout.puts "\e[2m  Attempting to fix...\e[0m"
+          log_interactive_turn
+          send_and_execute
         end
 
         # Update with the AI response, tokens, and any execution results
         log_interactive_turn
+
+        warn_if_history_large
       end
 
       $stdout = @interactive_old_stdout
@@ -374,6 +360,73 @@ module ConsoleAgent
       $stderr.puts "\e[31mConsoleAgent Error: #{e.class}: #{e.message}\e[0m"
     end
 
+    # Sends conversation to LLM, displays response, executes code if present.
+    # Returns :success, :error, :cancelled, :no_code, or :interrupted.
+    def send_and_execute
+      begin
+        result, tool_messages = send_query(nil, conversation: @history)
+      rescue Interrupt
+        $stdout.puts "\n\e[33m  Aborted.\e[0m"
+        return :interrupted
+      end
+
+      track_usage(result)
+      code = @executor.display_response(result.text)
+      display_usage(result, show_session: true)
+
+      # Save after response is displayed so viewer shows progress before Execute prompt
+      log_interactive_turn
+
+      # Add tool call/result messages so the LLM remembers what it learned
+      @history.concat(tool_messages) if tool_messages && !tool_messages.empty?
+      @history << { role: :assistant, content: result.text }
+
+      return :no_code unless code && !code.strip.empty?
+
+      exec_result = if ConsoleAgent.configuration.auto_execute
+                      @executor.execute(code)
+                    else
+                      @executor.confirm_and_execute(code)
+                    end
+
+      unless @executor.last_cancelled?
+        @last_interactive_code = code
+        @last_interactive_output = @executor.last_output
+        @last_interactive_result = exec_result ? exec_result.inspect : nil
+        @last_interactive_executed = true
+      end
+
+      if @executor.last_cancelled?
+        @history << { role: :user, content: "User declined to execute the code." }
+        :cancelled
+      elsif @executor.last_error
+        error_msg = "Code execution failed with error: #{@executor.last_error}"
+        error_msg = error_msg[0..1000] + '...' if error_msg.length > 1000
+        @history << { role: :user, content: error_msg }
+        :error
+      else
+        output_parts = []
+
+        # Capture printed output (puts, print, etc.)
+        if @executor.last_output && !@executor.last_output.strip.empty?
+          output_parts << "Output:\n#{@executor.last_output.strip}"
+        end
+
+        # Capture return value
+        if exec_result
+          output_parts << "Return value: #{exec_result.inspect}"
+        end
+
+        unless output_parts.empty?
+          result_str = output_parts.join("\n\n")
+          result_str = result_str[0..1000] + '...' if result_str.length > 1000
+          @history << { role: :user, content: "Code was executed. #{result_str}" }
+        end
+
+        :success
+      end
+    end
+
     def provider
       @provider ||= Providers.build
     end
@@ -383,7 +436,32 @@ module ConsoleAgent
     end
 
     def context
-      @context ||= context_builder.build
+      base = @context_base ||= context_builder.build
+      vars = binding_variable_summary
+      vars ? "#{base}\n\n#{vars}" : base
+    end
+
+    # Summarize local and instance variables from the user's console session
+    # so the LLM knows what's available to reference in generated code.
+    def binding_variable_summary
+      parts = []
+
+      locals = @binding_context.local_variables.reject { |v| v.to_s.start_with?('_') }
+      locals.first(20).each do |var|
+        val = @binding_context.local_variable_get(var) rescue nil
+        parts << "#{var} (#{val.class})"
+      end
+
+      ivars = (@binding_context.eval("instance_variables") rescue [])
+      ivars.reject { |v| v.to_s =~ /\A@_/ }.first(20).each do |var|
+        val = @binding_context.eval(var.to_s) rescue nil
+        parts << "#{var} (#{val.class})"
+      end
+
+      return nil if parts.empty?
+      "The user's console session has these variables available: #{parts.join(', ')}. You can reference them directly in code."
+    rescue
+      nil
     end
 
     def init_system_prompt(existing_guide)
@@ -805,6 +883,64 @@ 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 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"
+    end
+
+    def compact_history
+      if @history.length < 6
+        $stdout.puts "\e[33m  History too short to compact (#{@history.length} messages). Need at least 6.\e[0m"
+        return
+      end
+
+      before_chars = @history.sum { |m| m[:content].to_s.length }
+      before_count = @history.length
+
+      $stdout.puts "\e[2m  Compacting #{before_count} messages (~#{format_tokens(before_chars)} chars)...\e[0m"
+
+      system_prompt = <<~PROMPT
+        You are a conversation summarizer. The user will provide a conversation history from a Rails console AI assistant session.
+
+        Produce a concise summary that captures:
+        - What the user has been working on and their goals
+        - 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
+
+        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
+
+      history_text = @history.map { |m| "#{m[:role]}: #{m[:content]}" }.join("\n\n")
+      messages = [{ role: :user, content: "Summarize this conversation history:\n\n#{history_text}" }]
+
+      begin
+        result = provider.chat(messages, system_prompt: system_prompt)
+        track_usage(result)
+
+        summary = result.text.to_s.strip
+        if summary.empty?
+          $stdout.puts "\e[33m  Compaction failed: empty summary returned.\e[0m"
+          return
+        end
+
+        @history = [{ role: :user, content: "CONVERSATION SUMMARY (compacted):\n#{summary}" }]
+        @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" }
+        display_usage(result)
+      rescue => e
+        $stdout.puts "\e[31m  Compaction failed: #{e.message}\e[0m"
+      end
+    end
+
     def display_exit_info
       display_session_summary
       if @interactive_session_id

data/lib/console_agent/tools/registry.rb

@@ -339,8 +339,12 @@ module ConsoleAgent
           # Make result available as step1, step2, etc. for subsequent steps
           @executor.binding_context.local_variable_set(:"step#{i + 1}", exec_result)
           output = @executor.last_output
+          error = @executor.last_error
 
           step_report = "Step #{i + 1} (#{step['description']}):\n"
+          if error
+            step_report += "ERROR: #{error}\n"
+          end
           if output && !output.strip.empty?
             step_report += "Output: #{output.strip}\n"
           end

data/lib/console_agent/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: console_agent
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Cortfr