aia 0.5.18 → 0.8.0

data/Rakefile

@@ -12,12 +12,23 @@ require 'kramdown/man/task'
 Kramdown::Man::Task.new
 
 require "bundler/gem_tasks"
-require "rake/testtask"
+require "minitest/test_task"
 
-Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.libs << "lib"
-  t.test_files = FileList["test/**/*_test.rb"]
+Minitest::TestTask.create(:test) do |t|
+  t.libs        << "test"
+  t.libs        << "lib"
+  t.warning     = false
+  t.test_globs  = ["test/aia/*_test.rb", "test/aia_test.rb", "!test/integration/**/*_test.rb"]
 end
 
+Minitest::TestTask.create(:integration) do |t|
+  t.libs        << "test"
+  t.libs        << "lib"
+  t.warning     = false
+  t.test_globs  = ["test/integration/**/*_test.rb"]
+end
+
+desc "Run all tests including integration tests"
+task all_tests: [:test, :integration]
+
 task default: :test

data/_notes.txt

@@ -0,0 +1,231 @@
+
+--- 2025-02-01 18:01:36 -0600
+    I have no idea where I left off in this branch. The objective is to replace all the back-end processes with AiClient.
+
+    Tests are failing.
+
+    Make a few changes.  It seems to be working in its basic modes.
+    
+--- 2025-02-21 20:13:19 -0600
+    Implemented Stark's clean slate protocol
+
+  
+
+
+
+--- 2025-03-29 21:39:46 -0500
+    starting the refactor to take advantage of the new capability of the PromptMananger gem.
+
+  lib/aia/chat_processor_service.rb
+
+
+
+--- 2025-04-03 22:17:11 -0500
+    i have been tring to get multi-line input to work in the chat mode but have run into all kinds of problems. I think it would be best just to invoke the users editor for that kind of operation. Alo I am not sure but I thing the same ask method is used for getting values for parameters. changes may have been committed but they should be reversed back to the original and start over.
+
+  def get_multiline_input
+	  input_lines     = []
+	  current_line    = ""
+	  last_key_time   = Time.now
+	  waiting_printed = 0 # Track number of WAITING characters printed
+	
+	  STDIN.raw! # Enable raw mode for immediate keypress detection
+	  begin
+	    loop do
+	      begin
+	        r, _, _ = IO.select([STDIN], nil, nil, 0.1)
+	        if r
+	          char = STDIN.getc
+	          last_key_time = Time.now
+	          # Clear waiting characters when user types again
+	          if waiting_printed > 0
+	            print WAITING_ERASE * waiting_printed # Erase all waiting characters
+	            $stdout.flush
+	            waiting_printed = 0
+	          end
+	        else
+	          if (Time.now - last_key_time >= KEYPRESS_TIMEUT) &&
+	              waiting_printed == 0 &&
+	              (!input_lines.empty? || !current_line.empty?)
+	            print WAITING
+	            $stdout.flush
+	            waiting_printed = 1 # Record one '?' printed
+	          end
+	          next
+	        end
+	
+	      rescue Interrupt
+	        puts "\nInput cancelled. Discarding current input; please start over."
+	        input_lines     = []
+	        current_line    = ""
+	        waiting_printed = 0
+	        last_key_time   = Time.now
+	        next
+	      end
+	
+	      break if char.nil? # Handle EOF (Ctrl+D)
+	
+	      if char == "\r" || char == "\n"
+	        if current_line.empty? && !input_lines.empty?
+	          break # Two Enters in a row submits
+	        else
+	          input_lines << current_line
+	          current_line = ""
+	          waiting_printed = 0 # Reset waiting on new line
+	          print "\n\r"
+	          $stdout.flush
+	        end
+	
+	      elsif char == "\x04" # Ctrl+D
+	        break
+	
+	      elsif char == "\x08" || char == "\x7F" # Backspace or Delete
+	        if !current_line.empty?
+	          current_line.chop!
+	          print WAITING_ERASE
+	          $stdout.flush
+	        elsif waiting_printed > 0
+	          # Clear one waiting character if current_line is empty
+	          print "\b \b"
+	          $stdout.flush
+	          waiting_printed -= 1
+	        end
+	
+	      else
+	        current_line << char
+	        print char
+	        $stdout.flush
+	      end
+	    end
+	
+	  ensure
+	    STDIN.cooked! # Restore terminal to normal mode
+	  end
+	
+	  input_lines << current_line unless current_line.empty?
+	
+	  # Handle single-line special case
+	  if input_lines.size == 1
+	    if special_first_line_processing(input_lines.first)
+	      # If special (starts with "//"), return immediately as if double return was pressed
+	      return input_lines.first
+	    else
+	      # If not special, keep as is and return the full input
+	      return input_lines.join("\n")
+	    end
+	  end
+	
+	  input_lines.join("\n").tap do |result|
+	    puts "\n" if result.empty? # Clean up display if no input
+	  end
+	
+	rescue EOFError
+	  input_lines.join("\n")
+	end
+
+
+
+--- 2025-04-03 22:18:18 -0500
+    by using subl -w for multi-line input in chat mode that gives us the ability to write ERB for chat input.
+
+  def get_multiline_input
+	  input_lines     = []
+	  current_line    = ""
+	  last_key_time   = Time.now
+	  waiting_printed = 0 # Track number of WAITING characters printed
+	
+	  STDIN.raw! # Enable raw mode for immediate keypress detection
+	  begin
+	    loop do
+	      begin
+	        r, _, _ = IO.select([STDIN], nil, nil, 0.1)
+	        if r
+	          char = STDIN.getc
+	          last_key_time = Time.now
+	          # Clear waiting characters when user types again
+	          if waiting_printed > 0
+	            print WAITING_ERASE * waiting_printed # Erase all waiting characters
+	            $stdout.flush
+	            waiting_printed = 0
+	          end
+	        else
+	          if (Time.now - last_key_time >= KEYPRESS_TIMEUT) &&
+	              waiting_printed == 0 &&
+	              (!input_lines.empty? || !current_line.empty?)
+	            print WAITING
+	            $stdout.flush
+	            waiting_printed = 1 # Record one '?' printed
+	          end
+	          next
+	        end
+	
+	      rescue Interrupt
+	        puts "\nInput cancelled. Discarding current input; please start over."
+	        input_lines     = []
+	        current_line    = ""
+	        waiting_printed = 0
+	        last_key_time   = Time.now
+	        next
+	      end
+	
+	      break if char.nil? # Handle EOF (Ctrl+D)
+	
+	      if char == "\r" || char == "\n"
+	        if current_line.empty? && !input_lines.empty?
+	          break # Two Enters in a row submits
+	        else
+	          input_lines << current_line
+	          current_line = ""
+	          waiting_printed = 0 # Reset waiting on new line
+	          print "\n\r"
+	          $stdout.flush
+	        end
+	
+	      elsif char == "\x04" # Ctrl+D
+	        break
+	
+	      elsif char == "\x08" || char == "\x7F" # Backspace or Delete
+	        if !current_line.empty?
+	          current_line.chop!
+	          print WAITING_ERASE
+	          $stdout.flush
+	        elsif waiting_printed > 0
+	          # Clear one waiting character if current_line is empty
+	          print "\b \b"
+	          $stdout.flush
+	          waiting_printed -= 1
+	        end
+	
+	      else
+	        current_line << char
+	        print char
+	        $stdout.flush
+	      end
+	    end
+	
+	  ensure
+	    STDIN.cooked! # Restore terminal to normal mode
+	  end
+	
+	  input_lines << current_line unless current_line.empty?
+	
+	  # Handle single-line special case
+	  if input_lines.size == 1
+	    if special_first_line_processing(input_lines.first)
+	      # If special (starts with "//"), return immediately as if double return was pressed
+	      return input_lines.first
+	    else
+	      # If not special, keep as is and return the full input
+	      return input_lines.join("\n")
+	    end
+	  end
+	
+	  input_lines.join("\n").tap do |result|
+	    puts "\n" if result.empty? # Clean up display if no input
+	  end
+	
+	rescue EOFError
+	  input_lines.join("\n")
+	end
+
+

data/bin/aia

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
-# bin/aia
+# frozen_string_literal: true
+
+require_relative '../lib/aia'
 
-require 'aia'
 AIA.run

data/examples/README.md

@@ -0,0 +1,140 @@
+# Executable Prompts
+
+Executable prompts are a powerful feature of the AI Assistant (`aia`) that enable users to create and run command-line utilities tailored to interact with AI models. These prompts can automate tasks, generate content, and incorporate custom configurations, making them highly versatile for various applications. In this section, we will delve deeper into the nature of executable prompts, how to configure them with directives, and provide an overview of practical examples.
+
+## What is an Executable Prompt?
+
+An executable prompt is a special type of prompt file that is structured to allow execution through the `aia` command-line interface. By including specific command-line behavior in the form of a shebang line, the prompt can be invoked directly from the terminal like any other executable script.
+
+### Structure of an Executable Prompt
+
+1. **Shebang Line**: The first line of the prompt indicates how the file should be executed. For instance:
+   ```bash
+   #!/usr/bin/env aia run --no-out_file
+   ```
+
+   This line tells the system to use the `aia` CLI with the `run` prompt ID for execution, while `--no-out_file` indicates that output should be sent to STDOUT instead of being written to a file.
+
+2. **Content**: Below the shebang line, users can add the prompt content that will be sent to the AI model for processing. This content can use flexible directives and dynamic parameters.
+
+### Example of an Executable Prompt
+
+```bash
+#!/usr/bin/env aia run --no-out_file
+# File: top10
+# Desc: The top 10 cities by population
+
+What are the top 10 cities by population in the USA? Summarize what people like about living in each city. Include an average cost of living and links to the respective Wikipedia pages. Format your response as a markdown document.
+```
+
+After making this script executable with `chmod +x top10`, it can be run directly in the terminal:
+
+```bash
+./top10
+```
+
+## Using Directives to Configure Execution
+
+Directives embedded within executable prompts allow users to configure various execution parameters dynamically. These directives are special commands within the prompt text that guide the prompt's behavior when processed by the AI model.
+
+### Available Directives
+
+#### 1. **//config**
+
+The `//config` directive is used to modify configuration settings specifically for a particular execution of the prompt. You can set various parameters such as model selection, output handling, or chat mode:
+
+```bash
+//config model = gpt-4
+//config out_file = results.md
+```
+
+**Example**: You can control the model and output settings dynamically without changing global or default settings.
+
+#### 2. **//include**
+
+This directive allows the inclusion of external files or content right into the prompt. This can be useful for injecting multiple lines of data or complex configurations:
+
+```bash
+//include path/to/config.txt
+```
+
+This will read the content of `config.txt` and prepend it to the prompt context.
+
+#### 3. **//shell**
+
+Execute shell commands dynamically and include their results in the prompt. This integration can enhance your prompts by feeding them real-time data:
+
+```bash
+//shell echo $(pwd)
+```
+
+This would prepend the current working directory to the prompt's input.
+
+### Parameterization
+
+Executable prompts can also accept parameters or keywords that users define themselves. For instance:
+
+```bash
+[MY_TOPIC]
+```
+
+When the prompt runs, users will be prompted to provide a value for `MY_TOPIC`, allowing for flexible and dynamic conversations with the AI model.
+
+## Benefits of Executable Prompts
+
+1. **Automation**: Automate complex tasks by wrapping them in a reusable script.
+2. **Dynamic Content**: Use directives to dynamically adjust settings, include external data, and run system commands.
+3. **Ease of Use**: Users can execute prompts directly from the terminal without entering the `aia` command each time.
+4. **Configuration Flexibility**: Tailor specific prompt executions without altering global settings, giving you full control over the runtime environment.
+
+## Practical Examples of Executable Prompts
+
+### Example 1: Top 10 Cities Script
+
+Create a script that gives information on the top cities in the USA:
+
+```bash
+#!/usr/bin/env aia run --no-out_file
+# File: top10
+# Desc: Retrieves top 10 cities by population
+
+//config out_file=top10_cities.md
+
+What are the top 10 cities by population in the USA? Summarize what people like about living in each city and include links to their respective Wikipedia pages.
+```
+
+### Example 2: Weather Report
+
+```bash
+#!/usr/bin/env aia run
+# File: weather_report
+# Desc: Gets today's weather
+
+//shell curl -s 'wttr.in/Toronto?format=3'
+
+Today's weather in Toronto is: $(cat weather_output.txt).
+```
+
+### Example 3: Dynamic Task Execution
+
+A user can create a prompt for performing mathematical calculations:
+
+```bash
+#!/usr/bin/env aia run
+# File: calculate
+# Desc: Simple calculator
+
+//config model=gpt-3
+
+Please calculate [MATH_EXPRESSION].
+```
+
+When executed, the user is prompted to input the mathematical expression they want to calculate.
+
+### Example of Using STDOUT and Piping
+
+You can combine executable prompts with other shell commands to further manipulate the output:
+
+```bash
+./top10 | glow  # Pipe output to glow for rendering markdown in the terminal
+```

data/examples/headlines

@@ -0,0 +1,21 @@
+#!/usr/bin/env aia run --no-out_file
+# File: examples/headlines
+# Desc: retrieves the news.google.com website
+#       extracts and formats the headlines
+#       and prints them to the console
+
+//config shell = true
+# //config
+
+# Puts the webpage into index.html
+# //shell wget2 https://news.google.com
+
+$(wget2 https://news.google.com)
+
+
+# Lets hear the headlines as well as read them.
+//config speak = true
+
+Extract and summarize the headlines from the following text:
+
+$(html2text index.html)

data/lib/aia/ai_client_adapter.rb

@@ -0,0 +1,210 @@
+# lib/aia/ai_client_adapter.rb
+#
+
+
+require 'ai_client'
+require 'tty-spinner'
+
+
+module AIA
+  class AIClientAdapter
+    def initialize
+      @model  = AIA.config.model
+
+      model_info = extract_model_parts(@model)
+      @client = AiClient.new(
+        model_info[:model],
+        provider: model_info[:provider]
+      )
+    end
+
+
+    def chat(prompt)
+      if @model.downcase.include?('dall-e') || @model.downcase.include?('image-generation')
+        text_to_image(prompt)
+      elsif @model.downcase.include?('vision') || @model.downcase.include?('image')
+        image_to_text(prompt)
+      elsif @model.downcase.include?('tts') || @model.downcase.include?('speech')
+        text_to_audio(prompt)
+      elsif @model.downcase.include?('whisper') || @model.downcase.include?('transcription')
+        audio_to_text(prompt)
+      else
+        text_to_text(prompt)
+      end
+    end
+
+
+
+    def transcribe(audio_file)
+      @client.transcribe(audio_file)
+    end
+
+
+
+    def speak(text)
+      output_file = "#{Time.now.to_i}.mp3"
+
+      begin
+        # Try with options
+        @client.speak(text, output_file, {
+          model: AIA.config.speech_model,
+          voice: AIA.config.voice
+        })
+      rescue ArgumentError
+        @client.speak(text)
+      end
+
+      system("#{AIA.config.speak_command} #{output_file}") if File.exist?(output_file) && system("which #{AIA.config.speak_command} > /dev/null 2>&1")
+    end
+
+    def method_missing(method, *args, &block)
+      if @client.respond_to?(method)
+        @client.public_send(method, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      @client.respond_to?(method) || super
+    end
+
+    private
+
+
+
+    def extract_model_parts(model_string)
+      parts = model_string.split('/')
+      parts.map!(&:strip)
+
+      if parts.length > 1
+        provider = parts[0]
+        model = parts[1]
+      else
+        provider = nil # AiClient will figure it out from the model name
+        model = parts[0]
+      end
+
+
+
+      { provider: provider, model: model }
+    end
+
+
+
+    def extract_text_prompt(prompt)
+
+      if prompt.is_a?(String)
+        prompt
+      elsif prompt.is_a?(Hash) && prompt[:text]
+        prompt[:text]
+      elsif prompt.is_a?(Hash) && prompt[:content]
+        prompt[:content]
+      else
+        prompt.to_s
+      end
+    end
+
+
+
+    def text_to_text(prompt)
+      text_prompt = extract_text_prompt(prompt)
+      @client.chat(text_prompt)
+    end
+
+
+
+    def text_to_image(prompt)
+      text_prompt = extract_text_prompt(prompt)
+
+
+      output_file = "#{Time.now.to_i}.png"
+
+      begin
+        begin
+          @client.generate_image(text_prompt, output_file, {
+            size:    AIA.config.image_size,
+            quality: AIA.config.image_quality,
+            style:   AIA.config.image_style
+          })
+        rescue ArgumentError
+          @client.generate_image(text_prompt)
+        end
+
+        "Image generated and saved to: #{output_file}"
+      rescue => e
+        "Error generating image: #{e.message}"
+      end
+    end
+
+
+
+    def image_to_text(prompt)
+      image_path = extract_image_path(prompt)
+      text_prompt = extract_text_prompt(prompt)
+
+      if image_path && File.exist?(image_path)
+        begin
+          @client.chat("#{text_prompt}\n[Analyzing image: #{image_path}]")
+        rescue => e
+          "Error analyzing image: #{e.message}"
+        end
+      else
+        text_to_text(prompt)
+      end
+    end
+
+
+
+    def text_to_audio(prompt)
+      text_prompt = extract_text_prompt(prompt)
+
+      output_file = "#{Time.now.to_i}.mp3"
+
+      begin
+        begin
+          @client.speak(text_prompt, output_file, {
+            model: AIA.config.speech_model,
+            voice: AIA.config.voice
+          })
+        rescue ArgumentError
+          @client.speak(text_prompt)
+        end
+
+        system("#{AIA.config.speak_command} #{output_file}") if File.exist?(output_file) && system("which #{AIA.config.speak_command} > /dev/null 2>&1")
+
+        "Audio generated and saved to: #{output_file}"
+      rescue => e
+        "Error generating audio: #{e.message}"
+      end
+    end
+
+
+
+    def audio_to_text(prompt)
+      if prompt.is_a?(String) && File.exist?(prompt) &&
+         prompt.downcase.end_with?('.mp3', '.wav', '.m4a', '.flac')
+        begin
+          @client.transcribe(prompt)
+        rescue => e
+          "Error transcribing audio: #{e.message}"
+        end
+      else
+        # Fall back to regular chat if no valid audio file is found
+        text_to_text(prompt)
+      end
+    end
+
+
+
+    def extract_image_path(prompt)
+      if prompt.is_a?(String)
+        prompt.scan(/\b[\w\/\.\-]+\.(jpg|jpeg|png|gif|webp)\b/i).first&.first
+      elsif prompt.is_a?(Hash)
+        prompt[:image] || prompt[:image_path]
+      else
+        nil
+      end
+    end
+  end
+end