console_agent 0.0.1 → 0.2.0

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

data/lib/console_agent/repl.rb

@@ -0,0 +1,342 @@
+require 'readline'
+
+module ConsoleAgent
+  class Repl
+    def initialize(binding_context)
+      @binding_context = binding_context
+      @executor = Executor.new(binding_context)
+      @provider = nil
+      @context_builder = nil
+      @context = nil
+      @history = []
+      @total_input_tokens = 0
+      @total_output_tokens = 0
+      @input_history = []
+    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)
+      end
+    rescue Providers::ProviderError => e
+      $stderr.puts "\e[31mConsoleAgent Error: #{e.message}\e[0m"
+      nil
+    rescue => e
+      $stderr.puts "\e[31mConsoleAgent Error: #{e.class}: #{e.message}\e[0m"
+      nil
+    end
+
+    def explain(query)
+      result = send_query(query)
+      track_usage(result)
+      @executor.display_response(result.text)
+      display_usage(result)
+      nil
+    rescue Providers::ProviderError => e
+      $stderr.puts "\e[31mConsoleAgent Error: #{e.message}\e[0m"
+      nil
+    rescue => e
+      $stderr.puts "\e[31mConsoleAgent Error: #{e.class}: #{e.message}\e[0m"
+      nil
+    end
+
+    def interactive
+      $stdout.puts "\e[36mConsoleAgent interactive mode. Type 'exit' or 'quit' to leave.\e[0m"
+      @history = []
+      @total_input_tokens = 0
+      @total_output_tokens = 0
+
+      loop do
+        input = Readline.readline("\e[33mai> \e[0m", false)
+        break if input.nil? # Ctrl-D
+
+        input = input.strip
+        break if input.downcase == 'exit' || input.downcase == 'quit'
+        next if input.empty?
+
+        # Add to Readline history (avoid consecutive duplicates)
+        Readline::HISTORY.push(input) unless input == Readline::HISTORY.to_a.last
+
+        @history << { role: :user, content: input }
+
+        begin
+          result = 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
+          next
+        end
+
+        track_usage(result)
+        code = @executor.display_response(result.text)
+        display_usage(result, show_session: true)
+
+        @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
+
+          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
+        end
+      end
+
+      display_session_summary
+      $stdout.puts "\e[36mLeft ConsoleAgent interactive mode.\e[0m"
+    rescue Interrupt
+      # Ctrl-C during Readline input — exit cleanly
+      $stdout.puts
+      display_session_summary
+      $stdout.puts "\e[36mLeft ConsoleAgent interactive mode.\e[0m"
+    rescue => e
+      $stderr.puts "\e[31mConsoleAgent Error: #{e.class}: #{e.message}\e[0m"
+    end
+
+    private
+
+    def provider
+      @provider ||= Providers.build
+    end
+
+    def context_builder
+      @context_builder ||= ContextBuilder.new
+    end
+
+    def context
+      @context ||= context_builder.build
+    end
+
+    def send_query(query, conversation: nil)
+      ConsoleAgent.configuration.validate!
+
+      messages = if conversation
+                   conversation.map { |m| { role: m[:role], content: m[:content] } }
+                 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
+    end
+
+    def send_query_with_tools(messages)
+      require 'console_agent/tools/registry'
+      tools = Tools::Registry.new
+      max_rounds = ConsoleAgent.configuration.max_tool_rounds
+      total_input = 0
+      total_output = 0
+      result = nil
+
+      exhausted = false
+
+      max_rounds.times do |round|
+        if round == 0
+          $stdout.puts "\e[2m  Thinking...\e[0m"
+        end
+
+        result = provider.chat_with_tools(messages, tools: tools, system_prompt: context)
+        total_input += result.input_tokens || 0
+        total_output += result.output_tokens || 0
+
+        break unless result.tool_use?
+
+        # Show what the LLM is thinking (if it returned text alongside tool calls)
+        if result.text && !result.text.strip.empty?
+          $stdout.puts "\e[2m  #{result.text.strip}\e[0m"
+        end
+
+        # Add assistant message with tool calls to conversation
+        messages << provider.format_assistant_message(result)
+
+        # 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'
+            tool_result = tools.execute(tc[:name], tc[:arguments])
+          else
+            args_display = format_tool_args(tc[:name], tc[:arguments])
+            $stdout.puts "\e[33m  -> #{tc[:name]}#{args_display}\e[0m"
+
+            tool_result = tools.execute(tc[:name], tc[:arguments])
+
+            preview = compact_tool_result(tc[:name], tool_result)
+            cached_tag = tools.last_cached? ? " (cached)" : ""
+            $stdout.puts "\e[2m     #{preview}#{cached_tag}\e[0m"
+          end
+
+          if ConsoleAgent.configuration.debug
+            $stderr.puts "\e[35m[debug tool result] #{tool_result}\e[0m"
+          end
+
+          messages << provider.format_tool_result(tc[:id], tool_result)
+        end
+
+        exhausted = true if round == max_rounds - 1
+      end
+
+      # If we hit the tool round limit, force a final response without tools
+      if exhausted
+        $stdout.puts "\e[33m  Hit tool round limit (#{max_rounds}). Forcing final answer. Increase with: ConsoleAgent.configure { |c| c.max_tool_rounds = 200 }\e[0m"
+        messages << { role: :user, content: "You've used all available tool rounds. Please provide your best answer now based on what you've learned so far." }
+        result = provider.chat(messages, system_prompt: context)
+        total_input += result.input_tokens || 0
+        total_output += result.output_tokens || 0
+      end
+
+      Providers::ChatResult.new(
+        text: result ? result.text : '',
+        input_tokens: total_input,
+        output_tokens: total_output,
+        stop_reason: result ? result.stop_reason : :end_turn
+      )
+    end
+
+    def format_tool_args(name, args)
+      return '' if args.nil? || args.empty?
+
+      case name
+      when 'describe_table'
+        "(\"#{args['table_name']}\")"
+      when 'describe_model'
+        "(\"#{args['model_name']}\")"
+      when 'read_file'
+        "(\"#{args['path']}\")"
+      when 'search_code'
+        dir = args['directory'] ? ", dir: \"#{args['directory']}\"" : ''
+        "(\"#{args['query']}\"#{dir})"
+      when 'list_files'
+        args['directory'] ? "(\"#{args['directory']}\")" : ''
+      when 'save_memory'
+        "(\"#{args['name']}\")"
+      when 'delete_memory'
+        "(\"#{args['name']}\")"
+      when 'recall_memories'
+        args['query'] ? "(\"#{args['query']}\")" : ''
+      else
+        ''
+      end
+    end
+
+    def compact_tool_result(name, result)
+      return '(empty)' if result.nil? || result.strip.empty?
+
+      case name
+      when 'list_tables'
+        tables = result.split(', ')
+        if tables.length > 8
+          "#{tables.length} tables: #{tables.first(8).join(', ')}..."
+        else
+          "#{tables.length} tables: #{result}"
+        end
+      when 'list_models'
+        lines = result.split("\n")
+        if lines.length > 6
+          "#{lines.length} models: #{lines.first(6).map { |l| l.split(' ').first }.join(', ')}..."
+        else
+          "#{lines.length} models"
+        end
+      when 'describe_table'
+        col_count = result.scan(/^\s{2}\S/).length
+        "#{col_count} columns"
+      when 'describe_model'
+        parts = []
+        assoc_count = result.scan(/^\s{2}(has_many|has_one|belongs_to|has_and_belongs_to_many)/).length
+        val_count = result.scan(/^\s{2}(presence|uniqueness|format|length|numericality|inclusion|exclusion|confirmation|acceptance)/).length
+        parts << "#{assoc_count} associations" if assoc_count > 0
+        parts << "#{val_count} validations" if val_count > 0
+        parts.empty? ? truncate(result, 80) : parts.join(', ')
+      when 'list_files'
+        lines = result.split("\n")
+        "#{lines.length} files"
+      when 'read_file'
+        lines = result.split("\n")
+        "#{lines.length} lines"
+      when 'search_code'
+        if result.start_with?('Found')
+          result.split("\n").first
+        elsif result.start_with?('No matches')
+          result
+        else
+          truncate(result, 80)
+        end
+      when 'save_memory'
+        (result.start_with?('Memory saved') || result.start_with?('Memory updated')) ? result : truncate(result, 80)
+      when 'delete_memory'
+        result.start_with?('Memory deleted') ? result : truncate(result, 80)
+      when 'recall_memories'
+        chunks = result.split("\n\n")
+        chunks.length > 1 ? "#{chunks.length} memories found" : truncate(result, 80)
+      else
+        truncate(result, 80)
+      end
+    end
+
+    def truncate(str, max)
+      str.length > max ? str[0..max] + '...' : str
+    end
+
+    def track_usage(result)
+      @total_input_tokens += result.input_tokens || 0
+      @total_output_tokens += result.output_tokens || 0
+    end
+
+    def display_usage(result, show_session: false)
+      input  = result.input_tokens
+      output = result.output_tokens
+      return unless input || output
+
+      parts = []
+      parts << "in: #{input}" if input
+      parts << "out: #{output}" if output
+      parts << "total: #{result.total_tokens}"
+
+      line = "\e[2m[tokens #{parts.join(' | ')}]\e[0m"
+
+      if show_session && (@total_input_tokens + @total_output_tokens) > result.total_tokens
+        line += "\e[2m [session: in: #{@total_input_tokens} | out: #{@total_output_tokens} | total: #{@total_input_tokens + @total_output_tokens}]\e[0m"
+      end
+
+      $stdout.puts line
+    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
+  end
+end

data/lib/console_agent/storage/base.rb

@@ -0,0 +1,27 @@
+module ConsoleAgent
+  module Storage
+    class StorageError < StandardError; end
+
+    class Base
+      def read(key)
+        raise NotImplementedError
+      end
+
+      def write(key, content)
+        raise NotImplementedError
+      end
+
+      def list(pattern)
+        raise NotImplementedError
+      end
+
+      def exists?(key)
+        raise NotImplementedError
+      end
+
+      def delete(key)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/console_agent/storage/file_storage.rb

@@ -0,0 +1,63 @@
+require 'fileutils'
+require 'console_agent/storage/base'
+
+module ConsoleAgent
+  module Storage
+    class FileStorage < Base
+      attr_reader :root_path
+
+      def initialize(root_path = nil)
+        @root_path = root_path || default_root
+      end
+
+      def read(key)
+        path = full_path(key)
+        return nil unless File.exist?(path)
+        File.read(path)
+      end
+
+      def write(key, content)
+        path = full_path(key)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, content)
+        true
+      rescue Errno::EACCES, Errno::EROFS, IOError => e
+        raise StorageError, "Cannot write #{key}: #{e.message}"
+      end
+
+      def list(pattern)
+        Dir.glob(File.join(@root_path, pattern)).sort.map do |path|
+          path.sub("#{@root_path}/", '')
+        end
+      end
+
+      def exists?(key)
+        File.exist?(full_path(key))
+      end
+
+      def delete(key)
+        path = full_path(key)
+        return false unless File.exist?(path)
+        File.delete(path)
+        true
+      rescue Errno::EACCES, Errno::EROFS, IOError => e
+        raise StorageError, "Cannot delete #{key}: #{e.message}"
+      end
+
+      private
+
+      def full_path(key)
+        sanitized = key.gsub('..', '').gsub(%r{\A/+}, '')
+        File.join(@root_path, sanitized)
+      end
+
+      def default_root
+        if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
+          File.join(Rails.root.to_s, '.console_agent')
+        else
+          File.join(Dir.pwd, '.console_agent')
+        end
+      end
+    end
+  end
+end

data/lib/console_agent/tools/code_tools.rb

@@ -0,0 +1,114 @@
+module ConsoleAgent
+  module Tools
+    class CodeTools
+      MAX_FILE_LINES = 200
+      MAX_LIST_ENTRIES = 100
+      MAX_SEARCH_RESULTS = 50
+
+      def list_files(directory = nil)
+        directory = sanitize_directory(directory || 'app')
+        root = rails_root
+        return "Rails.root is not available." unless root
+
+        full_path = File.join(root, directory)
+        return "Directory '#{directory}' not found." unless File.directory?(full_path)
+
+        files = Dir.glob(File.join(full_path, '**', '*.rb')).sort
+        files = files.map { |f| f.sub("#{root}/", '') }
+
+        if files.length > MAX_LIST_ENTRIES
+          truncated = files.first(MAX_LIST_ENTRIES)
+          truncated.join("\n") + "\n... and #{files.length - MAX_LIST_ENTRIES} more files"
+        elsif files.empty?
+          "No Ruby files found in '#{directory}'."
+        else
+          files.join("\n")
+        end
+      rescue => e
+        "Error listing files: #{e.message}"
+      end
+
+      def read_file(path)
+        return "Error: path is required." if path.nil? || path.strip.empty?
+
+        root = rails_root
+        return "Rails.root is not available." unless root
+
+        path = sanitize_path(path)
+        full_path = File.expand_path(File.join(root, path))
+
+        # Security: ensure resolved path is under Rails.root
+        unless full_path.start_with?(File.expand_path(root))
+          return "Error: path must be within the Rails application."
+        end
+
+        return "File '#{path}' not found." unless File.exist?(full_path)
+        return "Error: '#{path}' is a directory, not a file." if File.directory?(full_path)
+
+        lines = File.readlines(full_path)
+        if lines.length > MAX_FILE_LINES
+          numbered = lines.first(MAX_FILE_LINES).each_with_index.map { |line, i| "#{i + 1}: #{line}" }
+          numbered.join + "\n... truncated (#{lines.length} total lines, showing first #{MAX_FILE_LINES})"
+        else
+          lines.each_with_index.map { |line, i| "#{i + 1}: #{line}" }.join
+        end
+      rescue => e
+        "Error reading file '#{path}': #{e.message}"
+      end
+
+      def search_code(query, directory = nil)
+        return "Error: query is required." if query.nil? || query.strip.empty?
+
+        directory = sanitize_directory(directory || 'app')
+        root = rails_root
+        return "Rails.root is not available." unless root
+
+        full_path = File.join(root, directory)
+        return "Directory '#{directory}' not found." unless File.directory?(full_path)
+
+        results = []
+        Dir.glob(File.join(full_path, '**', '*.rb')).sort.each do |file|
+          break if results.length >= MAX_SEARCH_RESULTS
+
+          relative = file.sub("#{root}/", '')
+          File.readlines(file).each_with_index do |line, idx|
+            if line.include?(query)
+              results << "#{relative}:#{idx + 1}: #{line.strip}"
+              break if results.length >= MAX_SEARCH_RESULTS
+            end
+          end
+        rescue => e
+          # skip unreadable files
+        end
+
+        if results.empty?
+          "No matches found for '#{query}' in #{directory}/."
+        else
+          header = "Found #{results.length} match#{'es' if results.length != 1}:\n"
+          header + results.join("\n")
+        end
+      rescue => e
+        "Error searching: #{e.message}"
+      end
+
+      private
+
+      def rails_root
+        if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
+          Rails.root.to_s
+        else
+          nil
+        end
+      end
+
+      def sanitize_path(path)
+        # Remove leading slashes and ../ sequences
+        path.strip.gsub(/\A\/+/, '').gsub(/\.\.\//, '').gsub(/\.\.\\/, '')
+      end
+
+      def sanitize_directory(dir)
+        sanitize_path(dir || 'app')
+      end
+    end
+  end
+end