console_agent 0.0.1 → 0.1.0

data/lib/console_agent/executor.rb

@@ -0,0 +1,131 @@
+module ConsoleAgent
+  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?
+
+      result = binding_context.eval(code, "(console_agent)", 1)
+      $stdout.puts colorize("=> #{result.inspect}", :green)
+      result
+    rescue SyntaxError => e
+      $stderr.puts colorize("SyntaxError: #{e.message}", :red)
+      nil
+    rescue => e
+      $stderr.puts colorize("Error: #{e.class}: #{e.message}", :red)
+      e.backtrace.first(3).each { |line| $stderr.puts colorize("  #{line}", :red) }
+      nil
+    end
+
+    def confirm_and_execute(code)
+      return nil if code.nil? || code.strip.empty?
+
+      $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)
+        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

data/lib/console_agent/providers/openai.rb

@@ -0,0 +1,114 @@
+module ConsoleAgent
+  module Providers
+    class OpenAI < Base
+      API_URL = 'https://api.openai.com'.freeze
+
+      def chat(messages, system_prompt: nil)
+        call_api(messages, system_prompt: system_prompt)
+      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)
+        msg = { role: 'assistant' }
+        msg[:content] = result.text if result.text && !result.text.empty?
+        if result.tool_calls && !result.tool_calls.empty?
+          msg[:tool_calls] = result.tool_calls.map do |tc|
+            {
+              'id' => tc[:id],
+              'type' => 'function',
+              'function' => {
+                'name' => tc[:name],
+                'arguments' => JSON.generate(tc[:arguments] || {})
+              }
+            }
+          end
+        end
+        msg
+      end
+
+      def format_tool_result(tool_call_id, result_string)
+        {
+          role: 'tool',
+          tool_call_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, {
+          'Authorization' => "Bearer #{config.resolved_api_key}"
+        })
+
+        formatted = []
+        formatted << { role: 'system', content: system_prompt } if system_prompt
+        formatted.concat(format_messages(messages))
+
+        body = {
+          model: config.resolved_model,
+          max_tokens: config.max_tokens,
+          temperature: config.temperature,
+          messages: formatted
+        }
+        body[:tools] = tools.to_openai_format if tools
+
+        json_body = JSON.generate(body)
+        debug_request("#{API_URL}/v1/chat/completions", body)
+        response = conn.post('/v1/chat/completions', json_body)
+        debug_response(response.body)
+        data = parse_response(response)
+        usage = data['usage'] || {}
+
+        choice = (data['choices'] || []).first || {}
+        message = choice['message'] || {}
+        finish_reason = choice['finish_reason']
+
+        tool_calls = extract_tool_calls(message)
+        stop = finish_reason == 'tool_calls' ? :tool_use : :end_turn
+
+        ChatResult.new(
+          text: message['content'] || '',
+          input_tokens: usage['prompt_tokens'],
+          output_tokens: usage['completion_tokens'],
+          tool_calls: tool_calls,
+          stop_reason: stop
+        )
+      end
+
+      def format_messages(messages)
+        messages.map do |msg|
+          base = { role: msg[:role].to_s }
+          if msg[:content]
+            base[:content] = msg[:content].is_a?(Array) ? JSON.generate(msg[:content]) : msg[:content].to_s
+          end
+          base[:tool_calls] = msg[:tool_calls] if msg[:tool_calls]
+          base[:tool_call_id] = msg[:tool_call_id] if msg[:tool_call_id]
+          base
+        end
+      end
+
+      def extract_tool_calls(message)
+        calls = message['tool_calls']
+        return [] unless calls.is_a?(Array)
+
+        calls.map do |tc|
+          func = tc['function'] || {}
+          args = begin
+                   JSON.parse(func['arguments'] || '{}')
+                 rescue
+                   {}
+                 end
+          {
+            id: tc['id'],
+            name: func['name'],
+            arguments: args
+          }
+        end
+      end
+    end
+  end
+end

data/lib/console_agent/railtie.rb

@@ -0,0 +1,30 @@
+require 'console_agent'
+
+module ConsoleAgent
+  class Railtie < Rails::Railtie
+    console do
+      require 'console_agent/console_methods'
+
+      # Inject into IRB if available
+      if defined?(IRB::ExtendCommandBundle)
+        IRB::ExtendCommandBundle.include(ConsoleAgent::ConsoleMethods)
+      end
+
+      # Extend TOPLEVEL_BINDING's receiver as well
+      TOPLEVEL_BINDING.eval('self').extend(ConsoleAgent::ConsoleMethods)
+
+      # Welcome message
+      if $stdout.respond_to?(:tty?) && $stdout.tty?
+        $stdout.puts "\e[36m[ConsoleAgent] AI assistant loaded. Try: ai \"show me all tables\"\e[0m"
+      end
+
+      # Pre-build context in background
+      Thread.new do
+        require 'console_agent/context_builder'
+        ConsoleAgent::ContextBuilder.new.build
+      rescue => e
+        ConsoleAgent.logger.debug("ConsoleAgent: background context build failed: #{e.message}")
+      end
+    end
+  end
+end