aicli 0.3.0 → 0.4.0

data/lib/aicli/helpers/completion.rb

@@ -3,50 +3,28 @@
 module AiCli
   module Helpers
     module Completion
-      EXPLAIN_IN_SECOND_REQUEST = true
-      # Opening fence must include a newline after optional language tag (e.g. ```zsh\n).
-      # Using \n? allowed ``` alone to match while streaming, leaking "zsh" into "zshfind".
       SHELL_CODE_EXCLUSIONS = [/```[a-zA-Z]*\n/i, /```[a-zA-Z]*/i, "\n"].freeze
 
       module_function
 
-      def get_script_and_info(prompt:, config:)
-        {
-          read_script: stream_prompt(full_prompt(prompt), config: config, exclusions: SHELL_CODE_EXCLUSIONS),
-          read_info: ->(_writer) { '' }
-        }
+      def get_script(prompt:, config:)
+        ask(full_prompt(prompt), config, SHELL_CODE_EXCLUSIONS)
       end
 
       def get_explanation(script:, config:)
-        { read_explanation: stream_prompt(explanation_prompt(script), config: config) }
+        ask(explanation_prompt(script), config, [])
       end
 
       def get_revision(prompt:, code:, config:)
-        {
-          read_script: stream_prompt(
-            revision_prompt(prompt, code),
-            config: config,
-            exclusions: SHELL_CODE_EXCLUSIONS
-          )
-        }
+        ask(revision_prompt(prompt, code), config, SHELL_CODE_EXCLUSIONS)
       end
 
       def get_models(provider)
         Llm.list_chat_models(provider)
       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
-
-      # Multi-turn chat helper used by `ai chat`.
       def start_chat(config)
-        chat = Llm.build_chat(config)
-        chat.with_instructions(chat_system_prompt)
-        chat
+        Llm.build_chat(config).tap { |chat| chat.with_instructions(chat_system_prompt) }
       end
 
       def chat_system_prompt
@@ -57,46 +35,74 @@ module AiCli
           Target shell: #{OsDetect.detect_shell}
 
           Whenever you suggest a command the user can run, put the exact runnable command
-          alone inside a markdown fenced code block, for example:
-
-          ```
-          ls -la
-          ```
-
-          Prefer a single command. You may briefly explain outside the fence.
-          Do not wrap non-runnable prose in fences.
+          alone inside a markdown fenced code block. Prefer a single command.
         PROMPT
       end
 
       def extract_commands(text)
         return [] if text.nil? || text.empty?
 
-        blocks = text.scan(/```(?:[a-zA-Z0-9_+-]*)\s*\n?(.*?)```/m)
-                     .flatten
-                     .map { |block| block.strip.gsub(/\A`+|`+\z/, '') }
-                     .map(&:strip)
-                     .reject(&:empty?)
-
-        # Prefer the last fenced command if several were suggested.
-        blocks
+        text.scan(/```(?:[a-zA-Z0-9_+-]*)\s*\n?(.*?)```/m)
+            .flatten
+            .map { |block| block.strip.gsub(/\A`+|`+\z/, '') }
+            .reject(&:empty?)
       end
 
       def stream_chat_message(chat, message, writer:)
         data = +''
 
-        begin
-          chat.ask(message) do |chunk|
-            content = chunk.content.to_s
-            next if content.empty?
+        chat.ask(message) do |chunk|
+          content = chunk.content.to_s
+          next if content.empty?
 
-            data << content
-            writer.call(content)
-          end
-        rescue RubyLLM::Error, RubyLLM::ConfigurationError => e
-          handle_ruby_llm_error(e)
+          data << content
+          writer.call(content)
         end
 
         data
+      rescue RubyLLM::Error, RubyLLM::ConfigurationError => e
+        handle_ruby_llm_error(e)
+      end
+
+      def ask(prompt, config, exclusions)
+        ask_stream(prompt, config, exclusions) { |_chunk| }
+      end
+
+      def ask_stream(prompt, config, exclusions, &writer)
+        chat = Llm.build_chat(config)
+        data = +''
+        data_start = exclusions.empty?
+        buffer = +''
+        prefix = exclusions.first
+
+        chat.ask(prompt) do |chunk|
+          content = chunk.content.to_s
+          next if content.empty?
+
+          unless data_start
+            buffer << content
+            next unless prefix.nil? || buffer.match?(prefix)
+
+            data_start = true
+            remainder = strip_exclusions(buffer, exclusions)
+            buffer = +''
+            next if remainder.empty?
+
+            data << remainder
+            writer.call(remainder)
+            next
+          end
+
+          cleaned = strip_exclusions(content, exclusions)
+          next if cleaned.empty?
+
+          data << cleaned
+          writer.call(cleaned)
+        end
+
+        sanitize_script(data)
+      rescue RubyLLM::Error, RubyLLM::ConfigurationError => e
+        handle_ruby_llm_error(e)
       end
 
       def explanation_prompt(script)
@@ -107,12 +113,8 @@ module AiCli
         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.'
+        'In one or two short sentences, explain what the script does. Plain text only.'
       end
 
       def generation_details
@@ -124,16 +126,13 @@ module AiCli
       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}
+          The target shell is #{OsDetect.detect_shell}
 
           #{generation_details}
 
-          #{explain}
-
           The prompt is: #{prompt}
         PROMPT
       end
@@ -150,43 +149,10 @@ module AiCli
         PROMPT
       end
 
-      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)
+      def strip_exclusions(text, exclusions)
+        exclusions.reduce(text) do |current, pattern|
+          pattern.is_a?(Regexp) ? current.gsub(pattern, '') : current.gsub(pattern.to_s, '')
         end
-
-        sanitize_script(data)
       end
 
       def sanitize_script(script)
@@ -229,13 +195,9 @@ module AiCli
           MSG
         end
 
-        raise KnownError, <<~MSG
-          Request to the LLM provider failed:
-
-          #{message}
-        MSG
+        raise KnownError, "Request to the LLM provider failed:\n\n#{message}"
       end
-      private_class_method :stream_to_writer, :handle_ruby_llm_error, :sanitize_script
+      private_class_method :ask_stream, :handle_ruby_llm_error, :strip_exclusions, :sanitize_script
     end
   end
 end

data/lib/aicli/helpers/config.rb

@@ -119,13 +119,9 @@ module AiCli
         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)
+        prompt = Helpers::Theme.prompt(interrupt: :exit)
 
         loop do
           config = get

data/lib/aicli/helpers/constants.rb

@@ -6,6 +6,7 @@ module AiCli
       COMMAND_NAME = 'ai'
       PROJECT_NAME = 'aicli'
       REPO_URL = 'https://github.com/magnum/aicli'
+      ACCENT_COLOR = :cyan
     end
   end
 end

data/lib/aicli/helpers/context.rb

@@ -7,7 +7,6 @@ require 'time'
 module AiCli
   module Helpers
     module Context
-      # Keep the last N user/assistant messages across sessions.
       MAX_MESSAGES = 40
       CONTEXT_FILENAME = 'context'
 
@@ -45,7 +44,7 @@ module AiCli
         }
         File.write(path, "#{JSON.pretty_generate(payload)}\n")
       rescue StandardError
-        # Ignore persistence failures; chat should still work.
+        nil
       end
 
       def save_from_chat(chat)

data/lib/aicli/helpers/error.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'pastel'
-
 module AiCli
   module Helpers
     class KnownError < StandardError; end
@@ -12,7 +10,7 @@ module AiCli
       def handle_cli_error(error)
         return if error.is_a?(KnownError)
 
-        pastel = Pastel.new
+        pastel = Theme.pastel
         indent = ' ' * 4
 
         if error.is_a?(StandardError) && error.backtrace

data/lib/aicli/helpers/i18n.rb

@@ -46,6 +46,12 @@ module AiCli
           LANGUAGES
         end
 
+        def load_from_config!
+          set_language(Config.get['LANGUAGE'])
+        rescue StandardError
+          set_language('en')
+        end
+
         private
 
         def load_translations

data/lib/aicli/helpers/script_action_menu.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module AiCli
+  module Helpers
+    module ScriptActionMenu
+      MARKER = '‣'
+
+      module_function
+
+      def select(question:, config:, silent_mode:, empty_script: false)
+        choices = build_choices(config, silent_mode, empty_script)
+        Menu.new(question, choices).ask
+      end
+
+      def build_choices(config, silent_mode, empty_script)
+        items = []
+        unless empty_script
+          items << choice('y', :yes, I18n.t('Yes'))
+          items << choice('m', :edit, I18n.t('Modify'))
+          unless silent_mode || config['SILENT_MODE']
+            items << choice('e', :explain, I18n.t('Explain'))
+          end
+        end
+        items << choice('r', :revise, I18n.t('Revise'))
+        items << choice('c', :copy, I18n.t('Copy'))
+        items << choice('x', :cancel, I18n.t('Exit'))
+        items
+      end
+
+      def choice(key, value, label)
+        { key: key, value: value, label: shortcut_label(label, key) }
+      end
+
+      def shortcut_label(text, key)
+        idx = text.downcase.index(key.downcase)
+        return text unless idx
+
+        result = text.downcase
+        result[idx] = result[idx].upcase
+        result
+      end
+
+      class Menu
+        def initialize(question, choices)
+          @question = question
+          @choices = choices
+          @active = 0
+          @done = false
+          @result = nil
+          @prompt = Theme.prompt(interrupt: :exit)
+        end
+
+        def ask
+          @prompt.print(@prompt.hide)
+          @prompt.subscribe(self) do
+            until @done
+              view = render_view
+              lines = line_count(view)
+              @prompt.print(view)
+              @prompt.read_keypress
+              @prompt.print(@prompt.clear_lines(lines)) unless @done
+            end
+          end
+          @result
+        ensure
+          @prompt.print(@prompt.show)
+        end
+
+        def keyenter(*)
+          choose_active
+        end
+
+        alias keyreturn keyenter
+        alias keyspace keyenter
+
+        def keyup(*)
+          @active = (@active - 1) % @choices.size
+        end
+
+        def keydown(*)
+          @active = (@active + 1) % @choices.size
+        end
+
+        alias keytab keydown
+
+        def keypress(event)
+          value = event.value.to_s
+          return if value.empty? || value.start_with?("\e")
+
+          char = value.downcase
+          idx = @choices.index { |choice| choice[:key] == char }
+          return unless idx
+
+          @active = idx
+          choose_active
+        end
+
+        def choose_active
+          @result = @choices[@active][:value]
+          @done = true
+        end
+
+        def render_view
+          output = ["#{@question}\n"]
+          @choices.each_with_index do |choice, index|
+            line = if index == @active
+                     "#{MARKER} #{choice[:label]}"
+                   else
+                     "  #{choice[:label]}"
+                   end
+            output << if index == @active
+                        "#{Theme.accent(line)}\n"
+                      else
+                        "#{line}\n"
+                      end
+          end
+          output.join
+        end
+
+        def line_count(view)
+          view.split($INPUT_RECORD_SEPARATOR, -1).sum do |line|
+            @prompt.count_screen_lines(line)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aicli/helpers/script_editor.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'tty-prompt'
+require 'tty-reader'
+
+module AiCli
+  module Helpers
+    module ScriptEditor
+      module_function
+
+      def ask(script)
+        text = script.to_s
+        return nil if text.strip.empty?
+
+        puts ''
+        puts I18n.t('Edit script')
+        puts Theme.dim(I18n.t('Edit with arrow keys, Enter to confirm, Ctrl+C to cancel'))
+        puts ''
+
+        if text.include?("\n")
+          ask_multiline(text)
+        else
+          ask_line(text)
+        end
+      rescue Interrupt, TTY::Reader::InputInterrupt
+        quit!
+      ensure
+        clear_reline_hook
+      end
+
+      def ask_line(script)
+        require 'reline'
+
+        Reline.pre_input_hook = proc do
+          Reline.insert_text(script.dup)
+          Reline.pre_input_hook = nil
+        end
+
+        line = Reline.readline('$ ', true)
+        line&.strip
+      rescue Interrupt
+        quit!
+      end
+
+      def ask_multiline(script)
+        prompt = Helpers::Theme.prompt(interrupt: :exit)
+        edited = prompt.editor(I18n.t('Edit script'), script, ext: 'sh')
+        edited&.strip
+      rescue TTY::Reader::InputInterrupt
+        quit!
+      end
+
+      def quit!
+        puts I18n.t('Goodbye!')
+        exit 0
+      end
+
+      def clear_reline_hook
+        return unless defined?(Reline)
+
+        Reline.pre_input_hook = nil
+      end
+    end
+  end
+end

data/lib/aicli/helpers/shell_exec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module AiCli
+  module Helpers
+    module ShellExec
+      module_function
+
+      def run(command)
+        system(ENV['SHELL'] || 'bash', '-c', command)
+        ShellHistory.record_executed(command)
+      end
+    end
+  end
+end