aicli 0.1.1 → 0.2.6

data/lib/aicli/helpers/completion.rb

@@ -1,219 +1,100 @@
 # frozen_string_literal: true
 
-require 'json'
-require 'net/http'
-require 'uri'
-require 'thread'
-
 module AiCli
   module Helpers
     module Completion
       EXPLAIN_IN_SECOND_REQUEST = true
-      SHELL_CODE_EXCLUSIONS = [/```[a-zA-Z]*\n/i, /```[a-zA-Z]*/i, "\n"].freeze
+      SHELL_CODE_EXCLUSIONS = [/```[a-zA-Z]*\n?/i, /```[a-zA-Z]*/i, "\n"].freeze
 
       module_function
 
-      def get_script_and_info(prompt:, key:, api_endpoint:, model: nil)
-        stream = generate_completion(
-          prompt: full_prompt(prompt),
-          key: key,
-          model: model,
-          api_endpoint: api_endpoint
-        )
-        enumerator = stream.each
-
+      def get_script_and_info(prompt:, config:)
         {
-          read_script: read_data(enumerator, *SHELL_CODE_EXCLUSIONS),
-          read_info: read_data(enumerator, *SHELL_CODE_EXCLUSIONS)
+          read_script: stream_prompt(full_prompt(prompt), config: config, exclusions: SHELL_CODE_EXCLUSIONS),
+          read_info: ->(_writer) { '' }
         }
       end
 
-      def get_explanation(script:, key:, api_endpoint:, model: nil)
-        stream = generate_completion(
-          prompt: explanation_prompt(script),
-          key: key,
-          model: model,
-          api_endpoint: api_endpoint
-        )
-        { read_explanation: read_data(stream.each) }
+      def get_explanation(script:, config:)
+        { read_explanation: stream_prompt(explanation_prompt(script), config: config) }
       end
 
-      def get_revision(prompt:, code:, key:, api_endpoint:, model: nil)
-        stream = generate_completion(
-          prompt: revision_prompt(prompt, code),
-          key: key,
-          model: model,
-          api_endpoint: api_endpoint
-        )
-        { read_script: read_data(stream.each, *SHELL_CODE_EXCLUSIONS) }
+      def get_revision(prompt:, code:, config:)
+        {
+          read_script: stream_prompt(
+            revision_prompt(prompt, code),
+            config: config,
+            exclusions: SHELL_CODE_EXCLUSIONS
+          )
+        }
       end
 
-      def get_models(key, api_endpoint)
-        uri = URI.join(ensure_trailing_slash(api_endpoint), 'models')
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = uri.scheme == 'https'
-
-        request = Net::HTTP::Get.new(uri)
-        request['Authorization'] = "Bearer #{key}"
-        request['Content-Type'] = 'application/json'
-
-        response = http.request(request)
-        raise KnownError, "Failed to list models: #{response.code}" unless response.is_a?(Net::HTTPSuccess)
-
-        data = JSON.parse(response.body)
-        data.fetch('data', []).select { |m| m['object'] == 'model' }
+      def get_models(provider)
+        Llm.list_chat_models(provider)
       end
 
-      # Returns a live Enumerator of SSE "data: ..." lines
-      def generate_completion(prompt:, key:, api_endpoint:, model: nil, number: 1)
-        messages = if prompt.is_a?(Array)
-                     prompt
-                   else
-                     [{ 'role' => 'user', 'content' => prompt }]
-                   end
-
-        uri = URI.join(ensure_trailing_slash(api_endpoint), 'chat/completions')
-        body = {
-          model: model || 'gpt-4o-mini',
-          messages: messages,
-          n: [number, 10].min,
-          stream: true
-        }
-
-        queue = Queue.new
-        error_box = []
-
-        Thread.new do
-          http = Net::HTTP.new(uri.host, uri.port)
-          http.use_ssl = uri.scheme == 'https'
-          http.read_timeout = 120
-
-          request = Net::HTTP::Post.new(uri)
-          request['Authorization'] = "Bearer #{key}"
-          request['Content-Type'] = 'application/json'
-          request['Accept'] = 'text/event-stream'
-          request.body = JSON.generate(body)
-
-          http.request(request) do |response|
-            unless response.is_a?(Net::HTTPSuccess)
-              error_box << [:api, response.code.to_i, response.body]
-              queue << :done
-              next
-            end
-
-            buffer = +''
-            response.read_body do |chunk|
-              buffer << chunk
-              while (eol = buffer.index("\n"))
-                line = buffer.slice!(0..eol).strip
-                queue << line if line.start_with?('data: ')
-              end
-            end
-          end
-          queue << :done
-        rescue SocketError, Errno::ECONNREFUSED, Errno::EHOSTUNREACH => e
-          error_box << [:network, uri.host, e.message]
-          queue << :done
-        rescue StandardError => e
-          error_box << [:other, e]
-          queue << :done
-        end
-
-        Enumerator.new do |yielder|
-          loop do
-            item = queue.pop
-            break if item == :done
-
-            yielder << item
-          end
-
-          if (err = error_box.first)
-            case err[0]
-            when :api
-              handle_api_error(err[1], err[2])
-            when :network
-              raise KnownError,
-                    "Error connecting to #{err[1]}. Are you connected to the internet? (#{err[2]})"
-            when :other
-              raise err[1]
-            end
-          end
+      # Streams a single-turn completion. Returns a callable that takes a writer.
+      def stream_prompt(prompt, config:, exclusions: [])
+        lambda do |writer|
+          stream_to_writer(prompt, config: config, exclusions: exclusions, writer: writer)
         end
       end
 
-      def read_data(enumerator, *excluded)
-        lambda do |writer|
-          data = +''
-          data_start = false
-          buffer = +''
-          excluded_prefix = excluded.first
-
-          loop do
-            chunk = enumerator.next
-            payloads = chunk.to_s.split("\n\n")
-
-            payloads.each do |payload|
-              return data if payload.include?('[DONE]')
+      # Multi-turn chat helper used by `aicli chat`.
+      def start_chat(config)
+        chat = Llm.build_chat(config)
+        chat.with_instructions(chat_system_prompt)
+        chat
+      end
 
-              next unless payload.start_with?('data:')
+      def chat_system_prompt
+        <<~PROMPT
+          You are aicli, a terminal assistant. The user is asking for shell commands.
 
-              content = parse_content(payload)
+          Target OS: #{OsDetect.operating_system_name}
+          Target shell: #{OsDetect.detect_shell}
 
-              unless data_start
-                buffer << content
-                if excluded_prefix.nil? || buffer.match?(excluded_prefix)
-                  data_start = true
-                  buffer = +''
-                  break if excluded_prefix
-                end
-              end
+          Whenever you suggest a command the user can run, put the exact runnable command
+          alone inside a markdown fenced code block, for example:
 
-              next unless data_start && !content.empty?
+          ```
+          ls -la
+          ```
 
-              cleaned = StripRegexPatterns.call(content, excluded)
-              data << cleaned
-              writer.call(cleaned)
-            end
-          rescue StopIteration
-            break
-          end
-
-          data
-        end
+          Prefer a single command. You may briefly explain outside the fence.
+          Do not wrap non-runnable prose in fences.
+        PROMPT
       end
 
-      def parse_content(payload)
-        raw = payload.sub(/^data:\s*/, '')
-        delta = JSON.parse(raw.strip)
-        delta.dig('choices', 0, 'delta', 'content') || ''
-      rescue JSON::ParserError => e
-        "Error with JSON.parse and #{payload}.\n#{e}"
-      end
+      def extract_commands(text)
+        return [] if text.nil? || text.empty?
 
-      def handle_api_error(status, body)
-        message_string = begin
-          JSON.pretty_generate(JSON.parse(body))
-        rescue StandardError
-          body.to_s
-        end
+        blocks = text.scan(/```(?:[a-zA-Z0-9_+-]*)\s*\n?(.*?)```/m)
+                     .flatten
+                     .map { |block| block.strip.gsub(/\A`+|`+\z/, '') }
+                     .map(&:strip)
+                     .reject(&:empty?)
 
-        if status == 429
-          raise KnownError, <<~MSG
-            Request to OpenAI failed with status 429. This is due to incorrect billing setup or excessive quota usage. Please follow this guide to fix it: https://help.openai.com/en/articles/6891831-error-code-429-you-exceeded-your-current-quota-please-check-your-plan-and-billing-details
+        # Prefer the last fenced command if several were suggested.
+        blocks
+      end
 
-            You can activate billing here: https://platform.openai.com/account/billing/overview . Make sure to add a payment method if not under an active grant from OpenAI.
+      def stream_chat_message(chat, message, writer:)
+        data = +''
 
-            Full message from OpenAI:
+        begin
+          chat.ask(message) do |chunk|
+            content = chunk.content.to_s
+            next if content.empty?
 
-            #{message_string}
-          MSG
+            data << content
+            writer.call(content)
+          end
+        rescue RubyLLM::Error, RubyLLM::ConfigurationError => e
+          handle_ruby_llm_error(e)
         end
 
-        raise KnownError, <<~MSG
-          Request to OpenAI failed with status #{status}:
-
-          #{message_string}
-        MSG
+        data
       end
 
       def explanation_prompt(script)
@@ -267,9 +148,84 @@ module AiCli
         PROMPT
       end
 
-      def ensure_trailing_slash(endpoint)
-        endpoint.end_with?('/') ? endpoint : "#{endpoint}/"
+      def stream_to_writer(prompt, config:, exclusions:, writer:)
+        chat = Llm.build_chat(config)
+        data = +''
+        data_start = exclusions.empty?
+        buffer = +''
+        excluded_prefix = exclusions.first
+
+        begin
+          chat.ask(prompt) do |chunk|
+            content = chunk.content.to_s
+            next if content.empty?
+
+            unless data_start
+              buffer << content
+              next unless excluded_prefix.nil? || buffer.match?(excluded_prefix)
+
+              data_start = true
+              remainder = StripRegexPatterns.call(buffer, exclusions)
+              buffer = +''
+              next if remainder.empty?
+
+              data << remainder
+              writer.call(remainder)
+              next
+            end
+
+            cleaned = StripRegexPatterns.call(content, exclusions)
+            next if cleaned.empty?
+
+            data << cleaned
+            writer.call(cleaned)
+          end
+        rescue RubyLLM::Error, RubyLLM::ConfigurationError => e
+          handle_ruby_llm_error(e)
+        end
+
+        data
+      end
+
+      def handle_ruby_llm_error(error)
+        message = error.message.to_s
+
+        if error.is_a?(RubyLLM::RateLimitError) || error.is_a?(RubyLLM::PaymentRequiredError) ||
+           message.match?(/rate.?limit|quota|billing/i)
+          raise KnownError, <<~MSG
+            Request to the LLM provider failed (rate limit / quota).
+
+            Check your plan and billing details for the configured provider, then try again.
+
+            Full message:
+
+            #{message}
+          MSG
+        end
+
+        if message.match?(/model_not_found|does not exist|do not have access/i)
+          raise KnownError, <<~MSG
+            The configured model is not available for this API key/provider.
+
+            Fix with:
+              #{Constants::COMMAND_NAME} config
+            or:
+              #{Constants::COMMAND_NAME} config set MODEL=#{Llm.default_model_for('anthropic')}
+              #{Constants::COMMAND_NAME} config set PROVIDER=anthropic
+
+            Full message:
+
+            #{message}
+          MSG
+        end
+
+        raise KnownError, <<~MSG
+          Request to the LLM provider failed:
+
+          #{message}
+        MSG
       end
+      private_class_method :stream_to_writer, :handle_ruby_llm_error
     end
   end
 end

data/lib/aicli/helpers/config.rb

@@ -7,19 +7,23 @@ require 'tty-prompt'
 module AiCli
   module Helpers
     module Config
-      CONFIG_PATH = File.join(Dir.home, '.aicli')
+      HOME_DIR = File.join(Dir.home, '.aicli')
+      CONFIG_PATH = File.join(HOME_DIR, 'config')
+      LEGACY_FLAT_CONFIG_PATH = File.join(Dir.home, '.aicli')
       LEGACY_CONFIG_PATH = File.join(Dir.home, '.ai-shell')
 
       CONFIG_PARSERS = {
+        'PROVIDER' => lambda { |provider|
+          Llm.normalize_provider(provider)
+        },
         'OPENAI_KEY' => lambda { |key|
-          if key.nil? || key.empty?
-            raise KnownError,
-                  "Please set your OpenAI API key via `#{Constants::COMMAND_NAME} config set OPENAI_KEY=<your token>`"
-          end
-          key
+          key.to_s
+        },
+        'ANTHROPIC_KEY' => lambda { |key|
+          key.to_s
         },
         'MODEL' => lambda { |model|
-          model.nil? || model.empty? ? 'gpt-4o-mini' : model
+          model.to_s
         },
         'SILENT_MODE' => lambda { |mode|
           mode.to_s.downcase == 'true'
@@ -34,6 +38,32 @@ module AiCli
 
       module_function
 
+      def home_dir
+        ensure_home!
+        HOME_DIR
+      end
+
+      def ensure_home!
+        if File.file?(LEGACY_FLAT_CONFIG_PATH) && !File.directory?(LEGACY_FLAT_CONFIG_PATH)
+          migrate_flat_config!
+        else
+          FileUtils.mkdir_p(HOME_DIR)
+        end
+        HOME_DIR
+      end
+
+      def migrate_flat_config!
+        backup = "#{LEGACY_FLAT_CONFIG_PATH}.migrating.#{Process.pid}"
+        File.rename(LEGACY_FLAT_CONFIG_PATH, backup)
+        FileUtils.mkdir_p(HOME_DIR)
+        FileUtils.mv(backup, CONFIG_PATH)
+      rescue StandardError
+        FileUtils.mkdir_p(HOME_DIR)
+        if File.exist?(backup)
+          FileUtils.mv(backup, CONFIG_PATH) unless File.exist?(CONFIG_PATH)
+        end
+      end
+
       def get(cli_config = nil)
         config = read_config_file
         parsed = {}
@@ -43,21 +73,49 @@ module AiCli
           parsed[key] = parser.call(value)
         end
 
+        raw_model = cli_config&.dig('MODEL') || config['MODEL']
+        if raw_model.nil? || raw_model.to_s.empty?
+          parsed['MODEL'] = Llm.default_model_for(parsed['PROVIDER'])
+        end
+
+        provider, model = Llm.resolve_provider_and_model(parsed)
+        parsed['PROVIDER'] = provider
+        parsed['MODEL'] = model
         parsed
       end
 
       def set(key_values)
         config = read_config_file
+        updates = {}
 
         key_values.each do |key, value|
           unless CONFIG_PARSERS.key?(key)
             raise KnownError, "#{I18n.t('Invalid config property')}: #{key}"
           end
 
-          parsed = CONFIG_PARSERS[key].call(value)
-          config[key] = parsed.to_s
+          updates[key] = CONFIG_PARSERS[key].call(value).to_s
+        end
+
+        # Keep PROVIDER and MODEL aligned with the RubyLLM registry.
+        if updates.key?('MODEL') && !updates['MODEL'].empty?
+          model_provider = Llm.provider_for_model(updates['MODEL'])
+          if model_provider
+            updates['PROVIDER'] = model_provider unless updates.key?('PROVIDER')
+          end
+        end
+
+        if updates.key?('PROVIDER')
+          provider = Llm.normalize_provider(updates['PROVIDER'])
+          updates['PROVIDER'] = provider
+          next_model = updates['MODEL'] || config['MODEL']
+          known_ids = Completion.get_models(provider).map { |m| m['id'] }
+          if next_model.to_s.empty? || !known_ids.include?(next_model)
+            updates['MODEL'] = Llm.default_model_for(provider) unless updates.key?('MODEL') && known_ids.include?(updates['MODEL'])
+          end
         end
 
+        updates.each { |key, value| config[key] = value }
+        ensure_home!
         File.write(CONFIG_PATH, stringify_ini(config))
       end
 
@@ -72,8 +130,12 @@ module AiCli
         loop do
           config = get
           choice = prompt.select("#{I18n.t('Set config')}:") do |menu|
+            menu.choice "#{I18n.t('Provider')} (#{display_hint(config, 'PROVIDER')})",
+                        'PROVIDER'
             menu.choice "#{I18n.t('OpenAI Key')} (#{display_hint(config, 'OPENAI_KEY') { |v| "sk-...#{v[-3..]}" }})",
                         'OPENAI_KEY'
+            menu.choice "#{I18n.t('Anthropic Key')} (#{display_hint(config, 'ANTHROPIC_KEY') { |v| "...#{v[-3..]}" }})",
+                        'ANTHROPIC_KEY'
             menu.choice "#{I18n.t('OpenAI API Endpoint')} (#{display_hint(config, 'OPENAI_API_ENDPOINT')})",
                         'OPENAI_API_ENDPOINT'
             menu.choice "#{I18n.t('Silent Mode')} (#{display_hint(config, 'SILENT_MODE')})",
@@ -86,11 +148,27 @@ module AiCli
           end
 
           case choice
+          when 'PROVIDER'
+            provider = prompt.select(I18n.t('Pick a provider')) do |menu|
+              Llm::PROVIDERS.each { |p| menu.choice p, p }
+            end
+            updates = [['PROVIDER', provider]]
+            current_model = get['MODEL']
+            known_ids = Completion.get_models(provider).map { |m| m['id'] }
+            unless known_ids.include?(current_model)
+              updates << ['MODEL', Llm.default_model_for(provider)]
+            end
+            set(updates)
           when 'OPENAI_KEY'
             key = prompt.ask(I18n.t('Enter your OpenAI API key')) do |q|
               q.required true
             end
             set([['OPENAI_KEY', key]])
+          when 'ANTHROPIC_KEY'
+            key = prompt.ask(I18n.t('Enter your Anthropic API key')) do |q|
+              q.required true
+            end
+            set([['ANTHROPIC_KEY', key]])
           when 'OPENAI_API_ENDPOINT'
             api_endpoint = prompt.ask(I18n.t('Enter your OpenAI API Endpoint'))
             set([['OPENAI_API_ENDPOINT', api_endpoint]]) if api_endpoint
@@ -99,9 +177,17 @@ module AiCli
             set([['SILENT_MODE', silent ? 'true' : 'false']])
           when 'MODEL'
             cfg = get
-            models = Completion.get_models(cfg['OPENAI_KEY'], cfg['OPENAI_API_ENDPOINT'])
-            model = prompt.select('Pick a model.') do |menu|
-              models.each { |m| menu.choice m['id'], m['id'] }
+            models = Completion.get_models(cfg['PROVIDER'])
+            if models.empty?
+              puts pastel.yellow(I18n.t('No models found for this provider.'))
+              next
+            end
+            model = prompt.select(I18n.t('Pick a model.')) do |menu|
+              menu.default cfg['MODEL'] if models.any? { |m| m['id'] == cfg['MODEL'] }
+              models.each do |m|
+                label = m['name'].empty? || m['name'] == m['id'] ? m['id'] : "#{m['name']} (#{m['id']})"
+                menu.choice label, m['id']
+              end
             end
             set([['MODEL', model]])
           when 'LANGUAGE'
@@ -121,9 +207,11 @@ module AiCli
       end
 
       def read_config_file
-        path = if File.exist?(CONFIG_PATH)
+        ensure_home!
+
+        path = if File.file?(CONFIG_PATH)
                  CONFIG_PATH
-               elsif File.exist?(LEGACY_CONFIG_PATH)
+               elsif File.file?(LEGACY_CONFIG_PATH)
                  LEGACY_CONFIG_PATH
                end
         return {} unless path
@@ -149,7 +237,7 @@ module AiCli
       end
 
       def display_hint(config, key)
-        if config.key?(key) && !config[key].nil?
+        if config.key?(key) && !config[key].nil? && !(config[key].respond_to?(:empty?) && config[key].empty?)
           value = config[key]
           block_given? ? yield(value) : value.to_s
         else

data/lib/aicli/helpers/context.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+require 'time'
+
+module AiCli
+  module Helpers
+    module Context
+      # Keep the last N user/assistant messages across sessions.
+      MAX_MESSAGES = 40
+      CONTEXT_FILENAME = 'context'
+
+      module_function
+
+      def path
+        File.join(Config.home_dir, CONTEXT_FILENAME)
+      end
+
+      def load_messages
+        Config.ensure_home!
+        return [] unless File.file?(path)
+
+        data = JSON.parse(File.read(path))
+        Array(data['messages'])
+          .select { |m| m.is_a?(Hash) && %w[user assistant].include?(m['role'].to_s) }
+          .map { |m| { 'role' => m['role'].to_s, 'content' => m['content'].to_s } }
+          .reject { |m| m['content'].strip.empty? }
+          .last(MAX_MESSAGES)
+      rescue StandardError
+        []
+      end
+
+      def save_messages(messages)
+        Config.ensure_home!
+        normalized = Array(messages)
+                     .map { |m| normalize_message(m) }
+                     .compact
+                     .last(MAX_MESSAGES)
+
+        payload = {
+          'version' => 1,
+          'updated_at' => Time.now.utc.iso8601,
+          'messages' => normalized
+        }
+        File.write(path, "#{JSON.pretty_generate(payload)}\n")
+      rescue StandardError
+        # Ignore persistence failures; chat should still work.
+      end
+
+      def save_from_chat(chat)
+        save_messages(chat.messages)
+      end
+
+      def apply_to_chat(chat)
+        load_messages.each do |message|
+          chat.add_message(role: message['role'].to_sym, content: message['content'])
+        end
+      end
+
+      def user_prompts
+        load_messages.select { |m| m['role'] == 'user' }.map { |m| m['content'] }
+      end
+
+      def seed_prompt_history(prompt)
+        return unless prompt.respond_to?(:reader)
+
+        user_prompts.each do |line|
+          prompt.reader.add_to_history(line)
+        end
+      rescue StandardError
+        nil
+      end
+
+      def normalize_message(message)
+        if message.respond_to?(:role) && message.respond_to?(:content)
+          role = message.role.to_s
+          content = message.content.to_s
+        elsif message.is_a?(Hash)
+          role = (message[:role] || message['role']).to_s
+          content = (message[:content] || message['content']).to_s
+        else
+          return nil
+        end
+
+        return nil unless %w[user assistant].include?(role)
+        return nil if content.strip.empty?
+
+        { 'role' => role, 'content' => content }
+      end
+      private_class_method :normalize_message
+    end
+  end
+end