artificial 0.0.1

data/lib/artificial/parsers/xml_parser.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'rexml/document'
+
+module Artificial
+  module Parsers
+    class XMLParser
+      attr_reader :input, :parsed_data, :errors
+
+      def initialize(input)
+        @input = input
+        @parsed_data = {}
+        @errors = []
+      end
+
+      def parse
+        return self unless valid?
+
+        begin
+          doc = REXML::Document.new(@input)
+          @parsed_data = extract_data_from_xml(doc)
+          @parsed_data[:format] = 'xml'
+          @parsed_data[:type] = 'structured_xml'
+        rescue REXML::ParseException => e
+          @errors << "XML parsing error: #{e.message}"
+        end
+
+        self
+      end
+
+      def valid?
+        return false unless @input.is_a?(String)
+        return false if @input.strip.empty?
+
+        begin
+          REXML::Document.new(@input)
+          true
+        rescue REXML::ParseException => e
+          @errors << "Invalid XML: #{e.message}"
+          false
+        end
+      end
+
+      def to_hash
+        @parsed_data
+      end
+
+      private
+
+      def extract_data_from_xml(doc)
+        data = {}
+
+        # Extract common prompt elements
+        if (prompt_element = doc.elements['prompt'])
+          data[:system] = prompt_element.elements['system']&.text
+          data[:instructions] = prompt_element.elements['instructions']&.text
+          data[:text] = data[:instructions] || prompt_element.text&.strip
+
+          # Extract context
+          if (context_element = prompt_element.elements['context'])
+            data[:context] = extract_hash_from_element(context_element)
+          end
+
+          # Extract data section
+          if (data_element = prompt_element.elements['data'])
+            data[:data] = extract_hash_from_element(data_element)
+          end
+
+          # Extract examples
+          if (examples_element = prompt_element.elements['examples'])
+            data[:examples] = extract_examples(examples_element)
+          end
+
+          # Extract grounding
+          if (grounding_element = prompt_element.elements['grounding'])
+            data[:grounding] = extract_grounding(grounding_element)
+          end
+
+          # Extract tools
+          if (tools_element = prompt_element.elements['tools'])
+            data[:tools] = extract_tools(tools_element)
+          end
+        end
+
+        data
+      end
+
+      def extract_hash_from_element(element)
+        hash = {}
+        element.elements.each do |child|
+          hash[child.name.to_sym] = child.text
+        end
+        hash
+      end
+
+      def extract_examples(examples_element)
+        examples = []
+        examples_element.elements.each('example') do |example|
+          examples << if example.elements['input'] && example.elements['output']
+                        {
+                          input: example.elements['input'].text,
+                          output: example.elements['output'].text
+                        }
+                      else
+                        example.text
+                      end
+        end
+        examples
+      end
+
+      def extract_grounding(grounding_element)
+        grounding = {}
+        grounding[:require_quotes] = grounding_element.elements['require_quotes']&.text == 'true'
+        grounding[:require_sources] = grounding_element.elements['require_sources']&.text == 'true'
+        grounding[:allow_uncertainty] = grounding_element.elements['allow_uncertainty']&.text == 'true'
+        grounding
+      end
+
+      def extract_tools(tools_element)
+        tools = []
+        tools_element.elements.each('tool') do |tool|
+          tool_data = { name: tool.attributes['name'] }
+          if (params_element = tool.elements['parameters'])
+            tool_data[:parameters] = extract_hash_from_element(params_element)
+          end
+          tools << tool_data
+        end
+        tools
+      end
+    end
+  end
+end

data/lib/artificial/parsers/yaml_parser.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'psych'
+
+module Artificial
+  module Parsers
+    class YAMLParser
+      attr_reader :input, :parsed_data, :errors
+
+      def initialize(input)
+        @input = input
+        @parsed_data = {}
+        @errors = []
+      end
+
+      def parse
+        return self unless valid?
+
+        begin
+          yaml_data = Psych.safe_load(@input, permitted_classes: [Date, Time, DateTime, Symbol])
+          @parsed_data = normalize_yaml_data(yaml_data)
+          @parsed_data[:format] = 'yaml'
+          @parsed_data[:type] = 'structured_yaml'
+        rescue Psych::SyntaxError => e
+          @errors << "YAML parsing error: #{e.message}"
+        rescue StandardError => e
+          @errors << "YAML processing error: #{e.message}"
+        end
+
+        self
+      end
+
+      def valid?
+        return false unless @input.is_a?(String)
+        return false if @input.strip.empty?
+
+        begin
+          Psych.safe_load(@input, permitted_classes: [Date, Time, DateTime, Symbol])
+          true
+        rescue Psych::SyntaxError => e
+          @errors << "Invalid YAML: #{e.message}"
+          false
+        rescue StandardError => e
+          @errors << "YAML validation error: #{e.message}"
+          false
+        end
+      end
+
+      def to_hash
+        @parsed_data
+      end
+
+      private
+
+      def normalize_yaml_data(yaml_data)
+        return {} unless yaml_data.is_a?(Hash)
+
+        # Convert string keys to symbols for consistency
+        normalized = {}
+        yaml_data.each do |key, value|
+          symbol_key = key.to_s.to_sym
+          normalized[symbol_key] = normalize_value(value)
+        end
+
+        # Ensure common fields are present
+        normalized[:text] ||= normalized[:instructions]
+        normalized[:examples] ||= []
+        normalized[:context] ||= {}
+        normalized[:grounding] ||= {}
+        normalized[:tools] ||= []
+
+        normalized
+      end
+
+      def normalize_value(value)
+        case value
+        when Hash
+          value.transform_keys { |k| k.to_s.to_sym }
+        when Array
+          value.map { |v| normalize_value(v) }
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/artificial/prompt.rb

@@ -0,0 +1,440 @@
+# frozen_string_literal: true
+
+require 'rexml/document'
+require 'json'
+require 'psych'
+
+module Artificial
+  class Prompt
+    attr_accessor :text, :system, :messages, :context, :examples, :thinking,
+                  :assistant_prefill, :format, :grounding, :data, :instructions,
+                  :constraints, :output_format, :tone, :tools, :retrieval,
+                  :citation_style, :validation, :optimization, :documents
+
+    def initialize(input = nil, **options)
+      @format = options[:format] || 'xml'
+      @context = {}
+      @examples = []
+      @constraints = []
+      @grounding = {}
+      @tools = []
+      @documents = []
+
+      parse_input(input, options)
+      apply_options(options)
+    end
+
+    # Generate the final prompt structure
+    def to_s
+      case @format
+      when 'xml'
+        generate_xml_prompt
+      when 'string'
+        generate_string_prompt
+      else
+        generate_xml_prompt
+      end
+    end
+
+    # Method chaining support
+    def with_system(system_prompt)
+      validate_system_prompt(system_prompt) if system_prompt
+      @system = system_prompt
+      self
+    end
+
+    def with_context(**context_options)
+      @context.merge!(context_options)
+      self
+    end
+
+    def with_examples(*example_list)
+      @examples.concat(example_list)
+      self
+    end
+
+    def with_thinking(enabled: true, style: 'step_by_step', show_reasoning: true)
+      @thinking = { enabled: enabled, style: style, show_reasoning: show_reasoning }
+      self
+    end
+
+    def with_grounding(require_quotes: false, require_sources: false, allow_uncertainty: false)
+      @grounding = {
+        require_quotes: require_quotes,
+        require_sources: require_sources,
+        allow_uncertainty: allow_uncertainty
+      }
+      self
+    end
+
+    def with_constraints(*constraint_list)
+      @constraints.concat(constraint_list)
+      self
+    end
+
+    def with_tools(*tool_list)
+      @tools.concat(tool_list)
+      self
+    end
+
+    def with_data(data_hash)
+      @data = data_hash
+      self
+    end
+
+    def with_documents(*document_list)
+      @documents.concat(document_list)
+      self
+    end
+
+    def with_prefill(prefill_text)
+      @assistant_prefill = prefill_text
+      self
+    end
+
+    private
+
+    def parse_input(input, options)
+      case input
+      when String
+        @text = input
+      when Hash
+        parse_hash_input(input)
+      when Array
+        parse_message_array(input)
+      when nil
+        # Handle options-only initialization
+        @text = options[:text] || options[:instructions]
+      else
+        raise ArgumentError, "Unsupported input type: #{input.class}"
+      end
+    end
+
+    def parse_hash_input(hash)
+      @text = hash[:text] || hash[:instructions]
+      @system = hash[:system]
+      @messages = hash[:messages]
+      @context = hash[:context] || {}
+      @examples = hash[:examples] || []
+      @data = hash[:data]
+      @instructions = hash[:instructions]
+
+      # Handle YAML/JSON parsing if needed
+      return unless hash.key?(:yaml) || hash.key?(:json)
+
+      parse_structured_data(hash)
+    end
+
+    def parse_message_array(messages)
+      validate_messages(messages)
+      @messages = messages
+    end
+
+    def parse_structured_data(hash)
+      if hash[:yaml]
+        parsed = Psych.safe_load(hash[:yaml])
+        merge_parsed_data(parsed)
+      elsif hash[:json]
+        parsed = JSON.parse(hash[:json])
+        merge_parsed_data(parsed)
+      end
+    end
+
+    def merge_parsed_data(parsed)
+      @text ||= parsed['text'] || parsed['instructions']
+      @system ||= parsed['system']
+      @context = (@context || {}).merge(parsed['context'] || {})
+      @examples = (@examples || []).concat(parsed['examples'] || [])
+    end
+
+    def apply_options(options)
+      @system ||= options[:system]
+      validate_system_prompt(@system) if @system
+
+      @context = (@context || {}).merge(options[:context] || {})
+      @examples = (@examples || []).concat(options[:examples] || [])
+      @thinking = options[:thinking] if options[:thinking]
+      @assistant_prefill = options[:assistant_prefill] if options[:assistant_prefill]
+      @grounding = (@grounding || {}).merge(options[:grounding] || {})
+      @constraints = (@constraints || []).concat(options[:constraints] || [])
+      @output_format = options[:output_format] if options[:output_format]
+      @tone = options[:tone] if options[:tone]
+      @tools = (@tools || []).concat(options[:tools] || [])
+      @retrieval = options[:retrieval] if options[:retrieval]
+      @citation_style = options[:citation_style] if options[:citation_style]
+      @validation = options[:validation] if options[:validation]
+      @optimization = options[:optimization] if options[:optimization]
+      @documents = (@documents || []).concat(options[:documents] || [])
+      @data = options[:data] if options[:data]
+    end
+
+    def validate_messages(messages)
+      return unless messages.is_a?(Array)
+
+      validator = Artificial::Validators::MessageValidator.new(messages)
+      return if validator.valid?
+
+      raise ArgumentError, validator.error_messages.join('; ')
+    end
+
+    def validate_system_prompt(system_prompt)
+      return unless system_prompt && !system_prompt.strip.empty?
+
+      validator = Artificial::Validators::RoleValidator.new(system_prompt)
+      validator.validate
+
+      # Log suggestions but don't raise errors for effectiveness
+      if validator.optimization_suggestions.any?
+        # Could add logging here in the future
+        # puts "Role optimization suggestions: #{validator.optimization_suggestions.join('; ')}"
+      end
+
+      return if validator.valid?
+
+      raise ArgumentError, validator.error_messages.join('; ')
+    end
+
+    def generate_xml_prompt
+      doc = REXML::Document.new
+      root = doc.add_element('prompt')
+
+      # Handle message array format (conversation)
+      if @messages && !@messages.empty?
+        add_messages_section(root)
+        return output_xml(doc)
+      end
+
+      # Add long context documents first for optimization
+      add_documents_section(root) if @documents && !@documents.empty?
+
+      # Add system instructions
+      if @system
+        system_element = root.add_element('system')
+        system_element.text = @system
+      end
+
+      # Add context information
+      add_context_section(root) if @context && !@context.empty?
+
+      # Add data section (separated from instructions)
+      add_data_section(root) if @data
+
+      # Add instructions
+      if @instructions || @text
+        instructions_element = root.add_element('instructions')
+        instructions_element.text = @instructions || @text
+
+        # Add constraints
+        if @constraints && !@constraints.empty?
+          constraints_element = instructions_element.add_element('constraints')
+          @constraints.each do |constraint|
+            constraint_element = constraints_element.add_element('constraint')
+            constraint_element.text = constraint
+          end
+        end
+      end
+
+      # Add examples
+      add_examples_section(root) if @examples && !@examples.empty?
+
+      # Add thinking instructions
+      add_thinking_section(root) if @thinking && @thinking[:enabled]
+
+      # Add grounding requirements
+      add_grounding_section(root) if @grounding && !@grounding.empty?
+
+      # Add tools
+      add_tools_section(root) if @tools && !@tools.empty?
+
+      # Add retrieval configuration
+      add_retrieval_section(root) if @retrieval
+
+      # Add output formatting
+      add_output_section(root) if @output_format || @tone
+
+      # Add assistant prefill
+      if @assistant_prefill
+        prefill_element = root.add_element('assistant_prefill')
+        prefill_element.text = @assistant_prefill
+      end
+
+      # Convert to string and clean up
+      output_xml(doc)
+    end
+
+    def generate_string_prompt
+      parts = []
+
+      # Add system prompt
+      parts << "System: #{@system}" if @system
+
+      # Add context
+      if @context && !@context.empty?
+        context_parts = @context.map { |k, v| "#{k}: #{v}" }
+        parts << "Context: #{context_parts.join(', ')}"
+      end
+
+      # Add main text/instructions
+      parts << (@instructions || @text) if @instructions || @text
+
+      # Add constraints
+      parts << "Constraints: #{@constraints.join('; ')}" if @constraints && !@constraints.empty?
+
+      # Add examples
+      parts << "Examples: #{@examples.map(&:to_s).join('; ')}" if @examples && !@examples.empty?
+
+      # Add assistant prefill
+      parts << "Assistant: #{@assistant_prefill}" if @assistant_prefill
+
+      parts.join("\n\n")
+    end
+
+    def output_xml(doc)
+      output = String.new
+      doc.write(output, 0)
+      output
+    end
+
+    def add_messages_section(root)
+      messages_element = root.add_element('messages')
+      @messages.each do |message|
+        message_element = messages_element.add_element('message')
+        message_element.add_attribute('role', message[:role] || message['role'])
+        message_element.text = message[:content] || message['content']
+      end
+    end
+
+    def add_documents_section(root)
+      documents_element = root.add_element('documents')
+      @documents.each do |doc|
+        doc_element = documents_element.add_element('document')
+        if doc.is_a?(Hash)
+          doc_element.add_attribute('source', doc[:source]) if doc[:source]
+          doc_element.text = doc[:content]
+          if doc[:metadata]
+            metadata_element = doc_element.add_element('metadata')
+            doc[:metadata].each do |key, value|
+              meta_element = metadata_element.add_element(key.to_s)
+              meta_element.text = value.to_s
+            end
+          end
+        else
+          doc_element.text = doc.to_s
+        end
+      end
+    end
+
+    def add_context_section(root)
+      context_element = root.add_element('context')
+      @context.each do |key, value|
+        element = context_element.add_element(key.to_s)
+        element.text = value.to_s
+      end
+    end
+
+    def add_data_section(root)
+      data_element = root.add_element('data')
+      case @data
+      when Hash
+        @data.each do |key, value|
+          element = data_element.add_element(key.to_s)
+          element.text = value.to_s
+        end
+      else
+        data_element.text = @data.to_s
+      end
+    end
+
+    def add_examples_section(root)
+      examples_element = root.add_element('examples')
+      @examples.each do |example|
+        example_element = examples_element.add_element('example')
+        if example.is_a?(Hash)
+          if example[:input]
+            input_element = example_element.add_element('input')
+            input_element.text = example[:input].to_s
+          end
+          if example[:output]
+            output_element = example_element.add_element('output')
+            output_element.text = example[:output].to_s
+          end
+        else
+          example_element.text = example.to_s
+        end
+      end
+    end
+
+    def add_thinking_section(root)
+      thinking_element = root.add_element('thinking')
+      thinking_element.add_attribute('enabled', @thinking[:enabled].to_s)
+      thinking_element.add_attribute('style', @thinking[:style]) if @thinking[:style]
+
+      return unless @thinking[:show_reasoning]
+
+      instruction = 'Think through this step by step. Show your reasoning process.'
+      thinking_element.text = instruction
+    end
+
+    def add_grounding_section(root)
+      grounding_element = root.add_element('grounding')
+
+      if @grounding[:require_quotes]
+        require_quotes_element = grounding_element.add_element('require_quotes')
+        require_quotes_element.text = 'true'
+      end
+
+      if @grounding[:require_sources]
+        require_sources_element = grounding_element.add_element('require_sources')
+        require_sources_element.text = 'true'
+      end
+
+      return unless @grounding[:allow_uncertainty]
+
+      allow_uncertainty_element = grounding_element.add_element('allow_uncertainty')
+      allow_uncertainty_element.text = 'true'
+    end
+
+    def add_tools_section(root)
+      tools_element = root.add_element('tools')
+      @tools.each do |tool|
+        tool_element = tools_element.add_element('tool')
+        if tool.is_a?(Hash)
+          tool_element.add_attribute('name', tool[:name]) if tool[:name]
+          if tool[:parameters]
+            params_element = tool_element.add_element('parameters')
+            tool[:parameters].each do |key, value|
+              param_element = params_element.add_element(key.to_s)
+              param_element.text = value.to_s
+            end
+          end
+        else
+          tool_element.text = tool.to_s
+        end
+      end
+    end
+
+    def add_retrieval_section(root)
+      retrieval_element = root.add_element('retrieval')
+
+      if @retrieval[:sources]
+        sources_element = retrieval_element.add_element('sources')
+        @retrieval[:sources].each do |source|
+          source_element = sources_element.add_element('source')
+          source_element.text = source
+        end
+      end
+
+      retrieval_element.add_attribute('max_results', @retrieval[:max_results].to_s) if @retrieval[:max_results]
+      return unless @retrieval[:similarity_threshold]
+
+      retrieval_element.add_attribute('similarity_threshold',
+                                      @retrieval[:similarity_threshold].to_s)
+    end
+
+    def add_output_section(root)
+      output_element = root.add_element('output')
+      output_element.add_attribute('format', @output_format) if @output_format
+      output_element.add_attribute('tone', @tone) if @tone
+    end
+  end
+end