poml 0.0.6 → 0.0.8

data/lib/poml/components/meta.rb

@@ -31,9 +31,9 @@ module Poml
     
     def handle_typed_meta(type)
       case type.downcase
-      when 'responseschema', 'response_schema'
+      when 'responseschema', 'response_schema', 'output-schema', 'output_schema'
         handle_response_schema
-      when 'tool'
+      when 'tool', 'tool-definition', 'tooldefinition'
         handle_tool_registration
       when 'runtime'
         handle_runtime_parameters
@@ -115,6 +115,29 @@ module Poml
         
         # Store the schema directly for simplicity
         @context.response_schema = schema
+        
+        # Also store for backward compatibility with tests that expect schemas array
+        # If the parsed JSON contains a name field, use the entire schema as-is
+        # Otherwise wrap it in a metadata structure
+        if schema.is_a?(Hash) && schema.key?('name')
+          @context.response_schema_with_metadata = schema
+        else
+          schema_with_metadata = {
+            'schema' => schema
+          }
+          
+          # Add name if provided as attribute
+          if _name
+            schema_with_metadata['name'] = _name
+          end
+          
+          # Add description if provided as attribute
+          if _description
+            schema_with_metadata['description'] = _description
+          end
+          
+          @context.response_schema_with_metadata = schema_with_metadata
+        end
       end
     end
     
@@ -143,6 +166,11 @@ module Poml
         nil
       end
       
+      # Apply enhanced tool registration features
+      if schema
+        schema = apply_tool_enhancements(schema)
+      end
+      
       if schema
         @context.tools ||= []
         
@@ -150,10 +178,14 @@ module Poml
         if name
           tool_def = {
             'name' => name,
-            'description' => description
+            'description' => description,
+            'schema' => schema.is_a?(String) ? schema : JSON.generate(schema)
           }
-          # Merge in the parsed schema (should include parameters, etc.)
-          tool_def.merge!(schema) if schema.is_a?(Hash)
+          
+          # Merge in the parsed schema for backward compatibility
+          if schema.is_a?(Hash)
+            tool_def.merge!(schema)
+          end
         elsif schema.is_a?(Hash) && schema['name']
           # If the schema contains the full tool definition, use it directly
           tool_def = schema
@@ -190,6 +222,11 @@ module Poml
         nil
       end
       
+      # Apply enhanced tool registration features
+      if schema
+        schema = apply_tool_enhancements(schema)
+      end
+      
       if schema
         @context.tools ||= []
         # Store tool with string keys for JSON compatibility
@@ -312,5 +349,97 @@ module Poml
         end
       end
     end
+    
+    # Apply enhanced tool registration features
+    def apply_tool_enhancements(schema)
+      return schema unless schema.is_a?(Hash)
+      
+      # Apply parameter key conversion and runtime type conversion
+      enhanced_schema = convert_parameter_keys(schema)
+      enhanced_schema = apply_runtime_parameter_conversion(enhanced_schema)
+      enhanced_schema
+    end
+    
+    # Convert kebab-case keys to camelCase recursively
+    def convert_parameter_keys(obj)
+      case obj
+      when Hash
+        converted = {}
+        obj.each do |key, value|
+          # Convert kebab-case to camelCase
+          new_key = kebab_to_camel_case(key.to_s)
+          
+          # Special handling for 'required' array
+          if key == 'required' && value.is_a?(Array)
+            converted[new_key] = value.map { |req_key| kebab_to_camel_case(req_key.to_s) }
+          else
+            converted[new_key] = convert_parameter_keys(value)
+          end
+        end
+        converted
+      when Array
+        obj.map { |item| convert_parameter_keys(item) }
+      else
+        obj
+      end
+    end
+    
+    # Convert kebab-case string to camelCase
+    def kebab_to_camel_case(str)
+      # Split on hyphens and convert to camelCase
+      parts = str.split('-')
+      return str if parts.length == 1  # No conversion needed
+      
+      parts[0] + parts[1..-1].map(&:capitalize).join
+    end
+    
+    # Apply runtime parameter type conversion
+    def apply_runtime_parameter_conversion(schema)
+      return schema unless schema.is_a?(Hash)
+      
+      converted = schema.dup
+      
+      # Process properties if they exist
+      if converted['properties'].is_a?(Hash)
+        converted['properties'] = converted['properties'].map do |key, prop|
+          [key, convert_property_value(prop)]
+        end.to_h
+      end
+      
+      converted
+    end
+    
+    # Convert individual property values based on 'convert' attribute
+    def convert_property_value(property)
+      return property unless property.is_a?(Hash) && property['convert']
+      
+      converted_prop = property.dup
+      convert_value = property['convert']
+      prop_type = property['type']
+      
+      begin
+        case prop_type
+        when 'boolean'
+          # Convert various truthy/falsy values to boolean
+          case convert_value.to_s.downcase
+          when 'true', '1', 'yes', 'on'
+            # Keep the convert attribute for now but could be removed
+          when 'false', '0', 'no', 'off'
+            # Keep the convert attribute for now but could be removed
+          end
+        when 'number'
+          # Validate that the value can be converted to a number
+          Float(convert_value) # This will raise an exception if invalid
+        when 'object', 'array'
+          # Validate that the value is valid JSON
+          JSON.parse(convert_value) # This will raise an exception if invalid
+        end
+      rescue StandardError
+        # If conversion fails, remove the convert attribute silently
+        converted_prop.delete('convert')
+      end
+      
+      converted_prop
+    end
   end
 end

data/lib/poml/components/output_schema.rb

@@ -33,9 +33,27 @@ module Poml
         if @context.response_schema
           raise Poml::Error, "Multiple output-schema elements are not allowed. Only one response schema per document is supported."
         end
+
+        # Store the schema with metadata structure expected by tests
+        schema_with_metadata = {
+          'schema' => schema
+        }
+        
+        # Add name if provided
+        if _name
+          schema_with_metadata['name'] = _name
+        end
         
-        # Store the schema directly for simplicity
+        # Add description if provided
+        if _description
+          schema_with_metadata['description'] = _description
+        end
+        
+        # Store the schema directly for simplicity (this is what the renderer uses for response_schema)
         @context.response_schema = schema
+        
+        # Also store the structured version for the schemas array
+        @context.response_schema_with_metadata = schema_with_metadata
       end
       
       # Meta-like components don't produce output

data/lib/poml/components/template.rb

@@ -24,12 +24,18 @@ module Poml
       # Handle both raw variable names and template expressions
       condition = condition.strip
       
+      # Check for negation operator at the beginning
+      negate = false
+      if condition.start_with?('!')
+        negate = true
+        condition = condition[1..-1].strip
+      end
+      
       # First, substitute any template variables in the condition
       substituted_condition = @context.template_engine.substitute(condition)
       
-      # If it's a template expression, it may have been pre-substituted
-      # If condition looks like a substituted value, try to parse it
-      case substituted_condition
+      # Evaluate the condition
+      result = case substituted_condition
       when 'true'
         true
       when 'false'
@@ -47,13 +53,13 @@ module Poml
         # Perform comparison
         case operator
         when '>'
-          left_value > right_value
+          compare_values(left_value, right_value, :>)
         when '<'
-          left_value < right_value
+          compare_values(left_value, right_value, :<)
         when '>='
-          left_value >= right_value
+          compare_values(left_value, right_value, :>=)
         when '<='
-          left_value <= right_value
+          compare_values(left_value, right_value, :<=)
         when '=='
           left_value == right_value
         when '!='
@@ -71,12 +77,20 @@ module Poml
         result = @context.template_engine.evaluate_attribute_expression(substituted_condition)
         convert_to_boolean(result)
       end
+      
+      # Apply negation if needed
+      negate ? !result : result
     end
     
     def convert_operand(operand)
       # First substitute any template variables
       substituted = @context.template_engine.substitute(operand)
       
+      # Handle quoted strings
+      if substituted =~ /^['"](.*)['"]$/
+        return $1
+      end
+      
       # Try to convert to number if possible, otherwise keep as string
       if substituted =~ /^-?\d+$/
         substituted.to_i
@@ -87,6 +101,16 @@ module Poml
       end
     end
     
+    def compare_values(left, right, operator)
+      # Handle type mismatches gracefully
+      begin
+        left.send(operator, right)
+      rescue ArgumentError
+        # If types are incompatible, try to convert both to strings and compare
+        left.to_s.send(operator, right.to_s)
+      end
+    end
+    
     def convert_to_boolean(result)
       case result
       when true, false
@@ -117,25 +141,42 @@ module Poml
       items = evaluate_items(items_expr)
       return '' unless items.is_a?(Array)
       
-      # Store original content of elements to avoid mutation
-      original_contents = store_original_contents(@element)
-      
-      # Render content for each item
+      # Render content for each item without mutating original elements
       results = []
       items.each_with_index do |item, index|
-        # Restore original content before each iteration
-        restore_original_contents(@element, original_contents)
-        
         # Create child context with loop variable
         child_context = @context.create_child_context
         child_context.variables[variable] = item
         child_context.variables['loop'] = { 'index' => index + 1 }  # 1-based index
         
-        # Render children with loop variable substitution
+        # Update template engine context to use new variables
+        child_context.template_engine = Poml::TemplateEngine.new(child_context)
+        
+        # Ensure list index is synchronized with parent context
+        if @context.instance_variable_get(:@list_style)
+          # Copy current list index from parent to child before processing
+          current_list_index = @context.instance_variable_get(:@list_index) || 0
+          child_context.instance_variable_set(:@list_index, current_list_index)
+        end
+        
+        # Process each child element in the child context
         item_content = @element.children.map do |child|
-          render_element_with_substitution(child, child_context)
+          # Create a deep copy of the child element to avoid mutations
+          child_copy = deep_copy_element(child)
+          
+          # Process templates in the copied element
+          process_templates_in_element(child_copy, child_context)
+          
+          # Render the processed element
+          Components.render_element(child_copy, child_context)
         end.join('')
         
+        # Update parent context with the list index from child context
+        if @context.instance_variable_get(:@list_style)
+          updated_list_index = child_context.instance_variable_get(:@list_index)
+          @context.instance_variable_set(:@list_index, updated_list_index)
+        end
+        
         results << item_content
       end
       
@@ -144,63 +185,33 @@ module Poml
     
     private
     
-    def store_original_contents(element)
-      contents = {}
-      contents[element.object_id] = element.content.dup if element.content
-      
-      element.children.each do |child|
-        contents.merge!(store_original_contents(child))
-      end
-      
-      contents
+    def deep_copy_element(element)
+      # Create a new element with the same properties
+      Element.new(
+        tag_name: element.tag_name,
+        attributes: element.attributes.dup,
+        content: element.content.dup,
+        children: element.children.map { |child| deep_copy_element(child) }
+      )
     end
     
-    def restore_original_contents(element, original_contents)
-      if original_contents[element.object_id]
-        element.content = original_contents[element.object_id].dup
-      end
-      
-      element.children.each do |child|
-        restore_original_contents(child, original_contents)
-      end
-    end
-    
-    private
-    
-    def render_element_with_substitution(element, context)
-      # First substitute in the element's own content if it has template variables
+    def process_templates_in_element(element, context)
+      # Process template variables in the element's content
       if element.content && element.content.include?('{{')
         element.content = context.template_engine.substitute(element.content)
       end
       
-      # If this is a text element, return substituted content directly
-      if element.tag_name == :text
-        return element.content
-      end
-      
-      # For non-text elements, recursively substitute in their children
-      substitute_in_element(element, context)
-      Components.render_element(element, context)
-    end
-    
-    def substitute_in_element(element, context)
-      # Substitute in the element's own content
-      if element.content && element.content.include?('{{')
-        element.content = context.template_engine.substitute(element.content)
-      end
-      
-      # Recursively substitute variables in children
+      # Recursively process templates in children
       element.children.each do |child|
-        if child.tag_name == :text && child.content.include?('{{')
+        # For text elements, process their content directly
+        if child.tag_name == :text && child.content && child.content.include?('{{')
           child.content = context.template_engine.substitute(child.content)
-        else
-          substitute_in_element(child, context)
         end
+        
+        process_templates_in_element(child, context)
       end
     end
     
-    private
-    
     def evaluate_items(items_expr)
       # Handle both raw variable names and template expressions
       items_expr = items_expr.strip

data/lib/poml/components/text.rb

@@ -2,7 +2,36 @@ module Poml
   # Text component for plain text content
   class TextComponent < Component
     def render
-      @element.content
+      # If there are child elements, render them; otherwise return the content
+      if @element.children.empty?
+        # Apply template substitution to text content
+        @context.template_engine.substitute(@element.content)
+      else
+        render_children
+      end
+    end
+  end
+
+  # Unknown component handler - preserves tag name and content for debugging
+  class UnknownComponent < Component
+    def render
+      apply_stylesheet
+      
+      tag_name = @element.tag_name.to_s
+      content = @element.children.empty? ? @element.content : render_children
+      
+      # Apply template substitution to content
+      if content.is_a?(String)
+        content = @context.template_engine.substitute(content)
+      end
+      
+      if xml_mode?
+        # In XML mode, preserve the original tag
+        render_as_xml(tag_name, content)
+      else
+        # In text mode, include both tag name and content for debugging
+        "#{tag_name}: #{content}"
+      end
     end
   end
 end

data/lib/poml/components/tool.rb

@@ -0,0 +1,81 @@
+module Poml
+  # Tool component for declarative tool definition
+  class ToolComponent < Component
+    def render
+      name = get_attribute('name')
+      return '' unless name
+      
+      # Build tool definition from declarative syntax
+      tool_def = {
+        'name' => name,
+        'description' => extract_description,
+        'parameters' => extract_parameters
+      }
+      
+      # Register the tool
+      @context.tools ||= []
+      @context.tools << tool_def
+      
+      # Tools components don't produce output by default
+      ''
+    end
+    
+    private
+    
+    def extract_description
+      description_element = @element.children.find { |child| child.name == 'description' }
+      return description_element&.content&.strip if description_element
+      
+      # Fallback to description attribute
+      get_attribute('description') || ''
+    end
+    
+    def extract_parameters
+      parameter_elements = @element.children.select { |child| child.name == 'parameter' }
+      
+      if parameter_elements.empty?
+        # If no parameter elements, return empty object structure
+        return {
+          'type' => 'object',
+          'properties' => {},
+          'required' => []
+        }
+      end
+      
+      properties = {}
+      required = []
+      
+      parameter_elements.each do |param_element|
+        param_name = param_element.attributes['name']
+        next unless param_name
+        
+        param_type = param_element.attributes['type'] || 'string'
+        param_required = param_element.attributes['required']
+        param_description = param_element.content&.strip
+        
+        # If the parameter has a description child element, use that instead
+        description_child = param_element.children.find { |child| child.name == 'description' }
+        if description_child
+          param_description = description_child.content&.strip
+        end
+        
+        properties[param_name] = {
+          'type' => param_type
+        }
+        
+        properties[param_name]['description'] = param_description if param_description && !param_description.empty?
+        
+        # Handle required flag
+        if param_required == 'true' || param_required == true
+          required << param_name
+        end
+      end
+      
+      {
+        'type' => 'object',
+        'properties' => properties,
+        'required' => required
+      }
+    end
+  end
+end