poml 0.0.1

data/lib/poml/context.rb

@@ -0,0 +1,53 @@
+require 'json'
+
+module Poml
+  # Context object that holds variables, stylesheets, and processing state
+  class Context
+    attr_accessor :variables, :stylesheet, :chat, :texts, :source_path, :syntax, :header_level
+
+    def initialize(variables: {}, stylesheet: nil, chat: true, syntax: nil)
+      @variables = variables || {}
+      @stylesheet = parse_stylesheet(stylesheet)
+      @chat = chat
+      @texts = {}
+      @source_path = nil
+      @syntax = syntax
+      @header_level = 1 # Track current header nesting level
+    end
+
+    def xml_mode?
+      @syntax == 'xml'
+    end
+
+    def determine_syntax(element)
+      # Check if element or parent has syntax specified
+      element_syntax = element.attributes['syntax'] if element.respond_to?(:attributes)
+      element_syntax || @syntax || 'markdown'
+    end
+
+    def with_increased_header_level
+      old_level = @header_level
+      @header_level += 1
+      yield
+    ensure
+      @header_level = old_level
+    end
+
+    private
+
+    def parse_stylesheet(stylesheet)
+      case stylesheet
+      when Hash
+        stylesheet
+      when String
+        JSON.parse(stylesheet)
+      when nil
+        {}
+      else
+        {}
+      end
+    rescue JSON::ParserError
+      {}
+    end
+  end
+end

data/lib/poml/parser.rb

@@ -0,0 +1,153 @@
+require 'rexml/document'
+
+module Poml
+  # Element represents a parsed POML element
+  class Element
+    attr_accessor :tag_name, :attributes, :content, :children
+
+    def initialize(tag_name:, attributes: {}, content: '', children: [])
+      @tag_name = tag_name
+      @attributes = attributes || {}
+      @content = content || ''
+      @children = children || []
+    end
+
+    def text?
+      @tag_name == :text
+    end
+
+    def component?
+      !text?
+    end
+  end
+
+  # Parser for POML markup
+  class Parser
+    def initialize(context)
+      @context = context
+      @template_engine = TemplateEngine.new(context)
+    end
+
+    def parse(content)
+      # Handle escape characters
+      content = unescape_poml(content)
+      
+      # Remove XML comments but preserve surrounding whitespace
+      content = content.gsub(/(\s*)<!--.*?-->(\s*)/m) do |match|
+        before_space = $1
+        after_space = $2
+        # Preserve the original spacing pattern, but normalize to a single space if there was whitespace
+        if before_space.length > 0 || after_space.length > 0
+          ' '
+        else
+          ''
+        end
+      end
+      
+      # Apply template substitutions
+      content = @template_engine.substitute(content)
+
+      # Check if content is wrapped in <poml> tags and extract syntax
+      content = content.strip
+      if content =~ /\A<poml\b([^>]*)?>(.*)<\/poml>\s*\z/m
+        poml_attributes = $1
+        content = $2
+        
+        # Extract syntax attribute if present
+        if poml_attributes && poml_attributes =~ /syntax\s*=\s*["']([^"']+)["']/
+          @context.syntax = $1
+        end
+      end
+
+      # Pre-process stylesheets before parsing other components
+      preprocess_stylesheets(content)
+
+      # Parse as XML with whitespace preservation
+      begin
+        doc = REXML::Document.new("<root>#{content}</root>")
+        # Preserve whitespace in text nodes
+        doc.context[:ignore_whitespace_nodes] = :none
+        parse_element(doc.root)
+      rescue => e
+        # If XML parsing fails, treat as plain text
+        puts "XML parsing failed: #{e.message}" if defined?(DEBUG)
+        [Element.new(tag_name: :text, content: content)]
+      end
+    end
+
+    private
+
+    def parse_element(xml_element)
+      elements = []
+
+      xml_element.children.each do |child|
+        case child
+        when REXML::Text
+          text_content = child.to_s
+          next if text_content.strip.empty?  # Only skip if completely empty when stripped
+          
+          # Check if the content (after removing newlines) ends with a space
+          content_no_newlines = text_content.gsub(/\n/, ' ')
+          preserves_trailing_space = content_no_newlines.rstrip != content_no_newlines
+          
+          # Normalize the text: strip leading/trailing whitespace 
+          normalized = text_content.strip
+          
+          # Add back trailing space if it was significant (i.e., there was a space before newlines)
+          normalized += ' ' if preserves_trailing_space
+          
+          next if normalized.empty?
+          elements << Element.new(tag_name: :text, content: normalized)
+        when REXML::Element
+          # Convert REXML attributes to string hash
+          attrs = {}
+          child.attributes.each do |name, value|
+            attrs[name.downcase] = value.to_s
+          end
+          
+          elements << Element.new(
+            tag_name: child.name.downcase.to_sym,
+            attributes: attrs,
+            content: extract_text_content(child),
+            children: parse_element(child)
+          )
+        end
+      end
+
+      elements
+    end
+
+    def extract_text_content(xml_element)
+      # Extract direct text content (not from child elements)
+      text_nodes = xml_element.children.select { |child| child.is_a?(REXML::Text) }
+      text_nodes.map(&:to_s).join('').strip
+    end
+
+    def unescape_poml(text)
+      # Handle POML escape characters
+      text.gsub(/#quot;/, '"')
+          .gsub(/#apos;/, "'")
+          .gsub(/#amp;/, '&')
+          .gsub(/#lt;/, '<')
+          .gsub(/#gt;/, '>')
+          .gsub(/#hash;/, '#')
+          .gsub(/#lbrace;/, '{')
+          .gsub(/#rbrace;/, '}')
+    end
+    
+    def preprocess_stylesheets(content)
+      # Extract and process stylesheet elements before main parsing
+      content.scan(/<stylesheet\b[^>]*>(.*?)<\/stylesheet>/m) do |stylesheet_content|
+        begin
+          stylesheet_text = stylesheet_content[0].strip
+          if stylesheet_text.start_with?('{') && stylesheet_text.end_with?('}')
+            stylesheet = JSON.parse(stylesheet_text)
+            @context.stylesheet.merge!(stylesheet) if stylesheet.is_a?(Hash)
+          end
+        rescue => e
+          # Silently fail JSON parsing errors
+        end
+      end
+    end
+  end
+end

data/lib/poml/renderer.rb

@@ -0,0 +1,147 @@
+require 'json'
+
+module Poml
+  # Renderer converts parsed POML elements to various output formats
+  class Renderer
+    def initialize(context)
+      @context = context
+    end
+
+    def render(elements, format = 'dict')
+      case format
+      when 'raw'
+        render_raw(elements)
+      when 'dict'
+        render_dict(elements)
+      when 'openai_chat'
+        render_openai_chat(elements)
+      when 'langchain'
+        render_langchain(elements)
+      when 'pydantic'
+        render_pydantic(elements)
+      else
+        raise Error, "Unknown format: #{format}"
+      end
+    end
+
+    private
+
+    def render_raw(elements)
+      content = elements.map { |element| Components.render_element(element, @context) }.join('')
+      
+      # For raw format, wrap in message boundaries like Python package does
+      if @context.chat && !content.strip.empty?
+        # Determine if this should be system or human message
+        # If it contains role/task/instructions, it's typically a system message
+        # Otherwise, it's a human message
+        message_type = determine_message_type(elements)
+        "===== #{message_type} =====\n\n#{content.strip}\n"
+      else
+        content
+      end
+    end
+
+    def render_dict(elements)
+      {
+        'content' => render_raw(elements),
+        'metadata' => {
+          'chat' => @context.chat,
+          'stylesheet' => @context.stylesheet,
+          'variables' => @context.variables
+        }
+      }
+    end
+
+    def render_openai_chat(elements)
+      content = render_raw(elements)
+      if @context.chat
+        parse_chat_messages(content)
+      else
+        [{ 'role' => 'user', 'content' => content }]
+      end
+    end
+
+    def render_langchain(elements)
+      content = render_raw(elements)
+      {
+        'messages' => render_openai_chat(elements),
+        'content' => content
+      }
+    end
+
+    def render_pydantic(elements)
+      # Simplified pydantic-like structure
+      {
+        'prompt' => render_raw(elements),
+        'variables' => @context.variables,
+        'chat_enabled' => @context.chat
+      }
+    end
+
+    def parse_chat_messages(content)
+      # Simplified chat message parsing
+      # In a full implementation, this would be more sophisticated
+      messages = []
+      current_role = 'user'
+      current_content = ''
+
+      content.split(/\n\n+/).each do |section|
+        section = section.strip
+        next if section.empty?
+
+        # Simple heuristic: if section starts with certain patterns, it might be assistant content
+        if section.start_with?('**Output:**', '**Assistant:**', 'Response:')
+          if !current_content.empty?
+            messages << { 'role' => current_role, 'content' => current_content.strip }
+          end
+          current_role = 'assistant'
+          current_content = section.gsub(/^\*\*(Output|Assistant):\*\*\s*/, '').gsub(/^Response:\s*/, '')
+        else
+          current_content += (current_content.empty? ? '' : "\n\n") + section
+        end
+      end
+
+      if !current_content.empty?
+        messages << { 'role' => current_role, 'content' => current_content.strip }
+      end
+
+      messages.empty? ? [{ 'role' => 'user', 'content' => content }] : messages
+    end
+
+    def determine_message_type(elements)
+      # Extract tag names from elements
+      tag_names = elements.map(&:tag_name).compact
+      
+      # Check for system-oriented components
+      has_role = tag_names.include?(:role)
+      has_task = tag_names.include?(:task)
+      has_hint = tag_names.include?(:hint)
+      
+      # Check for human-oriented components or content that suggests user interaction
+      has_document = tag_names.include?(:document) || tag_names.include?('Document')
+      has_question_content = elements.any? { |el| 
+        el.respond_to?(:content) && el.content&.match?(/\b(what|how|why|when|where|please|can you)\b/i)
+      }
+      
+      # System message detection rules based on original TypeScript implementation:
+      # 1. If it's only role/task/hint components → system message
+      # 2. If it has role AND task → system message (instruction setup)
+      # 3. If it has role but also user interaction content → human message
+      # 4. If it has document import or question-like content → human message
+      
+      if has_role && has_task
+        # Role + Task = system instruction setup
+        'system'
+      elsif has_role && !has_document && !has_question_content && tag_names.all? { |tag| [:role, :task, :hint, :text, :p].include?(tag) }
+        # Pure role/task/hint setup without user content
+        'system'
+      elsif has_document || has_question_content
+        # Document import or question-like content = human message
+        'human'
+      else
+        # Default to human for mixed or ambiguous content
+        'human'
+      end
+    end
+  end
+end

data/lib/poml/template_engine.rb

@@ -0,0 +1,66 @@
+module Poml
+  # Template engine for handling {{variable}} substitutions
+  class TemplateEngine
+    def initialize(context)
+      @context = context
+    end
+
+    def substitute(text)
+      return text unless text.is_a?(String)
+      
+      # Handle {{variable}} substitutions
+      text.gsub(/\{\{(.+?)\}\}/) do |match|
+        expression = $1.strip
+        evaluate_expression(expression)
+      end
+    end
+
+    private
+
+    def evaluate_expression(expression)
+      # Handle dot notation and arithmetic expressions
+      
+      # Simple arithmetic operations like loop.index+1
+      if expression =~ /^(\w+(?:\.\w+)*)\s*\+\s*(\d+)$/
+        variable_path = $1
+        increment = $2.to_i
+        
+        value = get_nested_variable(variable_path)
+        if value.is_a?(Numeric)
+          (value + increment).to_s
+        else
+          "{{#{expression}}}"
+        end
+      elsif expression =~ /^(\w+(?:\.\w+)*)$/
+        # Simple variable or dot notation lookup
+        variable_path = $1
+        value = get_nested_variable(variable_path)
+        value ? value.to_s : "{{#{expression}}}"
+      elsif @context.variables.key?(expression)
+        # Direct variable lookup (backward compatibility)
+        @context.variables[expression].to_s
+      else
+        # Return original expression if not found
+        "{{#{expression}}}"
+      end
+    end
+    
+    def get_nested_variable(path)
+      # Handle dot notation like "loop.index"
+      parts = path.split('.')
+      value = @context.variables
+      
+      parts.each do |part|
+        if value.is_a?(Hash) && value.key?(part)
+          value = value[part]
+        elsif value.is_a?(Hash) && value.key?(part.to_sym)
+          value = value[part.to_sym]
+        else
+          return nil
+        end
+      end
+      
+      value
+    end
+  end
+end

data/lib/poml/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Poml
+  VERSION = "0.0.1"
+end

data/lib/poml.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "poml/version"
+require_relative 'poml/context'
+require_relative 'poml/parser'
+require_relative 'poml/renderer'
+require_relative 'poml/components'
+require_relative 'poml/template_engine'
+
+module Poml
+  class Error < StandardError; end
+
+  # Main entry point for processing POML files
+  # Parameters:
+  # - markup: POML file path or string content
+  # - context: Hash of variables for template substitution
+  # - stylesheet: Optional stylesheet as string or hash
+  # - chat: Boolean indicating chat format (default: true)
+  # - output_file: Path to save output (optional)
+  # - format: 'raw', 'dict', 'openai_chat', 'langchain', 'pydantic' (default: 'dict')
+  # - extra_args: Array of extra CLI args (ignored in pure Ruby implementation)
+  def self.process(markup:, context: nil, stylesheet: nil, chat: true, output_file: nil, format: 'dict', extra_args: [])
+    # Create POML context
+    poml_context = Context.new(
+      variables: context || {},
+      stylesheet: stylesheet,
+      chat: chat
+    )
+
+    # Read markup content and set source path
+    content = if File.exist?(markup.to_s)
+      poml_context.source_path = File.expand_path(markup.to_s)
+      File.read(markup)
+    else
+      markup.to_s
+    end
+
+    # Parse POML content
+    parser = Parser.new(poml_context)
+    parsed_elements = parser.parse(content)
+
+    # Render to the desired format
+    renderer = Renderer.new(poml_context)
+    result = renderer.render(parsed_elements, format)
+
+    # Save to file if specified
+    if output_file
+      File.write(output_file, result)
+    end
+
+    result
+  end
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: poml
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ghennadii Mirosnicenco
+bindir: bin
+cert_chain: []
+date: 2025-08-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rexml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+description: "POML is a Ruby gem that implements POML (Prompt Oriented Markup Language),
+  \na markup language for structured prompt engineering. This is a Ruby port of \nthe
+  original Microsoft POML library, providing comprehensive tools for creating, \nprocessing,
+  and rendering structured prompts with support for multiple output \nformats including
+  OpenAI Chat, LangChain, and Pydantic.\n"
+email:
+- linkator7@gmail.com
+executables:
+- poml
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- TUTORIAL.md
+- bin/poml
+- examples/101_explain_character.poml
+- examples/102_render_xml.poml
+- examples/103_word_todos.poml
+- examples/104_financial_analysis.poml
+- examples/105_write_blog_post.poml
+- examples/106_research.poml
+- examples/107_read_report_pdf.poml
+- examples/201_orders_qa.poml
+- examples/202_arc_agi.poml
+- examples/301_generate_poml.poml
+- examples/README.md
+- examples/_generate_expects.py
+- examples/assets/101_jerry_mouse.jpg
+- examples/assets/101_tom_and_jerry.docx
+- examples/assets/101_tom_cat.jpg
+- examples/assets/101_tom_introduction.txt
+- examples/assets/103_prompt_wizard.docx
+- examples/assets/104_chart_normalized_price.png
+- examples/assets/104_chart_price.png
+- examples/assets/104_mag7.xlsx
+- examples/assets/107_usenix_paper.pdf
+- examples/assets/201_order_instructions.json
+- examples/assets/201_orderlines.csv
+- examples/assets/201_orders.csv
+- examples/assets/202_arc_agi_data.json
+- examples/expects/101_explain_character.txt
+- examples/expects/102_render_xml.txt
+- examples/expects/103_word_todos.txt
+- examples/expects/104_financial_analysis.txt
+- examples/expects/105_write_blog_post.txt
+- examples/expects/106_research.txt
+- examples/expects/107_read_report_pdf.txt
+- examples/expects/201_orders_qa.txt
+- examples/expects/202_arc_agi.txt
+- examples/expects/301_generate_poml.txt
+- examples/ruby_expects/101_explain_character.txt
+- examples/ruby_expects/102_render_xml.txt
+- examples/ruby_expects/103_word_todos.txt
+- examples/ruby_expects/104_financial_analysis.txt
+- examples/ruby_expects/105_write_blog_post.txt
+- examples/ruby_expects/106_research.txt
+- examples/ruby_expects/107_read_report_pdf.txt
+- examples/ruby_expects/201_orders_qa.txt
+- examples/ruby_expects/202_arc_agi.txt
+- examples/ruby_expects/301_generate_poml.txt
+- lib/poml.rb
+- lib/poml/components.rb
+- lib/poml/components/base.rb
+- lib/poml/components/content.rb
+- lib/poml/components/data.rb
+- lib/poml/components/examples.rb
+- lib/poml/components/instructions.rb
+- lib/poml/components/layout.rb
+- lib/poml/components/lists.rb
+- lib/poml/components/styling.rb
+- lib/poml/components/text.rb
+- lib/poml/components/workflow.rb
+- lib/poml/components_new.rb
+- lib/poml/components_old.rb
+- lib/poml/context.rb
+- lib/poml/parser.rb
+- lib/poml/renderer.rb
+- lib/poml/template_engine.rb
+- lib/poml/version.rb
+- media/logo-16-purple.png
+- media/logo-64-white.png
+homepage: https://github.com/GhennadiiMir/poml
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/GhennadiiMir/poml
+  source_code_uri: https://github.com/GhennadiiMir/poml
+  documentation_uri: https://github.com/GhennadiiMir/poml/blob/main/TUTORIAL.md
+  bug_tracker_uri: https://github.com/GhennadiiMir/poml/issues
+  changelog_uri: https://github.com/GhennadiiMir/poml/releases
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.5
+specification_version: 4
+summary: Ruby implementation of POML (Prompt Oriented Markup Language)
+test_files: []