console_agent 0.0.1 → 0.2.0

data/lib/console_agent/context_builder.rb

@@ -0,0 +1,229 @@
+module ConsoleAgent
+  class ContextBuilder
+    def initialize(config = ConsoleAgent.configuration)
+      @config = config
+    end
+
+    def build
+      case @config.context_mode
+      when :smart
+        build_smart
+      else
+        build_full
+      end
+    rescue => e
+      ConsoleAgent.logger.warn("ConsoleAgent: context build error: #{e.message}")
+      system_instructions + "\n\n" + environment_context
+    end
+
+    def build_full
+      parts = []
+      parts << system_instructions
+      parts << environment_context
+      parts << schema_context
+      parts << models_context
+      parts << routes_context
+      parts.compact.join("\n\n")
+    end
+
+    def build_smart
+      parts = []
+      parts << smart_system_instructions
+      parts << environment_context
+      parts << memory_context
+      parts.compact.join("\n\n")
+    end
+
+    private
+
+    def smart_system_instructions
+      <<~PROMPT.strip
+        You are a Ruby on Rails console assistant. The user is in a `rails console` session.
+        You help them query data, debug issues, and understand their application.
+
+        You have tools available to introspect the app's database schema, models, and source code.
+        Use them as needed to write accurate queries. For example, call list_tables to see what
+        tables exist, then describe_table to get column details for the ones you need.
+
+        You also have an ask_user tool to ask the console user clarifying questions. Use it when
+        you need specific information to write accurate code — such as which user they are, which
+        record to target, or what value to use.
+
+        You have memory tools to persist what you learn across sessions:
+        - save_memory: persist facts or procedures you learn about this codebase.
+          If a memory with the same name already exists, it will be updated in place.
+        - delete_memory: remove a memory by name
+        - recall_memories: search your saved memories for details
+
+        IMPORTANT: Check the Memories section below BEFORE answering. If a memory is relevant,
+        use recall_memories to get full details and apply that knowledge to your answer.
+        When you use a memory, mention it briefly (e.g. "Based on what I know about sharding...").
+        When you discover important patterns about this app, save them as memories.
+
+        RULES:
+        - Give ONE concise answer. Do not offer multiple alternatives or variations.
+        - Respond with a single ```ruby code block that directly answers the question.
+        - Include a brief one-line explanation before the code block.
+        - Use the app's actual model names, associations, and schema.
+        - Prefer ActiveRecord query interface over raw SQL.
+        - For destructive operations, add a comment warning.
+        - NEVER use placeholder values like YOUR_USER_ID or YOUR_EMAIL in code. If you need
+          a specific value from the user, call the ask_user tool to get it first.
+        - Keep code concise and idiomatic.
+        - Use tools to look up schema/model details rather than guessing column names.
+      PROMPT
+    end
+
+    def system_instructions
+      <<~PROMPT.strip
+        You are a Ruby on Rails console assistant. The user is in a `rails console` session.
+        You help them query data, debug issues, and understand their application.
+
+        RULES:
+        - Give ONE concise answer. Do not offer multiple alternatives or variations.
+        - Respond with a single ```ruby code block that directly answers the question.
+        - Include a brief one-line explanation before the code block.
+        - Use the app's actual model names, associations, and schema.
+        - Prefer ActiveRecord query interface over raw SQL.
+        - For destructive operations, add a comment warning.
+        - If the request is ambiguous, ask a clarifying question instead of guessing.
+        - Keep code concise and idiomatic.
+      PROMPT
+    end
+
+    def environment_context
+      lines = ["## Environment"]
+      lines << "- Ruby #{RUBY_VERSION}"
+      lines << "- Rails #{Rails.version}" if defined?(Rails) && Rails.respond_to?(:version)
+
+      if defined?(ActiveRecord::Base) && ActiveRecord::Base.connected?
+        adapter = ActiveRecord::Base.connection.adapter_name rescue 'unknown'
+        lines << "- Database adapter: #{adapter}"
+      end
+
+      if defined?(Bundler)
+        key_gems = %w[devise cancancan pundit sidekiq delayed_job resque
+                      paperclip carrierwave activestorage shrine
+                      pg mysql2 sqlite3 mongoid]
+        loaded = key_gems.select { |g| Gem.loaded_specs.key?(g) }
+        lines << "- Key gems: #{loaded.join(', ')}" unless loaded.empty?
+      end
+
+      lines.join("\n")
+    end
+
+    def schema_context
+      return nil unless defined?(ActiveRecord::Base) && ActiveRecord::Base.connected?
+
+      conn = ActiveRecord::Base.connection
+      tables = conn.tables.sort
+      return nil if tables.empty?
+
+      lines = ["## Database Schema"]
+      tables.each do |table|
+        next if table == 'schema_migrations' || table == 'ar_internal_metadata'
+
+        cols = conn.columns(table).map { |c| "#{c.name}:#{c.type}" }
+        lines << "- #{table} (#{cols.join(', ')})"
+      end
+      lines.join("\n")
+    rescue => e
+      ConsoleAgent.logger.debug("ConsoleAgent: schema introspection failed: #{e.message}")
+      nil
+    end
+
+    def models_context
+      return nil unless defined?(ActiveRecord::Base)
+
+      eager_load_app!
+      base_class = defined?(ApplicationRecord) ? ApplicationRecord : ActiveRecord::Base
+      models = ObjectSpace.each_object(Class).select { |c|
+        c < base_class && !c.abstract_class? && c.name && !c.name.start_with?('HABTM_')
+      }.sort_by(&:name)
+
+      return nil if models.empty?
+
+      lines = ["## Models"]
+      models.each do |model|
+        parts = [model.name]
+
+        assocs = model.reflect_on_all_associations.map { |a| "#{a.macro} :#{a.name}" }
+        parts << "  associations: #{assocs.join(', ')}" unless assocs.empty?
+
+        scopes = model.methods.grep(/^_scope_/).map { |m| m.to_s.sub('_scope_', '') } rescue []
+        if scopes.empty?
+          # Alternative: check singleton methods that return ActiveRecord::Relation
+          scope_names = (model.singleton_methods - base_class.singleton_methods).select { |m|
+            m != :all && !m.to_s.start_with?('_') && !m.to_s.start_with?('find')
+          }.first(10)
+          # We won't list these to avoid noise — scopes are hard to detect reliably
+        end
+
+        validations = model.validators.map { |v|
+          attrs = v.attributes.join(', ')
+          "#{v.class.name.demodulize.underscore.sub('_validator', '')} on #{attrs}"
+        }.uniq.first(5) rescue []
+        parts << "  validations: #{validations.join('; ')}" unless validations.empty?
+
+        lines << "- #{parts.join("\n")}"
+      end
+      lines.join("\n")
+    rescue => e
+      ConsoleAgent.logger.debug("ConsoleAgent: model introspection failed: #{e.message}")
+      nil
+    end
+
+    def routes_context
+      return nil unless defined?(Rails) && Rails.respond_to?(:application)
+
+      routes = Rails.application.routes.routes
+      return nil if routes.empty?
+
+      lines = ["## Routes (summary)"]
+      count = 0
+      routes.each do |route|
+        next if route.internal?
+        path = route.path.spec.to_s.sub('(.:format)', '')
+        verb = route.verb.to_s
+        next if verb.empty?
+        action = route.defaults[:controller].to_s + '#' + route.defaults[:action].to_s
+        lines << "- #{verb} #{path} -> #{action}"
+        count += 1
+        break if count >= 50
+      end
+      lines << "- ... (#{routes.size - count} more routes)" if routes.size > count
+
+      lines.join("\n")
+    rescue => e
+      ConsoleAgent.logger.debug("ConsoleAgent: route introspection failed: #{e.message}")
+      nil
+    end
+
+    def memory_context
+      return nil unless @config.memories_enabled
+
+      require 'console_agent/tools/memory_tools'
+      summaries = Tools::MemoryTools.new.memory_summaries
+      return nil if summaries.nil? || summaries.empty?
+
+      lines = ["## Memories"]
+      lines.concat(summaries)
+      lines << ""
+      lines << "Call recall_memories to get details before answering. Do NOT guess from the name alone."
+      lines.join("\n")
+    rescue => e
+      ConsoleAgent.logger.debug("ConsoleAgent: memory context failed: #{e.message}")
+      nil
+    end
+
+    def eager_load_app!
+      return unless defined?(Rails) && Rails.respond_to?(:application)
+
+      if Rails.application.respond_to?(:eager_load!)
+        Rails.application.eager_load!
+      end
+    rescue => e
+      ConsoleAgent.logger.debug("ConsoleAgent: eager_load failed: #{e.message}")
+    end
+  end
+end

data/lib/console_agent/executor.rb

@@ -0,0 +1,193 @@
+require 'stringio'
+
+module ConsoleAgent
+  # Writes to two IO streams simultaneously
+  class TeeIO
+    def initialize(primary, secondary)
+      @primary = primary
+      @secondary = secondary
+    end
+
+    def write(str)
+      @primary.write(str)
+      @secondary.write(str)
+    end
+
+    def puts(*args)
+      @primary.puts(*args)
+      # Capture what puts would output
+      args.each { |a| @secondary.write("#{a}\n") }
+      @secondary.write("\n") if args.empty?
+    end
+
+    def print(*args)
+      @primary.print(*args)
+      args.each { |a| @secondary.write(a.to_s) }
+    end
+
+    def flush
+      @primary.flush if @primary.respond_to?(:flush)
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      @primary.respond_to?(method, include_private) || super
+    end
+
+    def method_missing(method, *args, &block)
+      @primary.send(method, *args, &block)
+    end
+  end
+
+  class Executor
+    CODE_REGEX = /```ruby\s*\n(.*?)```/m
+
+    attr_reader :binding_context
+
+    def initialize(binding_context)
+      @binding_context = binding_context
+    end
+
+    def extract_code(response)
+      match = response.match(CODE_REGEX)
+      match ? match[1].strip : ''
+    end
+
+    def display_response(response)
+      code = extract_code(response)
+      explanation = response.gsub(CODE_REGEX, '').strip
+
+      $stdout.puts
+      $stdout.puts colorize(explanation, :cyan) unless explanation.empty?
+
+      unless code.empty?
+        $stdout.puts
+        $stdout.puts colorize("# Generated code:", :yellow)
+        $stdout.puts highlight_code(code)
+        $stdout.puts
+      end
+
+      code
+    end
+
+    def execute(code)
+      return nil if code.nil? || code.strip.empty?
+
+      captured_output = StringIO.new
+      old_stdout = $stdout
+      # Tee output: capture it and also print to the real stdout
+      $stdout = TeeIO.new(old_stdout, captured_output)
+
+      result = binding_context.eval(code, "(console_agent)", 1)
+
+      $stdout = old_stdout
+      $stdout.puts colorize("=> #{result.inspect}", :green)
+
+      @last_output = captured_output.string
+      result
+    rescue SyntaxError => e
+      $stdout = old_stdout if old_stdout
+      $stderr.puts colorize("SyntaxError: #{e.message}", :red)
+      @last_output = nil
+      nil
+    rescue => e
+      $stdout = old_stdout if old_stdout
+      $stderr.puts colorize("Error: #{e.class}: #{e.message}", :red)
+      e.backtrace.first(3).each { |line| $stderr.puts colorize("  #{line}", :red) }
+      @last_output = captured_output&.string
+      nil
+    end
+
+    def last_output
+      @last_output
+    end
+
+    def last_cancelled?
+      @last_cancelled
+    end
+
+    def confirm_and_execute(code)
+      return nil if code.nil? || code.strip.empty?
+
+      @last_cancelled = false
+      $stdout.print colorize("Execute? [y/N/edit] ", :yellow)
+      answer = $stdin.gets.to_s.strip.downcase
+
+      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)
+          if $stdin.gets.to_s.strip.downcase == 'y'
+            execute(edited)
+          else
+            $stdout.puts colorize("Cancelled.", :yellow)
+            nil
+          end
+        else
+          execute(code)
+        end
+      else
+        $stdout.puts colorize("Cancelled.", :yellow)
+        @last_cancelled = true
+        nil
+      end
+    end
+
+    private
+
+    def open_in_editor(code)
+      require 'tempfile'
+      editor = ENV['EDITOR'] || 'vi'
+      tmpfile = Tempfile.new(['console_agent', '.rb'])
+      tmpfile.write(code)
+      tmpfile.flush
+
+      system("#{editor} #{tmpfile.path}")
+      File.read(tmpfile.path)
+    rescue => e
+      $stderr.puts colorize("Editor error: #{e.message}", :red)
+      code
+    ensure
+      tmpfile.close! if tmpfile
+    end
+
+    def highlight_code(code)
+      if coderay_available?
+        CodeRay.scan(code, :ruby).terminal
+      else
+        colorize(code, :white)
+      end
+    end
+
+    def coderay_available?
+      return @coderay_available unless @coderay_available.nil?
+      @coderay_available = begin
+        require 'coderay'
+        true
+      rescue LoadError
+        false
+      end
+    end
+
+    COLORS = {
+      red:    "\e[31m",
+      green:  "\e[32m",
+      yellow: "\e[33m",
+      cyan:   "\e[36m",
+      white:  "\e[37m",
+      reset:  "\e[0m"
+    }.freeze
+
+    def colorize(text, color)
+      if $stdout.respond_to?(:tty?) && $stdout.tty?
+        "#{COLORS[color]}#{text}#{COLORS[:reset]}"
+      else
+        text
+      end
+    end
+  end
+end

data/lib/console_agent/providers/anthropic.rb

@@ -0,0 +1,112 @@
+module ConsoleAgent
+  module Providers
+    class Anthropic < Base
+      API_URL = 'https://api.anthropic.com'.freeze
+
+      def chat(messages, system_prompt: nil)
+        result = call_api(messages, system_prompt: system_prompt)
+        result
+      end
+
+      def chat_with_tools(messages, tools:, system_prompt: nil)
+        call_api(messages, system_prompt: system_prompt, tools: tools)
+      end
+
+      def format_assistant_message(result)
+        # Rebuild the assistant content blocks from the raw response
+        content_blocks = []
+        content_blocks << { 'type' => 'text', 'text' => result.text } if result.text && !result.text.empty?
+        (result.tool_calls || []).each do |tc|
+          content_blocks << {
+            'type' => 'tool_use',
+            'id' => tc[:id],
+            'name' => tc[:name],
+            'input' => tc[:arguments]
+          }
+        end
+        { role: 'assistant', content: content_blocks }
+      end
+
+      def format_tool_result(tool_call_id, result_string)
+        {
+          role: 'user',
+          content: [
+            {
+              'type' => 'tool_result',
+              'tool_use_id' => tool_call_id,
+              'content' => result_string.to_s
+            }
+          ]
+        }
+      end
+
+      private
+
+      def call_api(messages, system_prompt: nil, tools: nil)
+        conn = build_connection(API_URL, {
+          'x-api-key' => config.resolved_api_key,
+          'anthropic-version' => '2023-06-01'
+        })
+
+        body = {
+          model: config.resolved_model,
+          max_tokens: config.max_tokens,
+          temperature: config.temperature,
+          messages: format_messages(messages)
+        }
+        body[:system] = system_prompt if system_prompt
+        body[:tools] = tools.to_anthropic_format if tools
+
+        json_body = JSON.generate(body)
+        debug_request("#{API_URL}/v1/messages", body)
+        response = conn.post('/v1/messages', json_body)
+        debug_response(response.body)
+        data = parse_response(response)
+        usage = data['usage'] || {}
+
+        tool_calls = extract_tool_calls(data)
+        stop = data['stop_reason'] == 'tool_use' ? :tool_use : :end_turn
+
+        ChatResult.new(
+          text: extract_text(data),
+          input_tokens: usage['input_tokens'],
+          output_tokens: usage['output_tokens'],
+          tool_calls: tool_calls,
+          stop_reason: stop
+        )
+      end
+
+      def format_messages(messages)
+        messages.map do |msg|
+          if msg[:content].is_a?(Array)
+            { role: msg[:role].to_s, content: msg[:content] }
+          else
+            { role: msg[:role].to_s, content: msg[:content].to_s }
+          end
+        end
+      end
+
+      def extract_text(data)
+        content = data['content']
+        return '' unless content.is_a?(Array)
+
+        content.select { |c| c['type'] == 'text' }
+               .map { |c| c['text'] }
+               .join("\n")
+      end
+
+      def extract_tool_calls(data)
+        content = data['content']
+        return [] unless content.is_a?(Array)
+
+        content.select { |c| c['type'] == 'tool_use' }.map do |c|
+          {
+            id: c['id'],
+            name: c['name'],
+            arguments: c['input'] || {}
+          }
+        end
+      end
+    end
+  end
+end

data/lib/console_agent/providers/base.rb

@@ -0,0 +1,106 @@
+require 'faraday'
+require 'json'
+
+module ConsoleAgent
+  module Providers
+    class Base
+      attr_reader :config
+
+      def initialize(config = ConsoleAgent.configuration)
+        @config = config
+      end
+
+      def chat(messages, system_prompt: nil)
+        raise NotImplementedError, "#{self.class}#chat must be implemented"
+      end
+
+      def chat_with_tools(messages, tools:, system_prompt: nil)
+        raise NotImplementedError, "#{self.class}#chat_with_tools must be implemented"
+      end
+
+      def format_assistant_message(_result)
+        raise NotImplementedError, "#{self.class}#format_assistant_message must be implemented"
+      end
+
+      def format_tool_result(_tool_call_id, _result_string)
+        raise NotImplementedError, "#{self.class}#format_tool_result must be implemented"
+      end
+
+      private
+
+      def build_connection(url, headers = {})
+        Faraday.new(url: url) do |f|
+          f.options.timeout = config.timeout
+          f.options.open_timeout = config.timeout
+          f.headers.update(headers)
+          f.headers['Content-Type'] = 'application/json'
+          f.adapter Faraday.default_adapter
+        end
+      end
+
+      def debug_request(url, body)
+        return unless config.debug
+
+        $stderr.puts "\e[33m--- ConsoleAgent DEBUG: REQUEST ---\e[0m"
+        $stderr.puts "\e[33mURL: #{url}\e[0m"
+        parsed = body.is_a?(String) ? JSON.parse(body) : body
+        $stderr.puts "\e[33m#{JSON.pretty_generate(parsed)}\e[0m"
+        $stderr.puts "\e[33m--- END REQUEST ---\e[0m"
+      rescue => e
+        $stderr.puts "\e[33m[debug] #{body}\e[0m"
+      end
+
+      def debug_response(body)
+        return unless config.debug
+
+        $stderr.puts "\e[36m--- ConsoleAgent DEBUG: RESPONSE ---\e[0m"
+        parsed = body.is_a?(String) ? JSON.parse(body) : body
+        $stderr.puts "\e[36m#{JSON.pretty_generate(parsed)}\e[0m"
+        $stderr.puts "\e[36m--- END RESPONSE ---\e[0m"
+      rescue => e
+        $stderr.puts "\e[36m[debug] #{body}\e[0m"
+      end
+
+      def parse_response(response)
+        unless response.success?
+          body = begin
+                   JSON.parse(response.body)
+                 rescue
+                   { 'error' => response.body }
+                 end
+          error_msg = body.dig('error', 'message') || body['error'] || response.body
+          raise ProviderError, "API error (#{response.status}): #{error_msg}"
+        end
+
+        JSON.parse(response.body)
+      rescue JSON::ParserError => e
+        raise ProviderError, "Failed to parse response: #{e.message}"
+      end
+    end
+
+    class ProviderError < StandardError; end
+
+    ChatResult = Struct.new(:text, :input_tokens, :output_tokens, :tool_calls, :stop_reason, keyword_init: true) do
+      def total_tokens
+        (input_tokens || 0) + (output_tokens || 0)
+      end
+
+      def tool_use?
+        stop_reason == :tool_use && tool_calls && !tool_calls.empty?
+      end
+    end
+
+    def self.build(config = ConsoleAgent.configuration)
+      case config.provider
+      when :anthropic
+        require 'console_agent/providers/anthropic'
+        Anthropic.new(config)
+      when :openai
+        require 'console_agent/providers/openai'
+        OpenAI.new(config)
+      else
+        raise ConfigurationError, "Unknown provider: #{config.provider}"
+      end
+    end
+  end
+end