aicli 0.1.1

data/lib/aicli/helpers/completion.rb

@@ -0,0 +1,275 @@
+# 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
+
+      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
+
+        {
+          read_script: read_data(enumerator, *SHELL_CODE_EXCLUSIONS),
+          read_info: read_data(enumerator, *SHELL_CODE_EXCLUSIONS)
+        }
+      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) }
+      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) }
+      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' }
+      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
+        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]')
+
+              next unless payload.start_with?('data:')
+
+              content = parse_content(payload)
+
+              unless data_start
+                buffer << content
+                if excluded_prefix.nil? || buffer.match?(excluded_prefix)
+                  data_start = true
+                  buffer = +''
+                  break if excluded_prefix
+                end
+              end
+
+              next unless data_start && !content.empty?
+
+              cleaned = StripRegexPatterns.call(content, excluded)
+              data << cleaned
+              writer.call(cleaned)
+            end
+          rescue StopIteration
+            break
+          end
+
+          data
+        end
+      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 handle_api_error(status, body)
+        message_string = begin
+          JSON.pretty_generate(JSON.parse(body))
+        rescue StandardError
+          body.to_s
+        end
+
+        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
+
+            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.
+
+            Full message from OpenAI:
+
+            #{message_string}
+          MSG
+        end
+
+        raise KnownError, <<~MSG
+          Request to OpenAI failed with status #{status}:
+
+          #{message_string}
+        MSG
+      end
+
+      def explanation_prompt(script)
+        <<~PROMPT
+          #{explain_script} Please reply in #{I18n.current_language_name}
+
+          The script: #{script}
+        PROMPT
+      end
+
+      def shell_details
+        "The target shell is #{OsDetect.detect_shell}"
+      end
+
+      def explain_script
+        'Please provide a clear, concise description of the script, using minimal words. Outline the steps in a list format.'
+      end
+
+      def generation_details
+        <<~DETAILS.chomp
+          Only reply with the single line command surrounded by three backticks. It must be able to be directly run in the target shell. Do not include any other text.
+
+          Make sure the command runs on #{OsDetect.operating_system_name} operating system.
+        DETAILS
+      end
+
+      def full_prompt(prompt)
+        explain = EXPLAIN_IN_SECOND_REQUEST ? '' : explain_script
+        <<~PROMPT
+          Create a single line command that one can enter in a terminal and run, based on what is specified in the prompt.
+
+          #{shell_details}
+
+          #{generation_details}
+
+          #{explain}
+
+          The prompt is: #{prompt}
+        PROMPT
+      end
+
+      def revision_prompt(prompt, code)
+        <<~PROMPT
+          Update the following script based on what is asked in the following prompt.
+
+          The script: #{code}
+
+          The prompt: #{prompt}
+
+          #{generation_details}
+        PROMPT
+      end
+
+      def ensure_trailing_slash(endpoint)
+        endpoint.end_with?('/') ? endpoint : "#{endpoint}/"
+      end
+    end
+  end
+end

data/lib/aicli/helpers/config.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'pastel'
+require 'tty-prompt'
+
+module AiCli
+  module Helpers
+    module Config
+      CONFIG_PATH = File.join(Dir.home, '.aicli')
+      LEGACY_CONFIG_PATH = File.join(Dir.home, '.ai-shell')
+
+      CONFIG_PARSERS = {
+        '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
+        },
+        'MODEL' => lambda { |model|
+          model.nil? || model.empty? ? 'gpt-4o-mini' : model
+        },
+        'SILENT_MODE' => lambda { |mode|
+          mode.to_s.downcase == 'true'
+        },
+        'OPENAI_API_ENDPOINT' => lambda { |api_endpoint|
+          api_endpoint.nil? || api_endpoint.empty? ? 'https://api.openai.com/v1' : api_endpoint
+        },
+        'LANGUAGE' => lambda { |language|
+          language.nil? || language.empty? ? 'en' : language
+        }
+      }.freeze
+
+      module_function
+
+      def get(cli_config = nil)
+        config = read_config_file
+        parsed = {}
+
+        CONFIG_PARSERS.each do |key, parser|
+          value = cli_config&.dig(key) || config[key]
+          parsed[key] = parser.call(value)
+        end
+
+        parsed
+      end
+
+      def set(key_values)
+        config = read_config_file
+
+        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
+        end
+
+        File.write(CONFIG_PATH, stringify_ini(config))
+      end
+
+      def has_own?(object, key)
+        object.key?(key)
+      end
+
+      def show_config_ui
+        pastel = Pastel.new
+        prompt = TTY::Prompt.new(interrupt: :exit)
+
+        loop do
+          config = get
+          choice = prompt.select("#{I18n.t('Set config')}:") do |menu|
+            menu.choice "#{I18n.t('OpenAI Key')} (#{display_hint(config, 'OPENAI_KEY') { |v| "sk-...#{v[-3..]}" }})",
+                        'OPENAI_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')})",
+                        'SILENT_MODE'
+            menu.choice "#{I18n.t('Model')} (#{display_hint(config, 'MODEL')})",
+                        'MODEL'
+            menu.choice "#{I18n.t('Language')} (#{display_hint(config, 'LANGUAGE')})",
+                        'LANGUAGE'
+            menu.choice I18n.t('Cancel'), 'cancel'
+          end
+
+          case choice
+          when 'OPENAI_KEY'
+            key = prompt.ask(I18n.t('Enter your OpenAI API key')) do |q|
+              q.required true
+            end
+            set([['OPENAI_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
+          when 'SILENT_MODE'
+            silent = prompt.yes?(I18n.t('Enable silent mode?'))
+            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'] }
+            end
+            set([['MODEL', model]])
+          when 'LANGUAGE'
+            language = prompt.select(I18n.t('Enter the language you want to use')) do |menu|
+              I18n.languages.each { |k, v| menu.choice v, k }
+            end
+            set([['LANGUAGE', language]])
+            I18n.set_language(language)
+          when 'cancel'
+            break
+          end
+        end
+      rescue KnownError, StandardError => e
+        puts "\n#{pastel.red('✖')} #{e.message}"
+        Error.handle_cli_error(e)
+        exit 1
+      end
+
+      def read_config_file
+        path = if File.exist?(CONFIG_PATH)
+                 CONFIG_PATH
+               elsif File.exist?(LEGACY_CONFIG_PATH)
+                 LEGACY_CONFIG_PATH
+               end
+        return {} unless path
+
+        parse_ini(File.read(path))
+      end
+
+      def parse_ini(content)
+        result = {}
+        content.each_line do |line|
+          line = line.strip
+          next if line.empty? || line.start_with?('#', ';')
+          next unless line.include?('=')
+
+          key, value = line.split('=', 2)
+          result[key.strip] = value.strip.gsub(/\A["']|["']\z/, '')
+        end
+        result
+      end
+
+      def stringify_ini(config)
+        "#{config.map { |k, v| "#{k}=#{v}" }.join("\n")}\n"
+      end
+
+      def display_hint(config, key)
+        if config.key?(key) && !config[key].nil?
+          value = config[key]
+          block_given? ? yield(value) : value.to_s
+        else
+          I18n.t('(not set)')
+        end
+      end
+    end
+  end
+end

data/lib/aicli/helpers/constants.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module AiCli
+  module Helpers
+    module Constants
+      COMMAND_NAME = 'aicli'
+      PROJECT_NAME = 'aicli'
+      REPO_URL = 'https://github.com/magnum/aicli'
+    end
+  end
+end

data/lib/aicli/helpers/error.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'pastel'
+
+module AiCli
+  module Helpers
+    class KnownError < StandardError; end
+
+    module Error
+      module_function
+
+      def handle_cli_error(error)
+        return if error.is_a?(KnownError)
+
+        pastel = Pastel.new
+        indent = ' ' * 4
+
+        if error.is_a?(StandardError) && error.backtrace
+          puts pastel.dim(error.backtrace.join("\n"))
+        end
+
+        puts "\n#{indent}#{pastel.dim("aicli v#{AiCli::VERSION}")}"
+        puts "\n#{indent}#{I18n.t('Please open a Bug report with the information above')}:"
+        puts "#{indent}https://github.com/magnum/aicli/issues/new"
+      end
+    end
+  end
+end

data/lib/aicli/helpers/i18n.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module AiCli
+  module Helpers
+    module I18n
+      LANGUAGES = {
+        'en' => 'English',
+        'zh-Hans' => '简体中文',
+        'zh-Hant' => '繁體中文',
+        'es' => 'Español',
+        'jp' => '日本語',
+        'ko' => '한국어',
+        'fr' => 'Français',
+        'de' => 'Deutsch',
+        'ru' => 'Русский',
+        'uk' => 'Українська',
+        'vi' => 'Tiếng Việt',
+        'ar' => 'العربية',
+        'pt' => 'Português',
+        'id' => 'Indonesia',
+        'it' => 'Italiano',
+        'tr' => 'Türkçe'
+      }.freeze
+
+      class << self
+        attr_reader :current_lang
+
+        def set_language(lang)
+          @current_lang = lang.nil? || lang.empty? ? 'en' : lang
+          load_translations
+        end
+
+        def t(key)
+          return key if @current_lang.nil? || @current_lang == 'en'
+
+          @translations[key] || key
+        end
+
+        def current_language_name
+          LANGUAGES[@current_lang] || LANGUAGES['en']
+        end
+
+        def languages
+          LANGUAGES
+        end
+
+        private
+
+        def load_translations
+          return if @current_lang == 'en'
+
+          locale_path = File.expand_path(
+            "../../../locales/#{@current_lang}.yml",
+            __dir__
+          )
+
+          @translations = if File.exist?(locale_path)
+                            YAML.safe_load(File.read(locale_path), permitted_classes: [String]) || {}
+                          else
+                            {}
+                          end
+        end
+      end
+
+      set_language('en')
+    end
+  end
+end

data/lib/aicli/helpers/os_detect.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'etc'
+require 'rbconfig'
+
+module AiCli
+  module Helpers
+    module OsDetect
+      module_function
+
+      def detect_shell
+        return 'powershell' if RUBY_PLATFORM.match?(/mswin|mingw|cygwin/i)
+
+        shell = ENV['SHELL'] || Etc.getpwuid.shell || 'bash'
+        File.basename(shell)
+      rescue StandardError => e
+        raise "#{I18n.t('Shell detection failed unexpectedly')}: #{e.message}"
+      end
+
+      def operating_system_name
+        case RbConfig::CONFIG['host_os']
+        when /mswin|mingw|cygwin/i then 'Windows'
+        when /darwin/i then 'macOS'
+        when /linux/i then 'Linux'
+        when /bsd/i then 'BSD'
+        else RbConfig::CONFIG['host_os']
+        end
+      end
+    end
+  end
+end

data/lib/aicli/helpers/shell_history.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module AiCli
+  module Helpers
+    module ShellHistory
+      module_function
+
+      def append(command)
+        history_file = history_file_path
+        return unless history_file
+
+        last = last_command(history_file)
+        return if last == command
+
+        File.open(history_file, 'a') { |f| f.puts(command) }
+      rescue StandardError
+        # Ignore history write errors
+      end
+
+      def history_file_path
+        shell = File.basename(ENV['SHELL'] || '')
+        home = Dir.home
+
+        case shell
+        when 'bash', 'sh'
+          File.join(home, '.bash_history')
+        when 'zsh'
+          File.join(home, '.zsh_history')
+        when 'fish'
+          File.join(home, '.local', 'share', 'fish', 'fish_history')
+        when 'ksh'
+          File.join(home, '.ksh_history')
+        when 'tcsh'
+          File.join(home, '.history')
+        end
+      end
+
+      def last_command(history_file)
+        return nil unless File.exist?(history_file)
+
+        lines = File.read(history_file).strip.split("\n")
+        lines.last
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/aicli/helpers/strip_regex_patterns.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module AiCli
+  module Helpers
+    module StripRegexPatterns
+      module_function
+
+      def call(input_string, pattern_list)
+        pattern_list.reduce(input_string) do |current, pattern|
+          next current if pattern.nil?
+
+          if pattern.is_a?(Regexp)
+            current.gsub(pattern, '')
+          else
+            current.gsub(pattern.to_s, '')
+          end
+        end
+      end
+    end
+  end
+end