console_agent 0.2.0 → 0.4.0

data/lib/console_agent/repl.rb

@@ -15,17 +15,44 @@ module ConsoleAgent
     end
 
     def one_shot(query)
-      result = send_query(query)
-      track_usage(result)
-      code = @executor.display_response(result.text)
-      display_usage(result)
-      return nil if code.nil? || code.strip.empty?
-
-      if ConsoleAgent.configuration.auto_execute
-        @executor.execute(code)
-      else
-        @executor.confirm_and_execute(code)
+      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?
+        end
+
+        @_last_log_attrs = {
+          query: query,
+          conversation: [{ role: :user, content: query }, { role: :assistant, content: result.text }],
+          mode: 'one_shot',
+          code_executed: has_code ? code : nil,
+          code_output: executed ? @executor.last_output : nil,
+          code_result: executed && exec_result ? exec_result.inspect : nil,
+          executed: executed,
+          start_time: start_time
+        }
+
+        exec_result
       end
+
+      log_session(@_last_log_attrs.merge(console_output: console_capture.string))
+
+      exec_result
     rescue Providers::ProviderError => e
       $stderr.puts "\e[31mConsoleAgent Error: #{e.message}\e[0m"
       nil
@@ -35,10 +62,25 @@ module ConsoleAgent
     end
 
     def explain(query)
-      result = send_query(query)
-      track_usage(result)
-      @executor.display_response(result.text)
-      display_usage(result)
+      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      console_capture = StringIO.new
+      with_console_capture(console_capture) do
+        result, _ = send_query(query)
+        track_usage(result)
+        @executor.display_response(result.text)
+        display_usage(result)
+
+        @_last_log_attrs = {
+          query: query,
+          conversation: [{ role: :user, content: query }, { role: :assistant, content: result.text }],
+          mode: 'explain',
+          executed: false,
+          start_time: start_time
+        }
+      end
+
+      log_session(@_last_log_attrs.merge(console_output: console_capture.string))
+
       nil
     rescue Providers::ProviderError => e
       $stderr.puts "\e[31mConsoleAgent Error: #{e.message}\e[0m"
@@ -49,29 +91,132 @@ module ConsoleAgent
     end
 
     def interactive
-      $stdout.puts "\e[36mConsoleAgent interactive mode. Type 'exit' or 'quit' to leave.\e[0m"
+      init_interactive_state
+      interactive_loop
+    end
+
+    def resume(session)
+      init_interactive_state
+
+      # Restore state from the previous session
+      @history = JSON.parse(session.conversation, symbolize_names: true)
+      @interactive_session_id = session.id
+      @interactive_query = session.query
+      @interactive_session_name = session.name
+      @total_input_tokens = session.input_tokens || 0
+      @total_output_tokens = session.output_tokens || 0
+
+      # Seed the capture buffer with previous output so it's preserved on save
+      @interactive_console_capture.write(session.console_output.to_s)
+
+      # Replay to the user via the real stdout (bypass TeeIO to avoid double-capture)
+      if session.console_output && !session.console_output.strip.empty?
+        @interactive_old_stdout.puts "\e[2m--- Replaying previous session output ---\e[0m"
+        @interactive_old_stdout.puts session.console_output
+        @interactive_old_stdout.puts "\e[2m--- End of previous output ---\e[0m"
+        @interactive_old_stdout.puts
+      end
+
+      interactive_loop
+    end
+
+    private
+
+    def init_interactive_state
+      @interactive_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      @interactive_console_capture = StringIO.new
+      @interactive_old_stdout = $stdout
+      $stdout = TeeIO.new(@interactive_old_stdout, @interactive_console_capture)
+      @executor.on_prompt = -> { log_interactive_turn }
+
       @history = []
       @total_input_tokens = 0
       @total_output_tokens = 0
+      @interactive_query = nil
+      @interactive_session_id = nil
+      @interactive_session_name = nil
+      @last_interactive_code = nil
+      @last_interactive_output = nil
+      @last_interactive_result = nil
+      @last_interactive_executed = false
+    end
+
+    def interactive_loop
+      auto = ConsoleAgent.configuration.auto_execute
+      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) | /usage | /name <label>\e[0m"
+
+      # Bind Shift-Tab to insert /auto command and submit
+      if Readline.respond_to?(:parse_and_bind)
+        Readline.parse_and_bind('"\e[Z": "\C-a\C-k/auto\C-m"')
+      end
 
       loop do
-        input = Readline.readline("\e[33mai> \e[0m", false)
+        input = Readline.readline("\001\e[33m\002ai> \001\e[0m\002", false)
         break if input.nil? # Ctrl-D
 
         input = input.strip
         break if input.downcase == 'exit' || input.downcase == 'quit'
         next if input.empty?
 
+        if input == '/auto'
+          ConsoleAgent.configuration.auto_execute = !ConsoleAgent.configuration.auto_execute
+          mode = ConsoleAgent.configuration.auto_execute ? 'ON' : 'OFF'
+          @interactive_old_stdout.puts "\e[36m  Auto-execute: #{mode}\e[0m"
+          next
+        end
+
+        if input == '/usage'
+          display_session_summary
+          next
+        end
+
+        if input == '/debug'
+          ConsoleAgent.configuration.debug = !ConsoleAgent.configuration.debug
+          mode = ConsoleAgent.configuration.debug ? 'ON' : 'OFF'
+          @interactive_old_stdout.puts "\e[36m  Debug: #{mode}\e[0m"
+          next
+        end
+
+        if input.start_with?('/name')
+          name = input.sub('/name', '').strip
+          if name.empty?
+            if @interactive_session_name
+              @interactive_old_stdout.puts "\e[36m  Session name: #{@interactive_session_name}\e[0m"
+            else
+              @interactive_old_stdout.puts "\e[33m  Usage: /name <label>  (e.g. /name salesforce_user_123)\e[0m"
+            end
+          else
+            @interactive_session_name = name
+            if @interactive_session_id
+              require 'console_agent/session_logger'
+              SessionLogger.update(@interactive_session_id, name: name)
+            end
+            @interactive_old_stdout.puts "\e[36m  Session named: #{name}\e[0m"
+          end
+          next
+        end
+
         # Add to Readline history (avoid consecutive duplicates)
         Readline::HISTORY.push(input) unless input == Readline::HISTORY.to_a.last
 
+        @interactive_query ||= input
         @history << { role: :user, content: input }
 
+        # Log the user's prompt line to the console capture (Readline doesn't go through $stdout)
+        @interactive_console_capture.write("ai> #{input}\n")
+
+        # Save immediately so the session is visible in the admin UI while the AI thinks
+        log_interactive_turn
+
         begin
-          result = send_query(input, conversation: @history)
+          result, tool_messages = send_query(input, conversation: @history)
         rescue Interrupt
           $stdout.puts "\n\e[33m  Aborted.\e[0m"
           @history.pop # Remove the user message that never got a response
+          log_interactive_turn
           next
         end
 
@@ -79,6 +224,11 @@ module ConsoleAgent
         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?
@@ -88,6 +238,13 @@ module ConsoleAgent
             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
@@ -110,21 +267,28 @@ module ConsoleAgent
             end
           end
         end
+
+        # Update with the AI response, tokens, and any execution results
+        log_interactive_turn
       end
 
-      display_session_summary
-      $stdout.puts "\e[36mLeft ConsoleAgent interactive mode.\e[0m"
+      $stdout = @interactive_old_stdout
+      @executor.on_prompt = nil
+      finish_interactive_session
+      display_exit_info
     rescue Interrupt
       # Ctrl-C during Readline input — exit cleanly
+      $stdout = @interactive_old_stdout if @interactive_old_stdout
+      @executor.on_prompt = nil
       $stdout.puts
-      display_session_summary
-      $stdout.puts "\e[36mLeft ConsoleAgent interactive mode.\e[0m"
+      finish_interactive_session
+      display_exit_info
     rescue => e
+      $stdout = @interactive_old_stdout if @interactive_old_stdout
+      @executor.on_prompt = nil
       $stderr.puts "\e[31mConsoleAgent Error: #{e.class}: #{e.message}\e[0m"
     end
 
-    private
-
     def provider
       @provider ||= Providers.build
     end
@@ -141,25 +305,22 @@ module ConsoleAgent
       ConsoleAgent.configuration.validate!
 
       messages = if conversation
-                   conversation.map { |m| { role: m[:role], content: m[:content] } }
+                   conversation.dup
                  else
                    [{ role: :user, content: query }]
                  end
 
-      if ConsoleAgent.configuration.context_mode == :smart
-        send_query_with_tools(messages)
-      else
-        provider.chat(messages, system_prompt: context)
-      end
+      send_query_with_tools(messages)
     end
 
     def send_query_with_tools(messages)
       require 'console_agent/tools/registry'
-      tools = Tools::Registry.new
+      tools = Tools::Registry.new(executor: @executor)
       max_rounds = ConsoleAgent.configuration.max_tool_rounds
       total_input = 0
       total_output = 0
       result = nil
+      new_messages = []  # Track messages added during tool use
 
       exhausted = false
 
@@ -168,7 +329,20 @@ module ConsoleAgent
           $stdout.puts "\e[2m  Thinking...\e[0m"
         end
 
-        result = provider.chat_with_tools(messages, tools: tools, system_prompt: context)
+        begin
+          result = with_escape_monitoring do
+            provider.chat_with_tools(messages, tools: tools, system_prompt: context)
+          end
+        rescue Interrupt
+          redirect = prompt_for_redirect
+          if redirect
+            messages << { role: :user, content: redirect }
+            new_messages << messages.last
+            next
+          else
+            raise
+          end
+        end
         total_input += result.input_tokens || 0
         total_output += result.output_tokens || 0
 
@@ -180,12 +354,14 @@ module ConsoleAgent
         end
 
         # Add assistant message with tool calls to conversation
-        messages << provider.format_assistant_message(result)
+        assistant_msg = provider.format_assistant_message(result)
+        messages << assistant_msg
+        new_messages << assistant_msg
 
         # Execute each tool and show progress
         result.tool_calls.each do |tc|
-          # ask_user handles its own display (prompt + input)
-          if tc[:name] == 'ask_user'
+          # ask_user and execute_plan handle their own display
+          if tc[:name] == 'ask_user' || tc[:name] == 'execute_plan'
             tool_result = tools.execute(tc[:name], tc[:arguments])
           else
             args_display = format_tool_args(tc[:name], tc[:arguments])
@@ -202,7 +378,9 @@ module ConsoleAgent
             $stderr.puts "\e[35m[debug tool result] #{tool_result}\e[0m"
           end
 
-          messages << provider.format_tool_result(tc[:id], tool_result)
+          tool_msg = provider.format_tool_result(tc[:id], tool_result)
+          messages << tool_msg
+          new_messages << tool_msg
         end
 
         exhausted = true if round == max_rounds - 1
@@ -217,12 +395,66 @@ module ConsoleAgent
         total_output += result.output_tokens || 0
       end
 
-      Providers::ChatResult.new(
+      final_result = Providers::ChatResult.new(
         text: result ? result.text : '',
         input_tokens: total_input,
         output_tokens: total_output,
         stop_reason: result ? result.stop_reason : :end_turn
       )
+      [final_result, new_messages]
+    end
+
+    # Monitors stdin for Escape (or Ctrl+C, since raw mode disables signals)
+    # and raises Interrupt in the main thread when detected.
+    def with_escape_monitoring
+      require 'io/console'
+      return yield unless $stdin.respond_to?(:raw)
+
+      monitor = Thread.new do
+        Thread.current.report_on_exception = false
+        $stdin.raw do |io|
+          loop do
+            break if Thread.current[:stop]
+            ready = IO.select([io], nil, nil, 0.2)
+            next unless ready
+
+            char = io.read_nonblock(1) rescue nil
+            next unless char
+
+            if char == "\x03" # Ctrl+C (raw mode eats the signal)
+              Thread.main.raise(Interrupt)
+              break
+            elsif char == "\e"
+              # Distinguish standalone Escape from escape sequences (arrow keys, etc.)
+              seq = IO.select([io], nil, nil, 0.05)
+              if seq
+                io.read_nonblock(10) rescue nil # consume the sequence
+              else
+                Thread.main.raise(Interrupt)
+                break
+              end
+            end
+          end
+        end
+      rescue IOError, Errno::EIO, Errno::ENODEV, Errno::ENOTTY
+        # stdin is not a TTY (e.g. in tests or piped input) — silently skip
+      end
+
+      begin
+        yield
+      ensure
+        monitor[:stop] = true
+        monitor.join(1) rescue nil
+      end
+    end
+
+    def prompt_for_redirect
+      $stdout.puts "\n\e[33m  Interrupted. What should the AI do differently?\e[0m"
+      $stdout.puts "\e[2m  (Press Enter with no input to abort entirely)\e[0m"
+      $stdout.print "\e[33m  redirect> \e[0m"
+      input = $stdin.gets
+      return nil if input.nil? || input.strip.empty?
+      input.strip
     end
 
     def format_tool_args(name, args)
@@ -246,6 +478,9 @@ module ConsoleAgent
         "(\"#{args['name']}\")"
       when 'recall_memories'
         args['query'] ? "(\"#{args['query']}\")" : ''
+      when 'execute_plan'
+        steps = args['steps']
+        steps ? "(#{steps.length} steps)" : ''
       else
         ''
       end
@@ -300,6 +535,9 @@ module ConsoleAgent
       when 'recall_memories'
         chunks = result.split("\n\n")
         chunks.length > 1 ? "#{chunks.length} memories found" : truncate(result, 80)
+      when 'execute_plan'
+        steps_done = result.scan(/^Step \d+/).length
+        steps_done > 0 ? "#{steps_done} steps executed" : truncate(result, 80)
       else
         truncate(result, 80)
       end
@@ -333,10 +571,104 @@ module ConsoleAgent
       $stdout.puts line
     end
 
+    def with_console_capture(capture_io)
+      old_stdout = $stdout
+      $stdout = TeeIO.new(old_stdout, capture_io)
+      yield
+    ensure
+      $stdout = old_stdout
+    end
+
+    def log_interactive_turn
+      require 'console_agent/session_logger'
+      session_attrs = {
+        conversation:  @history,
+        input_tokens:  @total_input_tokens,
+        output_tokens: @total_output_tokens,
+        code_executed: @last_interactive_code,
+        code_output:   @last_interactive_output,
+        code_result:   @last_interactive_result,
+        executed:      @last_interactive_executed,
+        console_output: @interactive_console_capture&.string
+      }
+
+      if @interactive_session_id
+        SessionLogger.update(@interactive_session_id, session_attrs)
+      else
+        @interactive_session_id = SessionLogger.log(
+          session_attrs.merge(
+            query: @interactive_query || '(interactive session)',
+            mode:  'interactive',
+            name:  @interactive_session_name
+          )
+        )
+      end
+    end
+
+    def finish_interactive_session
+      require 'console_agent/session_logger'
+      duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - @interactive_start) * 1000).round
+      if @interactive_session_id
+        SessionLogger.update(@interactive_session_id,
+          conversation:  @history,
+          input_tokens:  @total_input_tokens,
+          output_tokens: @total_output_tokens,
+          code_executed: @last_interactive_code,
+          code_output:   @last_interactive_output,
+          code_result:   @last_interactive_result,
+          executed:      @last_interactive_executed,
+          console_output: @interactive_console_capture&.string,
+          duration_ms:   duration_ms
+        )
+      elsif @interactive_query
+        # Session was never created (e.g., only one turn that failed to log)
+        log_session(
+          query: @interactive_query,
+          conversation: @history,
+          mode: 'interactive',
+          code_executed: @last_interactive_code,
+          code_output: @last_interactive_output,
+          code_result: @last_interactive_result,
+          executed: @last_interactive_executed,
+          console_output: @interactive_console_capture&.string,
+          start_time: @interactive_start
+        )
+      end
+    end
+
+    def log_session(attrs)
+      require 'console_agent/session_logger'
+      start_time = attrs.delete(:start_time)
+      duration_ms = if start_time
+                      ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round
+                    end
+      SessionLogger.log(
+        attrs.merge(
+          input_tokens: @total_input_tokens,
+          output_tokens: @total_output_tokens,
+          duration_ms: duration_ms
+        )
+      )
+    end
+
     def display_session_summary
       return if @total_input_tokens == 0 && @total_output_tokens == 0
 
       $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_exit_info
+      display_session_summary
+      if @interactive_session_id
+        $stdout.puts "\e[36mSession ##{@interactive_session_id} saved.\e[0m"
+        if @interactive_session_name
+          $stdout.puts "\e[2m  Resume with: ai_resume \"#{@interactive_session_name}\"\e[0m"
+        else
+          $stdout.puts "\e[2m  Name it:   ai_name #{@interactive_session_id}, \"descriptive_name\"\e[0m"
+          $stdout.puts "\e[2m  Resume it: ai_resume #{@interactive_session_id}\e[0m"
+        end
+      end
+      $stdout.puts "\e[36mLeft ConsoleAgent interactive mode.\e[0m"
+    end
   end
 end

data/lib/console_agent/session_logger.rb

@@ -0,0 +1,79 @@
+module ConsoleAgent
+  module SessionLogger
+    class << self
+      def log(attrs)
+        return unless ConsoleAgent.configuration.session_logging
+        return unless table_exists?
+
+        record = session_class.create!(
+          query:         attrs[:query],
+          conversation:  Array(attrs[:conversation]).to_json,
+          input_tokens:  attrs[:input_tokens] || 0,
+          output_tokens: attrs[:output_tokens] || 0,
+          user_name:     current_user_name,
+          mode:          attrs[:mode].to_s,
+          name:          attrs[:name],
+          code_executed: attrs[:code_executed],
+          code_output:   attrs[:code_output],
+          code_result:   attrs[:code_result],
+          console_output: attrs[:console_output],
+          executed:      attrs[:executed] || false,
+          provider:      ConsoleAgent.configuration.provider.to_s,
+          model:         ConsoleAgent.configuration.resolved_model,
+          duration_ms:   attrs[:duration_ms],
+          created_at:    Time.respond_to?(:current) ? Time.current : Time.now
+        )
+        record.id
+      rescue => e
+        msg = "ConsoleAgent: session logging failed: #{e.class}: #{e.message}"
+        $stderr.puts "\e[33m#{msg}\e[0m" if $stderr.respond_to?(:puts)
+        ConsoleAgent.logger.warn(msg)
+        nil
+      end
+
+      def update(id, attrs)
+        return unless id
+        return unless ConsoleAgent.configuration.session_logging
+        return unless table_exists?
+
+        updates = {}
+        updates[:conversation]  = Array(attrs[:conversation]).to_json if attrs.key?(:conversation)
+        updates[:input_tokens]  = attrs[:input_tokens]  if attrs.key?(:input_tokens)
+        updates[:output_tokens] = attrs[:output_tokens] if attrs.key?(:output_tokens)
+        updates[:code_executed] = attrs[:code_executed]  if attrs.key?(:code_executed)
+        updates[:code_output]   = attrs[:code_output]    if attrs.key?(:code_output)
+        updates[:code_result]   = attrs[:code_result]    if attrs.key?(:code_result)
+        updates[:console_output] = attrs[:console_output] if attrs.key?(:console_output)
+        updates[:executed]      = attrs[:executed]       if attrs.key?(:executed)
+        updates[:duration_ms]   = attrs[:duration_ms]    if attrs.key?(:duration_ms)
+        updates[:name]          = attrs[:name]           if attrs.key?(:name)
+
+        session_class.where(id: id).update_all(updates) unless updates.empty?
+      rescue => e
+        msg = "ConsoleAgent: session update failed: #{e.class}: #{e.message}"
+        $stderr.puts "\e[33m#{msg}\e[0m" if $stderr.respond_to?(:puts)
+        ConsoleAgent.logger.warn(msg)
+        nil
+      end
+
+      private
+
+      def table_exists?
+        # Only cache positive results — retry on failure so transient
+        # errors (boot timing, connection not ready) don't stick forever
+        return true if @table_exists
+        @table_exists = session_class.connection.table_exists?('console_agent_sessions')
+      rescue
+        false
+      end
+
+      def session_class
+        Object.const_get('ConsoleAgent::Session')
+      end
+
+      def current_user_name
+        ConsoleAgent.current_user || ENV['USER']
+      end
+    end
+  end
+end