mdphlex 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30fde45581cd7d2edeada97dd0c281cbf4bf6447e6938f5002ad99231c4ac2f0
-  data.tar.gz: 1168f4d22457f7965160e4248f468d7bce4e0a45eb56a44b6285cb3aebe94d83
+  metadata.gz: df56be38ad404b1762ae330d4f59f21de2ab56ed0248688a8134890f61f407e7
+  data.tar.gz: 4bde2036075332276a3d3882cdabf931c97be472f67612a72c82a7cb513607be
 SHA512:
-  metadata.gz: 8aab63e64b863d0fdba508d8e9d2a570eb7b8bc8d9c11081cf4b8718a9c06365a6069df65024a2c868efd6bc60e1163f4adf20251f220f7c63d0d6d4b4ffd05b
-  data.tar.gz: 66efd4524781b9fcc52568879f352285db7477f078039c40f1c209c09e13d63c3dc0c24f95c20876839203a68982d79166bf125d54abe4017dc6c9c3c2008e69
+  metadata.gz: c8835c134e433334f033dc01dc8614476dd281c2c2be6223cb5dda92dabebdcad101bb1d2bb6f3806a6c792bd69b8a639410739ce417cf6fee90d81930191ee5
+  data.tar.gz: db3062396e99e68aa12ffbbe3c950fbf83c1e8549a88b6d6e0b289d4b39791975fd5ff7be99f983eb4a9fd2658bcacdcb6095053e3d5420807e1a49a2aef96cb

data/README.md

@@ -1,74 +1,152 @@
 # MDPhlex
 
-MDPhlex is a Phlex component for rendering Markdown. Write your Markdown in Ruby with Phlex's familiar syntax and render it as a Markdown string.
+> Inversion of Markdown
+
+MDPhlex is a Phlex component for rendering Markdown. No... not rendering markdown into HTML, rendering plain Markdown, programmatically.
+
+MDPhlex is perfect for dynamically creating context for LLMs, generating an llms.txt file from real content, or doing something silly like passing the output to a markdown renderer to create HTML or generating blog posts that look like they were hand-written markdown.
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
-```ruby
+~~~ruby
 gem 'mdphlex'
-```
+~~~
 
-## Basic Usage
+## Creating LLM Prompts with MDPhlex
 
-Create an MDPhlex::MD component just like you would create a Phlex component:
+MDPhlex shines when creating structured prompts for LLMs. Here's a simple example using custom tags:
+
+~~~ruby
+class LLMPrompt < MDPhlex::MD
+  # Register custom elements for structured prompts
+  register_block_element :system
+  register_block_element :tools
+  register_block_element :tool
+
+  def initialize(task:, tools: [])
+    @task = task
+    @tools = tools
+  end
 
-```ruby
-class HelloWorld < MDPhlex::MD
   def view_template
-    h1 "Hello, World!"
+    system do
+      plain "You are an AI assistant specialized in #{@task}."
+      plain "\nUse the available tools to help users effectively."
+    end
+
+    plain "\n"
+
+    if @tools.any?
+      tools do
+        @tools.each do |tool_def|
+          tool name: tool_def[:name] do
+            plain tool_def[:description]
+          end
+        end
+      end
+    end
+  end
+end
+
+# Dynamic prompt generation
+prompt = LLMPrompt.new(
+  task: "Ruby code analysis",
+  tools: [
+    { name: "analyze_code", description: "Analyze Ruby code for improvements" },
+    { name: "explain_concept", description: "Explain Ruby concepts and patterns" }
+  ]
+)
 
-    p "Welcome to MDPhlex - writing Markdown with Phlex syntax!"
+puts prompt.call
+~~~
 
-    h2 "Features"
+This outputs clean, structured markdown perfect for LLMs:
 
-    ul do
-      li "Write Markdown using Ruby"
-      li do
-        plain "Support for "
-        strong "bold"
-        plain ", "
-        em "italic"
-        plain ", and "
-        code "inline code"
+~~~xml
+<system>
+You are an AI assistant specialized in Ruby code analysis.
+Use the available tools to help users effectively.</system>
+
+<tools>
+<tool name="analyze_code">
+Analyze Ruby code for improvements</tool>
+<tool name="explain_concept">
+Explain Ruby concepts and patterns</tool>
+</tools>
+~~~
+
+The XML-style tags help LLMs understand different sections of the prompt, while Ruby's dynamic nature lets you generate prompts based on runtime conditions.
+
+## Traditional Markdown Generation
+
+MDPhlex also works great for generating regular Markdown content:
+
+~~~ruby
+class ArticleContent < MDPhlex::MD
+  def initialize(title:, sections:)
+    @title = title
+    @sections = sections
+  end
+
+  def view_template
+    h1 @title
+
+    @sections.each do |section|
+      h2 section[:heading]
+
+      p section[:content]
+
+      if section[:code_example]
+        pre(language: "ruby") { plain section[:code_example] }
       end
-      li "Full Phlex component composition"
     end
 
     p do
-      plain "Check out the "
-      a(href: "https://github.com/martinemde/mdphlex") { "MDPhlex repository" }
-      plain " for more information."
+      plain "Learn more in the "
+      a(href: "https://docs.example.com") { "documentation" }
+      plain "."
     end
   end
 end
 
-# Render the component
-puts HelloWorld.new.call
-```
+article = ArticleContent.new(
+  title: "Getting Started with Ruby",
+  sections: [
+    {
+      heading: "Variables",
+      content: "Ruby variables are dynamically typed and don't require declaration.",
+      code_example: "name = 'Alice'\nage = 30"
+    }
+  ]
+)
 
-This outputs the following Markdown:
+puts article.call
+~~~
 
-```markdown
-# Hello, World!
+Outputs:
 
-Welcome to MDPhlex - writing Markdown with Phlex syntax!
+~~~markdown
+# Getting Started with Ruby
 
-## Features
+## Variables
 
-- Write Markdown using Ruby
-- Support for **bold**, *italic*, and `inline code`
-- Full Phlex component composition
+Ruby variables are dynamically typed and don't require declaration.
 
-Check out the [MDPhlex repository](https://github.com/martinemde/mdphlex) for more information.
+```ruby
+name = 'Alice'
+age = 30
 ```
 
+Learn more in the [documentation](https://docs.example.com).
+~~~
+
 ## Rendering MDPhlex inside Phlex::HTML
 
 MDPhlex components can be seamlessly integrated into your Phlex::HTML views:
 
-```ruby
+~~~ruby
 class ArticlePage < Phlex::HTML
   def initialize(article)
     @article = article
@@ -109,14 +187,13 @@ class ArticleContent < MDPhlex::MD
     end
   end
 end
-```
+~~~
 
 ## Why MDPhlex?
 
 - **Component-based**: Build reusable Markdown components
-- **Type-safe**: Get Ruby's type checking and IDE support
+- **Dynamic Markdown**: Generate markdown from dynamic data
 - **Composable**: Mix Phlex::HTML and MDPhlex components freely
-- **Familiar**: Uses the same syntax as Phlex
 
 ## License
 

data/examples/custom_elements.rb

@@ -0,0 +1,106 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/mdphlex"
+require "json"
+
+# Example: Creating custom block elements for specialized markdown output
+class DocumentationTemplate < MDPhlex::MD
+  # Register custom elements for API documentation
+  register_block_element :api_endpoint
+  register_block_element :request
+  register_block_element :response
+  register_block_element :warning
+  register_block_element :note
+  register_block_element :deprecated
+
+  def initialize(endpoint_name:, method:, path:)
+    @endpoint_name = endpoint_name
+    @method = method
+    @path = path
+  end
+
+  def view_template
+    h1 "API Documentation: #{@endpoint_name}"
+
+    api_endpoint method: @method, path: @path do
+      h2 "Overview"
+      p "This endpoint handles user authentication and returns a JWT token."
+
+      warning do
+        p "This endpoint rate limits requests to 10 per minute per IP address."
+      end
+
+      h2 "Request"
+
+      request do
+        h3 "Headers"
+        pre do
+          <<~HEADERS
+            Content-Type: application/json
+            Accept: application/json
+          HEADERS
+        end
+
+        h3 "Body"
+        pre language: "json" do
+          JSON.pretty_generate({ email: "user@example.com", password: "secure_password123" })
+        end
+      end
+
+      h2 "Response"
+
+      response status: "200" do
+        h3 "Success Response"
+        pre language: "json" do
+          plain JSON.pretty_generate({
+            token: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
+            user: {
+              id: 123,
+              email: "user@example.com",
+              name: "John Doe",
+            },
+          })
+        end
+      end
+
+      response status: "401" do
+        h3 "Authentication Failed"
+        pre language: "json" do
+          JSON.pretty_generate({
+            error: "Invalid credentials",
+          })
+        end
+      end
+
+      note do
+        p "The JWT token expires after 24 hours. Use the refresh endpoint to get a new token."
+      end
+
+      deprecated version: "2.0" do
+        p "The 'username' field in the request body is deprecated. Use 'email' instead."
+      end
+    end
+  end
+end
+
+# Example usage
+if __FILE__ == $0
+  doc = DocumentationTemplate.new(
+    endpoint_name: "User Login",
+    method: "POST",
+    path: "/api/v1/auth/login"
+  )
+
+  output = doc.call
+  puts output
+
+  # Save to file
+  File.write(
+    File.join(File.dirname(__FILE__), "custom_elements_output.md"),
+    output
+  )
+
+  puts "\n---"
+  puts "Output saved to examples/custom_elements_output.md"
+end

data/examples/custom_elements_output.md

@@ -0,0 +1,60 @@
+# API Documentation: User Login
+<api-endpoint method="POST" path="/api/v1/auth/login">
+## Overview
+This endpoint handles user authentication and returns a JWT token.
+
+<warning>
+This endpoint rate limits requests to 10 per minute per IP address.
+
+</warning>
+## Request
+<request>
+### Headers
+```
+Content-Type: application/json
+Accept: application/json
+
+```
+
+### Body
+```json
+{
+  "email": "user@example.com",
+  "password": "secure_password123"
+}
+```
+
+</request>
+## Response
+<response status="200">
+### Success Response
+```json
+{
+  "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
+  "user": {
+    "id": 123,
+    "email": "user@example.com",
+    "name": "John Doe"
+  }
+}
+```
+
+</response>
+<response status="401">
+### Authentication Failed
+```json
+{
+  "error": "Invalid credentials"
+}
+```
+
+</response>
+<note>
+The JWT token expires after 24 hours. Use the refresh endpoint to get a new token.
+
+</note>
+<deprecated version="2.0">
+The 'username' field in the request body is deprecated. Use 'email' instead.
+
+</deprecated>
+</api-endpoint>

data/examples/html_in_markdown.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "mdphlex"
+
+class HTMLInMarkdownExample < MDPhlex::MD
+  def view_template
+    h1 { "HTML in Markdown" }
+
+    p { "Markdown allows inline HTML like <strong>this bold text</strong> and <em>this italic text</em>." }
+
+    p do
+      plain "You can use HTML entities directly: &copy; &amp; &lt;div&gt;"
+    end
+
+    h2 { "Complex HTML" }
+
+    p do
+      plain <<~HTML
+        You can even include complex HTML structures:
+        <div class="alert" style="border: 1px solid red;">
+          <h3>Warning!</h3>
+          <p>This is an alert box created with HTML.</p>
+        </div>
+      HTML
+    end
+
+    h2 { "Mixing Markdown and HTML" }
+
+    p do
+      plain "You can mix "
+      strong { "Markdown formatting" }
+      plain " with <code>HTML tags</code> seamlessly."
+    end
+  end
+end
+
+if __FILE__ == $0
+  puts HTMLInMarkdownExample.new.call
+end

data/examples/llm_prompt.rb

@@ -0,0 +1,181 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/mdphlex"
+
+# Example: Creating structured LLM prompts with custom XML-style tags
+class LLMPrompt < MDPhlex::MD
+  # Register custom block elements for LLM prompt structure
+  register_block_element :system
+  register_block_element :tools
+  register_block_element :tool
+  register_element :description
+  register_block_element :parameters
+  register_block_element :param
+  register_block_element :examples
+  register_block_element :example
+  register_block_element :user
+  register_block_element :assistant
+  register_block_element :context
+  register_block_element :constraints
+
+  def initialize(task:, tools: [], examples: [], context: nil, constraints: [])
+    @task = task
+    @tools = tools
+    @examples = examples
+    @context = context
+    @constraints = constraints
+  end
+
+  def view_template
+    # System instructions
+    system do
+      plain "You are an AI assistant specialized in #{@task}."
+      plain "\n"
+      plain "You have access to tools and should use them when appropriate to help the user."
+      plain "\n"
+      plain "Always be helpful, accurate, and follow the constraints provided."
+    end
+
+    plain "\n"
+
+    # Context section
+    if @context
+      context do
+        plain @context
+      end
+      plain "\n"
+    end
+
+    # Constraints
+    if @constraints.any?
+      constraints do
+        @constraints.each do |constraint|
+          plain "- #{constraint}\n"
+        end
+      end
+      plain "\n"
+    end
+
+    # Available tools
+    if @tools.any?
+      tools do
+        @tools.each do |tool_def|
+          tool name: tool_def[:name], category: tool_def[:category] do
+            description { plain tool_def[:description] }
+
+            if tool_def[:parameters]&.any?
+              parameters do
+                tool_def[:parameters].each do |param|
+                  param name: param[:name], type: param[:type], required: param[:required].to_s do
+                    plain param[:description]
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+      plain "\n"
+    end
+
+    # Examples
+    if @examples.any?
+      examples do
+        @examples.each_with_index do |ex, i|
+          example id: (i + 1).to_s do
+            user { plain ex[:user] }
+            assistant { plain ex[:assistant] }
+          end
+        end
+      end
+      plain "\n"
+    end
+
+    # Instructions footer
+    h2 "Instructions"
+
+    p "When responding to user queries, follow the system guidelines above and use the available tools as needed."
+  end
+end
+
+# Example usage
+if __FILE__ == $0
+  prompt = LLMPrompt.new(
+    task: "code review and refactoring",
+    context: "The user is working on a Ruby on Rails application and needs help improving code quality.",
+    constraints: [
+      "Focus on Ruby idioms and best practices",
+      "Consider performance implications",
+      "Suggest tests when appropriate",
+      "Keep explanations clear and concise",
+    ],
+    tools: [
+      {
+        name: "analyze_code",
+        category: "analysis",
+        description: "Analyzes code for potential improvements, security issues, and best practices",
+        parameters: [
+          {
+            name: "code",
+            type: "string",
+            required: true,
+            description: "The code snippet to analyze",
+          },
+          {
+            name: "language",
+            type: "string",
+            required: false,
+            description: "Programming language (defaults to auto-detect)",
+          },
+          {
+            name: "focus_areas",
+            type: "array",
+            required: false,
+            description: "Specific areas to focus on: performance, security, readability, testing",
+          },
+        ],
+      },
+      {
+        name: "suggest_refactoring",
+        category: "refactoring",
+        description: "Provides specific refactoring suggestions with before/after examples",
+        parameters: [
+          {
+            name: "code",
+            type: "string",
+            required: true,
+            description: "The code to refactor",
+          },
+          {
+            name: "refactoring_type",
+            type: "string",
+            required: false,
+            description: "Type of refactoring: extract_method, simplify_conditionals, remove_duplication",
+          },
+        ],
+      },
+    ],
+    examples: [
+      {
+        user: "Review this Ruby method for improvements:\n```ruby\ndef process_items(items)\n  results = []\n  items.each do |item|\n    if item.valid?\n      results << item.process\n    end\n  end\n  results\nend\n```",
+        assistant: "I'll analyze your Ruby method and suggest improvements.\n\nThe method can be refactored to be more idiomatic and concise using Ruby's enumerable methods:\n\n```ruby\ndef process_items(items)\n  items.select(&:valid?).map(&:process)\nend\n```\n\nKey improvements:\n1. **Use `select` and `map`**: More idiomatic than manual array building\n2. **Symbol-to-proc syntax**: `&:valid?` is cleaner than blocks\n3. **Method chaining**: Reads naturally left-to-right\n4. **No temporary variable**: Eliminates the `results` array\n\nThis refactored version is more functional, easier to test, and clearly expresses the intent.",
+      },
+    ]
+  )
+
+  # Generate the output once and store it
+  output = prompt.call
+
+  # Print to console
+  puts output
+
+  # Also save the output to a file for reference
+  File.write(
+    File.join(File.dirname(__FILE__), "llm_prompt_output.md"),
+    output
+  )
+
+  puts "\n---"
+  puts "Output saved to examples/llm_prompt_output.md"
+end

data/examples/llm_prompt_output.md

@@ -0,0 +1,75 @@
+<system>
+You are an AI assistant specialized in code review and refactoring.
+You have access to tools and should use them when appropriate to help the user.
+Always be helpful, accurate, and follow the constraints provided.</system>
+
+<context>
+The user is working on a Ruby on Rails application and needs help improving code quality.</context>
+
+<constraints>
+- Focus on Ruby idioms and best practices
+- Consider performance implications
+- Suggest tests when appropriate
+- Keep explanations clear and concise
+</constraints>
+
+<tools>
+<tool name="analyze_code" category="analysis">
+<description>Analyzes code for potential improvements, security issues, and best practices</description><parameters>
+<param name="code" type="string" required="true">
+The code snippet to analyze</param>
+<param name="language" type="string" required="false">
+Programming language (defaults to auto-detect)</param>
+<param name="focus_areas" type="array" required="false">
+Specific areas to focus on: performance, security, readability, testing</param>
+</parameters>
+</tool>
+<tool name="suggest_refactoring" category="refactoring">
+<description>Provides specific refactoring suggestions with before/after examples</description><parameters>
+<param name="code" type="string" required="true">
+The code to refactor</param>
+<param name="refactoring_type" type="string" required="false">
+Type of refactoring: extract_method, simplify_conditionals, remove_duplication</param>
+</parameters>
+</tool>
+</tools>
+
+<examples>
+<example id="1">
+<user>
+Review this Ruby method for improvements:
+```ruby
+def process_items(items)
+  results = []
+  items.each do |item|
+    if item.valid?
+      results << item.process
+    end
+  end
+  results
+end
+```</user>
+<assistant>
+I'll analyze your Ruby method and suggest improvements.
+
+The method can be refactored to be more idiomatic and concise using Ruby's enumerable methods:
+
+```ruby
+def process_items(items)
+  items.select(&:valid?).map(&:process)
+end
+```
+
+Key improvements:
+1. **Use `select` and `map`**: More idiomatic than manual array building
+2. **Symbol-to-proc syntax**: `&:valid?` is cleaner than blocks
+3. **Method chaining**: Reads naturally left-to-right
+4. **No temporary variable**: Eliminates the `results` array
+
+This refactored version is more functional, easier to test, and clearly expresses the intent.</assistant>
+</example>
+</examples>
+
+## Instructions
+When responding to user queries, follow the system guidelines above and use the available tools as needed.
+

data/lib/mdphlex/md.rb

@@ -22,7 +22,7 @@ module MDPhlex
 
         if attributes.length > 0
           attributes.each do |key, value|
-            buffer << " #{key}=\"#{Phlex::Escape.html_escape(value.to_s)}\""
+            buffer << " #{key}=\"#{value}\""
           end
         end
 
@@ -299,5 +299,53 @@ module MDPhlex
       buffer << marker
       nil
     end
+
+    # Override __text__ to avoid HTML escaping since markdown allows raw HTML
+    private def __text__(content)
+      state = @_state
+      return true unless state.should_render?
+
+      case content
+      when String
+        state.buffer << content
+      when Symbol
+        state.buffer << content.name
+      when nil
+        nil
+      else
+        if (formatted_object = format_object(content))
+          state.buffer << formatted_object
+        else
+          return false
+        end
+      end
+
+      true
+    end
+
+    # Override __implicit_output__ to avoid HTML escaping
+    private def __implicit_output__(content)
+      state = @_state
+      return true unless state.should_render?
+
+      case content
+      when Phlex::SGML::SafeObject
+        state.buffer << content.to_s
+      when String
+        state.buffer << content
+      when Symbol
+        state.buffer << content.name
+      when nil
+        nil
+      else
+        if (formatted_object = format_object(content))
+          state.buffer << formatted_object
+        else
+          return false
+        end
+      end
+
+      true
+    end
   end
 end

data/lib/mdphlex/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MDPhlex
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/quickdraw/html_escaping.test.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+test "markdown does not escape HTML entities" do
+  component = Class.new(MDPhlex::MD) do
+    def view_template
+      p { "HTML tags: <strong>bold</strong> & <em>italic</em>" }
+    end
+  end
+
+  output = component.new.call
+  assert_equal output, "HTML tags: <strong>bold</strong> & <em>italic</em>\n\n"
+end
+
+test "markdown preserves raw HTML in plain text" do
+  component = Class.new(MDPhlex::MD) do
+    def view_template
+      p do
+        plain "Raw HTML: <div>content</div> & entities"
+      end
+    end
+  end
+
+  output = component.new.call
+  assert_equal output, "Raw HTML: <div>content</div> & entities\n\n"
+end
+
+test "markdown preserves HTML in inline elements" do
+  component = Class.new(MDPhlex::MD) do
+    def view_template
+      p do
+        strong { "<b>nested</b> & more" }
+        plain " "
+        em { "<i>italic</i>" }
+      end
+    end
+  end
+
+  output = component.new.call
+  assert_equal output, "**<b>nested</b> & more** *<i>italic</i>*\n\n"
+end
+
+test "custom elements do not escape attribute values" do
+  component = Class.new(MDPhlex::MD) do
+    register_block_element :custom_div, tag: "div"
+
+    def view_template
+      custom_div(class: "test & class", "data-value": "x > 5") do
+        p { "Content" }
+      end
+    end
+  end
+
+  output = component.new.call
+  assert_includes output, '<div class="test & class" data-value="x > 5">'
+end
+
+test "code blocks preserve HTML content" do
+  component = Class.new(MDPhlex::MD) do
+    def view_template
+      pre(language: "html") do
+        plain "<div class=\"example\">\n  <p>HTML code</p>\n</div>"
+      end
+    end
+  end
+
+  output = component.new.call
+  expected = <<~MD
+    ```html
+    <div class="example">
+      <p>HTML code</p>
+    </div>
+    ```
+
+  MD
+  assert_equal output, expected
+end
+
+test "code blocks with JSON.pretty_generate preserve quotes and special characters" do
+  require "json"
+
+  component = Class.new(MDPhlex::MD) do
+    def view_template
+      pre language: "json" do
+        JSON.pretty_generate({ email: "user@example.com", password: "secure_password123" })
+      end
+    end
+  end
+
+  output = component.new.call
+  expected = <<~MD
+    ```json
+    {
+      "email": "user@example.com",
+      "password": "secure_password123"
+    }
+    ```
+
+  MD
+  assert_equal output, expected
+end
+
+test "code blocks preserve complex JSON with special characters" do
+  require "json"
+
+  component = Class.new(MDPhlex::MD) do
+    def view_template
+      pre language: "json" do
+        JSON.pretty_generate({
+          users: [
+            { name: "John & Jane", role: "admin" },
+            { name: "Bob <Smith>", role: "user" },
+          ],
+          config: {
+            api_key: "key-with-special-chars-!@#$%^&*()",
+            html_template: "<div class=\"test\">Content</div>",
+          },
+        })
+      end
+    end
+  end
+
+  output = component.new.call
+  expected = <<~MD
+    ```json
+    {
+      "users": [
+        {
+          "name": "John & Jane",
+          "role": "admin"
+        },
+        {
+          "name": "Bob <Smith>",
+          "role": "user"
+        }
+      ],
+      "config": {
+        "api_key": "key-with-special-chars-!@#$%^&*()",
+        "html_template": "<div class=\\"test\\">Content</div>"
+      }
+    }
+    ```
+
+  MD
+  assert_equal output, expected
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mdphlex
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Martin Emde
@@ -49,9 +49,15 @@ files:
 - README.md
 - Rakefile
 - config/quickdraw.rb
+- examples/custom_elements.rb
+- examples/custom_elements_output.md
+- examples/html_in_markdown.rb
+- examples/llm_prompt.rb
+- examples/llm_prompt_output.md
 - lib/mdphlex.rb
 - lib/mdphlex/md.rb
 - lib/mdphlex/version.rb
+- quickdraw/html_escaping.test.rb
 - quickdraw/interoperability.test.rb
 - quickdraw/mdphlex.test.rb
 homepage: https://github.com/martinemde/mdphlex