aia 0.5.17 → 0.8.0

data/lib/aia/session.rb

@@ -0,0 +1,215 @@
+# lib/aia/session.rb
+
+require 'tty-spinner'
+require 'tty-screen'
+require 'reline'
+require 'prompt_manager'
+require 'json'
+require 'fileutils'
+require 'amazing_print'
+require_relative 'directive_processor'
+require_relative 'history_manager'
+require_relative 'context_manager'
+require_relative 'ui_presenter'
+require_relative 'chat_processor_service'
+require_relative 'prompt_handler'
+require_relative 'utility'
+
+module AIA
+  class Session
+    KW_HISTORY_MAX = 5 # Maximum number of history entries per keyword
+    TERSE_PROMPT   = "\nKeep your response short and to the point.\n"
+
+    def initialize(prompt_handler)
+      @prompt_handler  = prompt_handler
+
+      if AIA.chat? && AIA.config.prompt_id.empty?
+        prompt_instance  = nil
+        @history_manager = nil
+      else
+        prompt_instance  = @prompt_handler.get_prompt(AIA.config.prompt_id)
+        @history_manager = HistoryManager.new(prompt: prompt_instance)
+      end
+
+      @context_manager = ContextManager.new(system_prompt: AIA.config.system_prompt) # Add this line
+      @ui_presenter    = UIPresenter.new
+      @directive_processor = DirectiveProcessor.new
+      @chat_processor      = ChatProcessorService.new(@ui_presenter, @directive_processor)
+
+      if AIA.config.out_file && !AIA.append? && File.exist?(AIA.config.out_file)
+        File.open(AIA.config.out_file, 'w') {} # Truncate the file
+      end
+    end
+
+    # Starts the session, processing the initial prompt and handling user
+    # interactions. It manages the flow of prompts, context, and responses.
+    def start
+      prompt_id = AIA.config.prompt_id
+      role_id   = AIA.config.role
+
+      # Handle chat mode *only* if NO initial prompt is given
+      if AIA.chat?
+        AIA::Utility.robot
+        if prompt_id.empty? && role_id.empty?
+          start_chat
+          return
+        end
+      end
+
+
+      # --- Get and process the initial prompt ---
+      begin
+        prompt = @prompt_handler.get_prompt(prompt_id, role_id)
+      rescue StandardError => e
+        puts "Error: #{e.message}"
+        return
+      end
+
+      # Collect variable values if needed
+      variables = prompt.parameters.keys
+
+      if variables && !variables.empty?
+        variable_values = {}
+        history_manager = AIA::HistoryManager.new prompt: prompt
+
+        variables.each do |var_name|
+          # History is based on the prompt ID and the variable name (without brackets)
+          history = prompt.parameters[var_name]
+
+          # Ask the user for the variable
+          value = history_manager.request_variable_value(
+            variable_name:  var_name,
+            history_values: history
+          )
+          # Store the value using the original BRACKETED key from prompt.parameters
+          if history.include? value
+            history.delete(value)
+          end
+          history << value
+          if history.size > HistoryManager::MAX_VARIABLE_HISTORY
+            history.shift
+          end
+          variable_values[var_name] = history
+        end
+
+        # Assign collected values back for prompt_manager substitution
+        prompt.parameters = variable_values
+      end
+
+      # Add terse instruction if needed
+      if AIA.terse?
+        prompt.text << TERSE_PROMPT
+      end
+
+      prompt.save
+
+      # Substitute variables and get final prompt text
+      prompt_text = prompt.to_s
+
+      # Add context files if any
+      if AIA.config.context_files && !AIA.config.context_files.empty?
+        context = AIA.config.context_files.map do |file|
+          File.read(file) rescue "Error reading file: #{file}"
+        end.join("\n\n")
+        prompt_text = "#{prompt_text}\n\nContext:\n#{context}"
+      end
+
+      # Determine operation type
+      operation_type = @chat_processor.determine_operation_type(AIA.config.model)
+
+      # Add initial user prompt to context *before* sending to AI
+      @context_manager.add_to_context(role: 'user', content: prompt_text)
+
+      # Process the initial prompt
+      @ui_presenter.display_thinking_animation
+      # Send the current context (which includes the user prompt)
+      response = @chat_processor.process_prompt(@context_manager.get_context, operation_type)
+
+      # Add AI response to context
+      @context_manager.add_to_context(role: 'assistant', content: response)
+
+      # Output the response
+      @chat_processor.output_response(response) # Handles display
+
+      # Process next prompts/pipeline (if any)
+      @chat_processor.process_next_prompts(response, @prompt_handler)
+
+      # --- Enter chat mode AFTER processing initial prompt ---
+      if AIA.chat?
+        @ui_presenter.display_separator # Add separator
+        start_chat # start_chat will use the now populated context
+      end
+    end
+
+    # Starts the interactive chat session.
+    def start_chat
+      # Consider if display_chat_header is needed if robot+separator already shown
+      # For now, let's keep it, maybe add an indicator message
+      puts "\nEntering interactive chat mode..."
+      @ui_presenter.display_chat_header
+
+      Reline::HISTORY.clear # Keep Reline history for user input editing, separate from chat context
+
+      loop do
+        # Get user input
+        prompt = @ui_presenter.ask_question
+
+
+        break if prompt.nil? || prompt.strip.downcase == 'exit' || prompt.strip.empty?
+
+        if AIA.config.out_file
+          File.open(AIA.config.out_file, 'a') do |file|
+            file.puts "\nYou: #{prompt}"
+          end
+        end
+
+        if @directive_processor.directive?(prompt)
+          directive_output = @directive_processor.process(prompt, @context_manager) # Pass context_manager
+
+          # Add check for specific directives like //clear that might modify context
+          if prompt.strip.start_with?('//clear', '#!clear:')
+             # Context is likely cleared within directive_processor.process now
+             # or add @context_manager.clear_context here if not handled internally
+             @ui_presenter.display_info("Chat context cleared.")
+             next # Skip API call after clearing
+          elsif directive_output.nil? || directive_output.strip.empty?
+            next # Skip API call if directive produced no output and wasn't //clear
+          else
+            puts "\n#{directive_output}\n"
+            # Optionally add directive output to context or handle as needed
+            # Example: Add a summary to context
+            # @context_manager.add_to_context(role: 'assistant', content: "Directive executed. Output:\n#{directive_output}")
+            # For now, just use a placeholder prompt modification:
+            prompt = "I executed this directive: #{prompt}\nHere's the output: #{directive_output}\nLet's continue our conversation."
+             # Fall through to add this modified prompt to context and send to AI
+          end
+        end
+
+        # Use ContextManager instead of HistoryManager
+        @context_manager.add_to_context(role: 'user', content: prompt)
+
+        # Use ContextManager to get the conversation
+        conversation = @context_manager.get_context # System prompt handled internally
+
+        # FIXME: remove this comment once verified
+        # is conversation the same thing as the context for a chat session? YES
+        # if so need to somehow delete it when the //clear directive is entered. - Addressed above/in DirectiveProcessor
+
+        operation_type = @chat_processor.determine_operation_type(AIA.config.model)
+        @ui_presenter.display_thinking_animation
+        response = @chat_processor.process_prompt(conversation, operation_type)
+
+        @ui_presenter.display_ai_response(response)
+
+        # Use ContextManager instead of HistoryManager
+        @context_manager.add_to_context(role: 'assistant', content: response)
+
+        @chat_processor.speak(response)
+
+        @ui_presenter.display_separator
+      end
+
+      @ui_presenter.display_chat_end
+    end
+  end
+end

data/lib/aia/shell_command_executor.rb

@@ -0,0 +1,109 @@
+# lib/aia/shell_command_executor.rb
+
+module AIA
+  class ShellCommandExecutor
+    DANGEROUS_PATTERNS = [
+      # File system destructive commands
+      /\brm\s+(-[a-z]*)?f/i,               # rm with force flag
+      /\bmkfs/i,                           # format filesystems
+      /\bdd\b.*\bof=/i,                    # dd with output file
+      /\bshred\b/i,                        # securely delete files
+      # System modification commands
+      /\bsystemctl\s+(stop|disable|mask)/i, # stopping system services
+      /\bchmod\s+777\b/i,                  # setting dangerous permissions
+      /\b(halt|poweroff|shutdown|reboot)\b/i, # system power commands
+      # Network security related
+      /\btcpdump\b/i,                      # packet capturing
+      /\bifconfig\b.*\bdown\b/i,           # taking down network interfaces
+      # Process control
+      /\bkill\s+-9\b/i,                    # force killing processes
+      /\bpkill\b/i                         # pattern-based process killing
+    ].freeze
+
+
+    MAX_COMMAND_LENGTH = 500
+
+
+
+    def initialize
+      # Stub method for future implementation
+    end
+
+    # Class-level
+
+
+
+
+
+    def self.execute_command(command)
+      new.execute_command(command)
+    end
+
+
+
+    def execute_command(command)
+      return "No command specified" if blank?(command)
+
+      validation_result = validate_command(command)
+      return validation_result if validation_result
+
+      `#{command}`.chomp
+    rescue StandardError => error
+      "Error executing shell command: #{error.message}"
+    end
+
+
+
+    def dangerous_command?(command)
+      return false if blank?(command)
+      DANGEROUS_PATTERNS.any? { |pattern| command =~ pattern }
+    end
+
+    private
+
+
+
+    def blank?(str)
+      str.nil? || str.strip.empty?
+    end
+
+
+
+    def validate_command(command)
+      command_length = command.length
+
+      if command_length > MAX_COMMAND_LENGTH
+        return "Error: Command too long (#{command_length} chars). Maximum length is #{MAX_COMMAND_LENGTH}."
+      end
+
+
+      is_dangerous = dangerous_command?(command)
+
+
+      if AIA.strict_shell_safety? && is_dangerous
+        return "Error: Potentially dangerous command blocked for security reasons: '#{command}'"
+      end
+
+      if AIA.shell_confirm? && is_dangerous
+        return prompt_confirmation(command)
+      end
+
+      nil # Command is valid
+    end
+
+
+
+
+
+
+
+    def prompt_confirmation(command)
+      puts "\n⚠️  WARNING: Potentially dangerous shell command detected:"
+      puts "\n    #{command}\n"
+      print "\nDo you want to execute this command? [y/N]: "
+      confirm = STDIN.gets.chomp.downcase
+      return "Command execution canceled by user" unless confirm == 'y'
+      nil
+    end
+  end
+end

data/lib/aia/ui_presenter.rb

@@ -0,0 +1,110 @@
+# lib/aia/ui_presenter.rb
+
+require 'tty-screen'
+require 'reline'
+
+module AIA
+  class UIPresenter
+    USER_PROMPT = "Follow up (cntl-D or 'exit' to end) #=> "
+
+
+    def initialize
+      @terminal_width = TTY::Screen.width
+    end
+
+    def display_chat_header
+      puts "#{'═' * @terminal_width}\n"
+    end
+
+
+    def display_thinking_animation
+      puts "\n⏳ Processing...\n"
+    end
+
+
+    def display_ai_response(response)
+      puts "\nAI: "
+      format_chat_response(response)
+
+      if AIA.config.out_file
+        File.open(AIA.config.out_file, 'a') do |file|
+          file.puts "\nAI: "
+          format_chat_response(response, file)
+        end
+      end
+    end
+
+
+    def format_chat_response(response, output = $stdout)
+      indent = '   '
+
+      in_code_block = false
+      language = ''
+
+      response.each_line do |line|
+        line = line.chomp
+
+        # Check for code block delimiters
+        if line.match?(/^```(\w*)$/) && !in_code_block
+          in_code_block = true
+          language = $1
+          output.puts "#{indent}```#{language}"
+        elsif line.match?(/^```$/) && in_code_block
+          in_code_block = false
+          output.puts "#{indent}```"
+        elsif in_code_block
+          # Print code with special formatting
+          output.puts "#{indent}#{line}"
+        else
+          # Handle regular text
+          output.puts "#{indent}#{line}"
+        end
+      end
+    end
+
+
+    def display_separator
+      puts "\n#{'─' * @terminal_width}"
+    end
+
+
+    def display_chat_end
+      puts "\nChat session ended."
+    end
+
+
+    # This is the follow up question in a chat session
+    def ask_question
+      puts USER_PROMPT
+      $stdout.flush  # Ensure the prompt is displayed immediately
+      begin
+        input = Reline.readline('', true)
+        return nil if input.nil? # Handle Ctrl+D
+        Reline::HISTORY << input unless input.strip.empty?
+        input
+      rescue Interrupt
+        puts "\nChat session interrupted."
+        return 'exit'
+      end
+    end
+
+    def display_info(message)
+      puts "\n#{message}"
+    end
+
+    def with_spinner(message = "Processing", operation_type = nil)
+      if AIA.verbose?
+        spinner_message = operation_type ? "#{message} #{operation_type}..." : "#{message}..."
+        spinner = TTY::Spinner.new("[:spinner] #{spinner_message}", format: :bouncing_ball)
+        spinner.auto_spin
+
+        result = yield
+
+        spinner.stop
+        result
+      else
+        yield
+      end
+    end
+  end
+end

data/lib/aia/utility.rb

@@ -0,0 +1,24 @@
+# lib/aia/utility.rb
+
+module AIA
+  class Utility
+    class << self
+      # Displays the AIA robot ASCII art
+      def robot
+        puts <<-ROBOT
+
+       ,      ,
+       (\\____/) AI Assistant
+        (_oo_)   #{AIA.config.model}
+         (O)      is Online
+       __||__    \\)
+     [/______\\]  /
+    / \\__AI__/ \\/
+   /    /__\\
+  (\\   /____\\
+
+        ROBOT
+      end
+    end
+  end
+end

data/lib/aia/version.rb

@@ -1,10 +1,13 @@
 # lib/aia/version.rb
-# frozen_string_literal: true
-
-require 'versionaire'
+#
+# This file defines the version of the AIA application.
+# The VERSION constant defines the current version of the AIA application,
+# which is read from the .version file in the project root.
 
+# The AIA module serves as the namespace for the AIA application, which
+# provides an interface for interacting with AI models and managing prompts.
 module AIA
-  VERSION_FILEPATH  = "#{__dir__}/../../.version"
-  VERSION           = Versionaire::Version File.read(VERSION_FILEPATH).strip
-  def self.version  = VERSION
+  # The VERSION constant defines the current version of the AIA application,
+  # which is read from the .version file in the project root.
+  VERSION = File.read(File.join(File.dirname(__FILE__), '..', '..', '.version')).strip
 end

data/lib/aia.rb

@@ -1,78 +1,74 @@
 # lib/aia.rb
+#
+# This is the main entry point for the AIA application.
+# The AIA module serves as the namespace for the AIA application, which
+# provides an interface for interacting with AI models and managing prompts.
 
-def tramp_require(what, &block)
-  loaded, require_result = false, nil
-
-  begin
-    require_result = require what
-    loaded = true
-  rescue Exception => ex
-    # Do nothing
+require 'ai_client'
+require 'prompt_manager'
+require 'debug_me'
+include DebugMe
+$DEBUG_ME = false
+DebugMeDefaultOptions[:skip1] = true
+
+require_relative 'extensions/openstruct_merge'
+require_relative 'aia/utility'
+require_relative 'aia/version'
+require_relative 'aia/config'
+require_relative 'aia/shell_command_executor'
+require_relative 'aia/prompt_handler'
+require_relative 'aia/ai_client_adapter'
+require_relative 'aia/directive_processor'
+require_relative 'aia/history_manager'
+require_relative 'aia/ui_presenter'
+require_relative 'aia/chat_processor_service'
+require_relative 'aia/session'
+
+# The AIA module serves as the namespace for the AIA application, which
+# provides an interface for interacting with AI models and managing prompts.
+module AIA
+  at_exit do
+    STDERR.puts "Exiting AIA application..."
   end
 
-  yield if loaded and block_given?
-
-  require_result
-end
-
-tramp_require('debug_me') {
-  include DebugMe
-}
-
-require 'hashie'
-require 'openai'
-require 'os'
-require 'pathname'
-require 'reline'
-require 'shellwords'
-require 'tempfile'
-
-require 'tty-spinner'
-
-unless TTY::Spinner.new.respond_to?(:log)
-  # Allows messages to be sent to the console while
-  # the spinner is still spinning.
-  require_relative './core_ext/tty-spinner_log'
-end
-
-require 'prompt_manager'
-require 'prompt_manager/storage/file_system_adapter'
+  @config = nil
 
-require_relative "aia/version"
-require_relative "aia/clause"
-require_relative "aia/main"
-require_relative "core_ext/string_wrap"
+  def self.config
+    @config
+  end
 
-module AIA
-  class << self
-    attr_accessor :config
-    attr_accessor :client
+  def self.client
+    @config.client
+  end
 
-    def run(args=ARGV)
-      args = args.split(' ') if args.is_a?(String)
+  def self.client=(client)
+    @config.client = client
+  end
 
-      # TODO: Currently this is a one and done architecture.
-      #       If the args contain an "-i" or and "--interactive"
-      #       flag could this turn into some kind of
-      #       conversation REPL?
-      
-      AIA::Main.new(args).call
+  def self.build_flags
+    @config.each_pair do |key, value|
+      if [TrueClass, FalseClass].include?(value.class)
+        define_singleton_method("#{key}?") do
+          @config[key]
+        end
+      end
     end
+  end
 
+  def self.run
+    @config = Config.setup
 
-    def speak(what)
-      return unless config.speak?
+    build_flags
 
-      if OS.osx? && 'siri' == config.voice.downcase
-        system "say #{Shellwords.escape(what)}"
-      else
-        Client.speak(what)
-      end
+    # Load Fzf if fuzzy search is enabled and fzf is installed
+    if @config.fuzzy && system('which fzf >/dev/null 2>&1')
+      require_relative 'aia/fzf'
     end
 
+    prompt_handler = PromptHandler.new
+    @config.client = AIClientAdapter.new
+    session        = Session.new(prompt_handler)
 
-    def verbose?  = AIA.config.verbose?
-    def debug?    = AIA.config.debug?
+    session.start
   end
 end
-

data/lib/extensions/openstruct_merge.rb

@@ -0,0 +1,44 @@
+# lib/extensions/openstruct_merge.rb
+#
+
+require 'ostruct'
+
+class OpenStruct
+  def self.merge(*args)
+    result = OpenStruct.new
+
+    args.each do |arg|
+      unless [Hash, OpenStruct].include?(arg.class)
+        raise ArgumentError, "Only OpenStruct or Hash objects are allowed. bad: #{arg.class}"
+      end
+
+      arg.each_pair do |key, value|
+        set_value(result, key, value)
+      end
+    end
+
+    result
+  end
+
+  # Sets value in result OpenStruct, handling nested OpenStruct and Hash objects
+  def self.set_value(result, key, value)
+    if value.is_a?(OpenStruct) || value.is_a?(Hash)
+      current_value = result[key]
+      current_value = {} if current_value.nil?
+      merged_value  = merge(current_value, value.to_h)
+      result[key]   = merged_value
+    else
+      result[key] = value
+    end
+  end
+end
+
+__END__
+
+# Usage example
+os1 = OpenStruct.new(a: 1, b: 2, e: OpenStruct.new(x: 9))
+os2 = OpenStruct.new(b: 3, c: 4)
+os3 = {d: 5, e: {y: 10}}
+
+merged_os = OpenStruct.merge(os1, os2, os3)
+puts merged_os.inspect