probatio_diabolica 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 368faf074dc354becfef975422fc3199a1e83293a30bad935ef17696a9b879c9
-  data.tar.gz: 66b84421f306926f425cdc6d9e5cc4a1ff3b8ed1cd4f6df13e86bd7313796c5d
+  metadata.gz: 891d8275e2ccd96dea0d74c456a55693ab667fd556fedf9b5d1fe9470b0949cb
+  data.tar.gz: d53faf24d75c1f112e5cb064048372d7ac7c5391f50ed3e546a5f7990cb7d02f
 SHA512:
-  metadata.gz: f9cce79af416cc2b0e216820dd3f07f2d0ba46552db2e2598d9ab2ab83f1492757044717a383256db7b6d14168a3da4d11a0cf89949f6ec1eebe4bf55f366f2c
-  data.tar.gz: 03e7a8a23b02b473e8bac35c4b4021e729b4e435408bdc69a6143162eebdad8172ec5bb07b83d4471b87464c5f42b1346a112d0e1d7f3af061f916838ea13ea8
+  metadata.gz: faafc8c84e60b7058d57ceb6d457502822724aea22325e3e0ccd4efb3e3765903f21f8525f0e4c9937bea8e69901d39e543796a776b5a1305922492955ce373e
+  data.tar.gz: 4d9f2a94aee2e50112544aa6c0be783ee79f95ee0b4dd7ef95731590b45f335a4e2e61044a99bfa4d2b6125767c9f9b6f91ba2b7e8b70e275ab792b62b138be3

data/README.md

@@ -21,7 +21,7 @@ Tests are evaluated with `instance_eval` (not through RSpec).
 
 ## Installation
 
-### From the gem
+### In the Gemfile
 
 ```ruby
 gem 'probatio_diabolica'
@@ -33,63 +33,6 @@ Then:
 bundle install
 ```
 
-In Ruby code, you can load it with:
-
-```ruby
-require "probatio_diabolica"
-```
-
-### From this repository (local development)
-
-```bash
-bundle install
-bundle exec prd examples/basics_spec.rb
-```
-
-### Build and install as a gem
-
-```bash
-# build the package
-gem build probatio_diabolica.gemspec
-
-# install locally from the built gem
-gem install ./probatio_diabolica-*.gem
-```
-
-## Release workflow
-
-Use the release helper to bump version, refresh `Gemfile.lock`, create commit/tag, and push:
-
-```bash
-# explicit version
-bin/release --version 0.2.0
-
-# or env-style
-VERSION=0.2.0 bin/release
-
-# semantic bump from current version
-bin/release --bump patch
-```
-
-Useful options:
-
-- `--dry-run` preview all actions without modifying files/git
-- `--no-push` create commit/tag locally only
-- `--skip-tests` skip `bundle exec ruby bin/prd spec --mode synthetic`
-- `--allow-dirty` bypass clean-working-tree guard
-
-After installation, you can run:
-
-```bash
-prd examples/basics_spec.rb
-```
-
-If `prd` is not found, add your gem bin directory to `PATH`:
-
-```bash
-export PATH="$(ruby -e 'print Gem.user_dir')/bin:$PATH"
-```
-
 ## Configuration LLM
 
 The runtime automatically loads `prd_helper.rb` if present (or a file passed with `-c`).
@@ -119,6 +62,29 @@ From source checkout (without gem install), this is always valid:
 bundle exec ruby bin/prd <file_or_directory> [options]
 ```
 
+## MCP server (`run_specs`)
+
+A minimal MCP server is available through:
+
+```bash
+bundle exec ruby bin/prd_mcp
+```
+
+It exposes one tool: `run_specs`.
+
+Input:
+- `path` (required): file or directory containing specs
+- `config` (optional): same as `-c`
+- `out` (optional): same as `-o`
+- `formatters` (optional): array of `simple|html|json|pdf` (default: `["simple"]`)
+- `mode` (optional): `verbose|synthetic` (default: `synthetic`)
+
+Output (`structuredContent`):
+- `ok`, `exit_code`
+- `summary` (`passed`, `failed`, `pending`)
+- `artifacts` (`base_out`, `reports`, `annex_dir`)
+- `logs` (`stdout`, `stderr`)
+
 Options:
 
 - `-c, --config FILE` Ruby config file to require
@@ -151,33 +117,36 @@ Examples:
 
 ```bash
 # single file
-bundle exec ruby bin/prd examples/basics_spec.rb
+prd examples/basics_spec.rb
 
 # all *_spec.rb files in a directory
-bundle exec ruby bin/prd examples
+prd examples
 
 # HTML report in an existing directory (creates ./tmp/report.html)
-bundle exec ruby bin/prd examples/image_spec.rb -t html -o ./tmp/
+prd examples/image_spec.rb -t html -o ./tmp/
 
 # multiple reports from one run with shared base name
-bundle exec ruby bin/prd examples/basics_spec.rb -t html,json,pdf -o ./tmp/my_report
+prd examples/basics_spec.rb -t html,json,pdf -o ./tmp/my_report
 
 # compact synthetic output on console
-bundle exec ruby bin/prd examples/basics_spec.rb --mode synthetic
+prd examples/basics_spec.rb --mode synthetic
 ```
 
 ## Available DSL
 
+It is inspired by RSpec but with a custom runtime and additional features.
+
 ### Structure
 
 ```ruby
 describe 'My domain' do
   context 'my context' do
-    let(:value) { 5 }
-    subject { 'hello' }
+    let(:two) { 2 }
+    let(:three) { 3 }
+    subject { two + three }
 
     it 'runs an assertion' do
-      expect(value).to eq(5)
+      expect.to eq(5)
     end
 
     pending 'test to implement later'
@@ -231,6 +200,20 @@ end
 ### Source code helper (Prism)
 
 `source_code(...)` uses the `prism` gem to parse Ruby source and extract class/method code.
+It returns a `PrD::Code` object:
+
+- `source` (`String`)
+- `language` (`String`, default: `ruby`)
+
+Example:
+
+```ruby
+let(:code) { source_code(PrD::Matchers::AllMatcher) }
+
+it 'uses raw source text' do
+  expect(code.source).to(includes('class AllMatcher'))
+end
+```
 
 Prerequisites:
 
@@ -273,13 +256,16 @@ When you define a `subject`, each formatter tries to render it in the most usefu
   - for files, prints a textual representation (for example path, file preview for `.txt`)
 - `HtmlFormatter`:
   - renders text values directly
+  - for `PrD::Code`, renders syntax-highlighted code blocks (Rouge)
   - for image files (`.png`, `.jpg`, `.jpeg`), embeds the image in the report
   - for PDF subjects (`File` `.pdf` or `PDF::Reader`), embeds the PDF with a `data:application/pdf;base64,...` URI
 - `PdfFormatter`:
   - renders text values as report lines
+  - for `PrD::Code`, renders language + code block (plain, without syntax colors)
   - for image files (`.png`, `.jpg`, `.jpeg`), inserts the image directly in the PDF report
 - `JsonFormatter`:
   - keeps a structured representation for machine processing
+  - for `PrD::Code`, emits a structured payload (`type: "code"`, `language`, `source`)
   - `File` values (images, PDFs, text files, etc.) are embedded as base64 payloads
   - `PDF::Reader` values are also embedded as base64 (`application/pdf`)
 

data/bin/prd_mcp

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'pr_d'
+rescue LoadError
+  require_relative '../lib/pr_d'
+end
+
+PrD::Mcp::Server.new.run

data/lib/pr_d/code.rb

@@ -0,0 +1,18 @@
+module PrD
+  class Code
+    attr_reader :source, :language
+
+    def initialize(source:, language: 'ruby')
+      @source = source.to_s
+      @language = language.to_s
+    end
+
+    def to_s
+      @source
+    end
+
+    def include?(value)
+      @source.include?(value)
+    end
+  end
+end

data/lib/pr_d/formatters/formatter.rb

@@ -100,6 +100,10 @@ module PrD
 
         value
       end
+
+      def code_object?(value)
+        defined?(PrD::Code) && value.is_a?(PrD::Code)
+      end
     end
   end
 end

data/lib/pr_d/formatters/html_formatter.rb

@@ -1,5 +1,6 @@
 require 'cgi'
 require 'base64'
+require 'rouge'
 
 module PrD
   module Formatters
@@ -9,6 +10,7 @@ module PrD
         @content = +''
         @index_entries = []
         @anchor_counters = Hash.new(0)
+        @rouge_formatter = Rouge::Formatters::HTMLLegacy.new(css_class: 'highlight')
       end
 
       def context(message)
@@ -51,20 +53,13 @@ module PrD
       end
 
       def let(value)
+        return if synthetic?
+        render_value_block('Let', value)
       end
 
       def subject(subject)
         return if synthetic?
-        @content << '<div class="subject-block">'
-        @content << "<p class=\"line\"><strong>Subject:</strong> #{escape(serialize(subject).to_s)}</p>"
-        if image_file?(subject)
-          @content << "<img src=\"#{image_data_uri(subject.path)}\" alt=\"Subject image\" class=\"subject-image\" />"
-        elsif pdf_file?(subject)
-          @content << "<embed src=\"#{pdf_data_uri(subject.path)}\" type=\"application/pdf\" class=\"subject-pdf\" />"
-        elsif pdf_reader?(subject)
-          @content << "<embed src=\"#{pdf_reader_data_uri(subject)}\" type=\"application/pdf\" class=\"subject-pdf\" />"
-        end
-        @content << '</div>'
+        render_value_block('Subject', subject)
       end
 
       def pending(description = nil)
@@ -85,7 +80,7 @@ module PrD
 
       def expect(expectation)
         return if synthetic?
-        @content << "<p class=\"line\"><strong>Expect:</strong> #{escape(serialize(expectation).to_s)}</p>"
+        render_labeled_value('Expect', expectation)
       end
 
       def to
@@ -102,15 +97,15 @@ module PrD
         return if synthetic?
         case matcher
         when Matchers::EqMatcher
-          @content << "<p class=\"line\"><strong>Matcher:</strong> Be equal to #{escape(serialize(matcher.expected).to_s)}</p>"
+          render_matcher_value('Be equal to', matcher.expected)
         when Matchers::BeMatcher
-          @content << "<p class=\"line\"><strong>Matcher:</strong> Be the same object as #{escape(serialize(matcher.expected).to_s)}</p>"
+          render_matcher_value('Be the same object as', matcher.expected)
         when Matchers::IncludesMatcher
-          @content << "<p class=\"line\"><strong>Matcher:</strong> Include #{escape(serialize(matcher.expected).to_s)}</p>"
+          render_matcher_value('Include', matcher.expected)
         when Matchers::HaveMatcher
-          @content << "<p class=\"line\"><strong>Matcher:</strong> Have #{escape(serialize(matcher.expected).to_s)}</p>"
+          render_matcher_value('Have', matcher.expected)
         when Matchers::LlmMatcher
-          @content << "<p class=\"line\"><strong>Matcher:</strong> Satisfy condition #{escape(serialize(matcher.expected).to_s)}</p>"
+          render_matcher_value('Satisfy condition', matcher.expected)
         when Matchers::AllMatcher
           if sources
             code_line = matcher.expected.source_location.last.to_i
@@ -156,6 +151,7 @@ module PrD
                   --muted: #6b7280;
                   --line: #e5e7eb;
                   --accent: #0f766e;
+                  --sidebar-width: 320px;
                   --pass-bg: #ecfdf5;
                   --pass-fg: #166534;
                   --fail-bg: #fef2f2;
@@ -182,12 +178,51 @@ module PrD
                   border-radius: 18px;
                 }
 
+                body.has-index main.container {
+                  width: min(960px, calc(100% - var(--sidebar-width) - 4rem));
+                  margin: 1rem 1rem 2rem calc(var(--sidebar-width) + 2rem);
+                }
+
+                body.has-index.index-collapsed main.container {
+                  width: min(960px, calc(100% - 2rem));
+                  margin: 1rem auto 2rem;
+                }
+
+                .index-toggle {
+                  position: fixed;
+                  top: 0.9rem;
+                  left: 0.9rem;
+                  z-index: 1100;
+                  border: 1px solid #d1d5db;
+                  border-radius: 999px;
+                  background: var(--paper);
+                  color: #0f172a;
+                  padding: 0.45rem 0.8rem;
+                  font-size: 0.9rem;
+                  font-weight: 600;
+                  cursor: pointer;
+                  box-shadow: 0 6px 18px rgba(15, 23, 42, 0.12);
+                }
+
                 .report-index {
+                  position: fixed;
+                  top: 3.2rem;
+                  left: 1rem;
+                  bottom: 1rem;
+                  z-index: 1000;
+                  width: var(--sidebar-width);
                   background: var(--paper);
                   border: 1px solid var(--line);
                   border-radius: 14px;
                   padding: 0.9rem 1rem;
-                  margin-bottom: 1rem;
+                  overflow-y: auto;
+                  transition: transform 0.18s ease, opacity 0.18s ease;
+                }
+
+                body.has-index.index-collapsed .report-index {
+                  transform: translateX(calc(-1 * (var(--sidebar-width) + 1rem)));
+                  opacity: 0;
+                  pointer-events: none;
                 }
 
                 .index-title {
@@ -207,12 +242,16 @@ module PrD
                   padding-left: calc(var(--index-level, 0) * 1rem);
                 }
 
-                .index-item a {
+                .index-link {
+                  display: block;
+                  white-space: nowrap;
+                  overflow: hidden;
+                  text-overflow: ellipsis;
                   color: var(--accent);
                   text-decoration: none;
                 }
 
-                .index-item a:hover {
+                .index-link:hover {
                   text-decoration: underline;
                 }
 
@@ -314,6 +353,53 @@ module PrD
                 .result.success { color: var(--pass-fg); background: var(--pass-bg); }
                 .result.failure { color: var(--fail-fg); background: var(--fail-bg); }
                 .muted { color: var(--muted); }
+
+                .code-language {
+                  color: var(--muted);
+                  font-size: 0.85rem;
+                  margin-bottom: 0.35rem;
+                  text-transform: uppercase;
+                  letter-spacing: 0.05em;
+                }
+
+                .code-block {
+                  margin: 0.45rem 0 0.7rem;
+                }
+
+                .highlight {
+                  margin: 0;
+                  border: 1px solid var(--line);
+                  border-radius: 10px;
+                  overflow-x: auto;
+                }
+
+                .highlight pre {
+                  margin: 0;
+                  padding: 0.8rem;
+                  line-height: 1.35;
+                }
+
+                @media (max-width: 960px) {
+                  :root { --sidebar-width: min(82vw, 320px); }
+
+                  body.has-index main.container,
+                  body.has-index.index-collapsed main.container {
+                    width: calc(100% - 1rem);
+                    margin: 4rem 0.5rem 1rem 0.5rem;
+                  }
+
+                  .report-index {
+                    top: 3.5rem;
+                    left: 0.5rem;
+                    bottom: 0.5rem;
+                  }
+
+                  body.has-index.index-collapsed .report-index {
+                    transform: translateX(calc(-1 * (var(--sidebar-width) + 0.6rem)));
+                  }
+                }
+
+                #{rouge_theme_css}
               </style>
             </head>
             <body>
@@ -325,28 +411,52 @@ module PrD
         return '' if @index_entries.empty?
 
         index_items = @index_entries.map do |entry|
-          "<li class=\"index-item\" style=\"--index-level: #{entry[:level]};\"><a href=\"##{entry[:anchor_id]}\">#{escape(index_label(entry))}</a></li>"
+          label = escape(index_label(entry))
+          "<li class=\"index-item\" style=\"--index-level: #{entry[:level]};\"><a class=\"index-link\" href=\"##{entry[:anchor_id]}\" title=\"#{label}\">#{label}</a></li>"
         end.join
 
         <<~HTML
-          <nav class="report-index" aria-label="Report index">
+          <button type="button" class="index-toggle" aria-expanded="false" aria-controls="report-index">Show index</button>
+          <nav id="report-index" class="report-index" aria-label="Report index">
             <h2 class="index-title">Index</h2>
             <ul class="index-list">
               #{index_items}
             </ul>
           </nav>
+          <script>
+            (function() {
+              var body = document.body;
+              var nav = document.getElementById('report-index');
+              var toggle = document.querySelector('.index-toggle');
+              if (!body || !nav || !toggle) return;
+
+              body.classList.add('has-index');
+
+              var syncToggleLabel = function() {
+                var isCollapsed = body.classList.contains('index-collapsed');
+                toggle.setAttribute('aria-expanded', String(!isCollapsed));
+                toggle.textContent = isCollapsed ? 'Show index' : 'Hide index';
+              };
+
+              toggle.addEventListener('click', function() {
+                body.classList.toggle('index-collapsed');
+                syncToggleLabel();
+              });
+
+              syncToggleLabel();
+            })();
+          </script>
         HTML
       end
 
       def index_label(entry)
-        prefix =
+        marker =
           case entry[:type]
-          when :context then 'Context'
-          when :pending then 'Pending'
-          else 'Test'
+          when :context then '+'
+          else '-'
           end
 
-        "#{prefix}: #{entry[:label]}"
+        "#{marker} #{entry[:label]}"
       end
 
       def add_index_entry(type:, label:, level:, anchor_id:)
@@ -363,6 +473,70 @@ module PrD
         "#{prefix}-#{@anchor_counters[prefix]}"
       end
 
+      def render_labeled_value(label, value)
+        if code_object?(value)
+          @content << "<p class=\"line\"><strong>#{escape(label)}:</strong></p>"
+          @content << render_code_block(value)
+        else
+          @content << "<p class=\"line\"><strong>#{escape(label)}:</strong> #{escape(serialize(value).to_s)}</p>"
+        end
+      end
+
+      def render_matcher_value(label, value)
+        if code_object?(value)
+          @content << "<p class=\"line\"><strong>Matcher:</strong> #{escape(label)} (#{escape(value.language)})</p>"
+          @content << render_code_block(value)
+        else
+          @content << "<p class=\"line\"><strong>Matcher:</strong> #{escape(label)} #{escape(serialize(value).to_s)}</p>"
+        end
+      end
+
+      def render_value_block(label, value)
+        @content << '<div class="subject-block">'
+        if code_object?(value)
+          @content << "<p class=\"line\"><strong>#{escape(label)}:</strong></p>"
+          @content << render_code_block(value)
+        else
+          @content << "<p class=\"line\"><strong>#{escape(label)}:</strong> #{escape(serialize(value).to_s)}</p>"
+        end
+
+        if image_file?(value)
+          @content << "<img src=\"#{image_data_uri(value.path)}\" alt=\"#{escape(label)} image\" class=\"subject-image\" />"
+        elsif pdf_file?(value)
+          @content << "<embed src=\"#{pdf_data_uri(value.path)}\" type=\"application/pdf\" class=\"subject-pdf\" />"
+        elsif pdf_reader?(value)
+          @content << "<embed src=\"#{pdf_reader_data_uri(value)}\" type=\"application/pdf\" class=\"subject-pdf\" />"
+        end
+        @content << '</div>'
+      end
+
+      def render_code_block(code)
+        source = normalize_text(code.source)
+        language = normalize_text(code.language)
+        highlighted = highlight_code(source, language)
+        <<~HTML
+          <div class="code-block">
+            <div class="code-language">#{escape(language)}</div>
+            #{highlighted}
+          </div>
+        HTML
+      end
+
+      def highlight_code(source, language)
+        lexer = rouge_lexer_for(source, language)
+        @rouge_formatter.format(lexer.lex(source))
+      end
+
+      def rouge_lexer_for(source, language)
+        Rouge::Lexer.find_fancy(language, source) || Rouge::Lexers::PlainText
+      rescue StandardError
+        Rouge::Lexers::PlainText
+      end
+
+      def rouge_theme_css
+        Rouge::Themes::Github.render(scope: '.highlight')
+      end
+
       def escape(message)
         CGI.escape_html(normalize_text(message))
       end

data/lib/pr_d/formatters/json_formatter.rb

@@ -117,6 +117,10 @@ module PrD
         serializer = @serializers[value.class]
         return serializer.call(value) if serializer
 
+        if code_object?(value)
+          return serialize_code(value)
+        end
+
         if value.is_a?(File)
           return serialize_file(value)
         end
@@ -136,6 +140,14 @@ module PrD
         value
       end
 
+      def serialize_code(code)
+        {
+          type: 'code',
+          language: code.language,
+          source: code.source
+        }
+      end
+
       def serialize_file(file)
         file.rewind if file.respond_to?(:rewind)
         content = file.read

data/lib/pr_d/formatters/pdf_formatter.rb

@@ -74,7 +74,10 @@ module PrD
       def subject(subject)
         return if synthetic?
         add_event(:subject, message: 'Subject', level: @level)
-        if image_file?(subject)
+        if code_object?(subject)
+          add_event(:code_header, message: "Language: #{subject.language}", level: @level + 1)
+          add_event(:code_block, message: subject.source, level: @level + 1)
+        elsif image_file?(subject)
           add_event(:detail, message: serialize(subject).to_s, level: @level + 1)
           add_event(:subject_image, message: subject.path, level: @level + 1)
         else
@@ -93,7 +96,12 @@ module PrD
 
       def expect(expectation)
         return if synthetic?
-        add_event(:detail, message: "Expect: #{serialize(expectation)}", level: @level + 1)
+        if code_object?(expectation)
+          add_event(:code_header, message: "Expect (#{expectation.language})", level: @level + 1)
+          add_event(:code_block, message: expectation.source, level: @level + 1)
+        else
+          add_event(:detail, message: "Expect: #{serialize(expectation)}", level: @level + 1)
+        end
       end
 
       def to
@@ -110,15 +118,15 @@ module PrD
         return if synthetic?
         case matcher
         when Matchers::EqMatcher
-          add_event(:matcher, message: "Be equal to: #{serialize(matcher.expected)}", level: @level + 2)
+          add_matcher_value_event('Be equal to', matcher.expected)
         when Matchers::BeMatcher
-          add_event(:matcher, message: "Be the same object as: #{serialize(matcher.expected)}", level: @level + 2)
+          add_matcher_value_event('Be the same object as', matcher.expected)
         when Matchers::IncludesMatcher
-          add_event(:matcher, message: "Include: #{serialize(matcher.expected)}", level: @level + 2)
+          add_matcher_value_event('Include', matcher.expected)
         when Matchers::HaveMatcher
-          add_event(:matcher, message: "Have: #{serialize(matcher.expected)}", level: @level + 2)
+          add_matcher_value_event('Have', matcher.expected)
         when Matchers::LlmMatcher
-          add_event(:matcher, message: "Satisfy condition: #{serialize(matcher.expected)}", level: @level + 2)
+          add_matcher_value_event('Satisfy condition', matcher.expected)
         when Matchers::AllMatcher
           add_event(:matcher, message: 'all match the given condition', level: @level + 2)
         else
@@ -227,6 +235,10 @@ module PrD
             status_line(document, 'PENDING', event[:message], event[:level], COLORS[:pending])
           when :matcher
             styled_line(document, event[:message], level: event[:level], size: 10, color: COLORS[:muted])
+          when :code_header
+            styled_line(document, event[:message], level: event[:level], size: 10, style: :bold, color: COLORS[:muted])
+          when :code_block
+            render_code_block(document, event[:message], level: event[:level])
           when :detail, :subject, :justification
             styled_line(document, event[:message], level: event[:level], size: 10, color: COLORS[:text])
           when :subject_image
@@ -284,6 +296,28 @@ module PrD
         document.move_down 2
       end
 
+      def render_code_block(document, text, level:)
+        document.indent(level * 14) do
+          document.fill_color COLORS[:muted]
+          document.text '--- Code Block ---', size: 9, style: :italic
+          document.fill_color COLORS[:text]
+          document.font('Courier') { document.text text, size: 9 }
+          document.fill_color COLORS[:muted]
+          document.text '--- End Block ---', size: 9, style: :italic
+          document.fill_color COLORS[:text]
+        end
+        document.move_down 3
+      end
+
+      def add_matcher_value_event(label, value)
+        if code_object?(value)
+          add_event(:matcher, message: "#{label} (#{value.language})", level: @level + 2)
+          add_event(:code_block, message: value.source, level: @level + 2)
+        else
+          add_event(:matcher, message: "#{label}: #{serialize(value)}", level: @level + 2)
+        end
+      end
+
       def index_label(entry)
         prefix =
           case entry[:type]

data/lib/pr_d/formatters/simple_formatter.rb

@@ -47,7 +47,12 @@ module PrD
       def subject(subject)
         return if synthetic?
         title('Subject')
-        output(subject, :white, indent: 1)
+        if code_object?(subject)
+          output("Code (#{subject.language}):", :white, indent: 1)
+          output(subject.source, :white, indent: 2)
+        else
+          output(subject, :white, indent: 1)
+        end
       end
 
       def pending(description = nil)
@@ -61,7 +66,12 @@ module PrD
 
       def expect(expectation)
         return if synthetic?
-        output("Expect: #{expectation}", :white, indent: 1)
+        if code_object?(expectation)
+          output("Expect (#{expectation.language}):", :white, indent: 1)
+          output(expectation.source, :white, indent: 2)
+        else
+          output("Expect: #{expectation}", :white, indent: 1)
+        end
       end
 
       def to
@@ -81,15 +91,15 @@ module PrD
         return if synthetic?
         case matcher
         when Matchers::EqMatcher
-          output("Be equal to: #{matcher.expected}", :white, indent: 2)
+          output_matcher_value('Be equal to', matcher.expected)
         when Matchers::BeMatcher
-          output("Be the same object as: #{matcher.expected}", :white, indent: 2)
+          output_matcher_value('Be the same object as', matcher.expected)
         when Matchers::IncludesMatcher
-          output("Include: #{matcher.expected}", :white, indent: 2)
+          output_matcher_value('Include', matcher.expected)
         when Matchers::HaveMatcher
-          output("Have: #{matcher.expected}", :white, indent: 2)
+          output_matcher_value('Have', matcher.expected)
         when Matchers::LlmMatcher
-          output("Satisfy condition: #{matcher.expected}", :white, indent: 2)
+          output_matcher_value('Satisfy condition', matcher.expected)
         when Matchers::AllMatcher
           if sources
             code_line = matcher.expected.source_location.last.to_i
@@ -117,6 +127,9 @@ module PrD
           @io.puts "#{INDENT * indent}#{message}"
         when Array
           message.each { |line| output(line, color, figure: figure, indent: indent) }
+        when PrD::Code
+          output("Code (#{message.language}):", color, indent: indent)
+          output(message.source, color, indent: indent + 1)
         when String
           if message.include?("\n")
             @io.puts "#{COLOR_MAPPING[color]}#{INDENT * indent}--- Code Block ---#{COLOR_MAPPING[:default]}"
@@ -152,6 +165,15 @@ module PrD
         output(message, :yellow)
       end
 
+      def output_matcher_value(label, value)
+        if code_object?(value)
+          output("#{label} (#{value.language}):", :white, indent: 2)
+          output(value.source, :white, indent: 3)
+        else
+          output("#{label}: #{value}", :white, indent: 2)
+        end
+      end
+
       def indented_message(message, indent_incr: 0)
         "#{INDENT * (@level + indent_incr)}#{message}"
       end

data/lib/pr_d/helpers/chrome_helper.rb

@@ -23,12 +23,7 @@ module PrD
         text_node = browser.at_css(css)
         raise ArgumentError, "CSS selector not found: #{css}" unless text_node
 
-        text_id = Digest::SHA256.hexdigest("#{at}-#{css}")
-        file_name = File.join(chrome_annex_dir, "text-#{text_id}.txt")
-        File.open(file_name, 'w') do |file|
-          file.write(text_node.text.scan(/.{1,100}/m).join("\n"))
-        end
-        File.open(file_name, 'rb')
+        PrD::Code.new(source: text_node.text, language: 'text')
       end
 
       def network(at:, warmup_time: 2)
@@ -54,7 +49,8 @@ module PrD
       def html(at:, warmup_time: 2)
         browser = prepare_browser(at:, warmup_time:)
         yield browser if block_given?
-        browser.body
+
+        PrD::Code.new(source: browser.body, language: 'html')
       end
 
       def close_chrome_browser

data/lib/pr_d/helpers/source_code_helper.rb

@@ -10,14 +10,14 @@ module PrD
 
           code = File.read(file)
           tree = Prism.parse(code)
-          extract_class_from_node(tree.value, class_or_method.to_s, code)
+          extract_code_object(extract_class_from_node(tree.value, class_or_method.to_s, code))
         else
           file, line = class_or_method.source_location
           return nil unless file && line
 
           code = File.read(file)
           tree = Prism.parse(code)
-          extract_method_from_node(tree.value, class_or_method.name, code)
+          extract_code_object(extract_method_from_node(tree.value, class_or_method.name, code))
         end
       end
 
@@ -61,6 +61,12 @@ module PrD
       rescue LoadError => e
         raise LoadError, "Source code helpers require the 'prism' gem. Install it with `gem install prism` or add `gem 'prism'` to your Gemfile. (#{e.message})"
       end
+
+      def extract_code_object(source)
+        return nil if source.nil?
+
+        PrD::Code.new(source:, language: 'ruby')
+      end
     end
   end
 end

data/lib/pr_d/matchers/includes_matcher.rb

@@ -5,6 +5,8 @@ module PrD
       def matches?(actual)
         if actual.is_a?(String) || actual.is_a?(Array)
           PrD::Runtime::TestResult.new(comment: nil, pass: actual.include?(@expected))
+        elsif defined?(PrD::Code) && actual.is_a?(PrD::Code)
+          PrD::Runtime::TestResult.new(comment: nil, pass: actual.source.include?(@expected))
         elsif actual.is_a?(File)
           content = actual.read
           actual.rewind

data/lib/pr_d/matchers/llm_matcher.rb

@@ -24,6 +24,8 @@ module PrD
       def matches?(actual)
         if actual.is_a?(String)
           return build_runtime_result(text(@expected, actual))
+        elsif defined?(PrD::Code) && actual.is_a?(PrD::Code)
+          return build_runtime_result(text(@expected, actual.source))
         elsif actual.is_a?(File)
           if actual.path.end_with?('.png', '.jpg', '.jpeg')
             return build_runtime_result(image(@expected, actual))

data/lib/pr_d/mcp/run_specs_tool.rb

@@ -0,0 +1,248 @@
+require 'json'
+require 'open3'
+
+module PrD
+  module Mcp
+    class RunSpecsTool
+      SUPPORTED_FORMATTERS = %w[simple html json pdf].freeze
+      SUPPORTED_MODES = %w[verbose synthetic].freeze
+      FORMATTER_EXTENSIONS = {
+        'simple' => '.txt',
+        'html' => '.html',
+        'json' => '.json',
+        'pdf' => '.pdf'
+      }.freeze
+      DEFAULT_REPORT_BASENAME = 'report'.freeze
+
+      def initialize(command_runner: Open3, pwd: Dir.pwd)
+        @command_runner = command_runner
+        @pwd = pwd
+      end
+
+      def call(arguments)
+        args = normalize_and_validate_arguments(arguments)
+        command = build_command(args)
+        stdout, stderr, status = @command_runner.capture3(*command, chdir: @pwd)
+
+        base_out = args[:out] ? output_base_path(args[:out]) : nil
+        parsed_json = parse_json_summary(args:, stdout:, base_out:)
+
+        {
+          ok: true,
+          exit_code: status.exitstatus,
+          summary: build_summary(args:, stdout:, parsed_json:),
+          artifacts: build_artifacts(args:, base_out:),
+          logs: {
+            stdout: stdout,
+            stderr: stderr
+          }
+        }
+      rescue StandardError => e
+        raise e if e.is_a?(ArgumentError)
+
+        {
+          ok: false,
+          exit_code: nil,
+          summary: { passed: nil, failed: nil, pending: nil },
+          artifacts: { base_out: nil, reports: [], annex_dir: nil },
+          logs: { stdout: '', stderr: "#{e.class}: #{e.message}" }
+        }
+      end
+
+      private
+
+      def normalize_and_validate_arguments(raw_args)
+        raise ArgumentError, 'run_specs requires an arguments object.' unless raw_args.is_a?(Hash)
+
+        path = raw_args['path'] || raw_args[:path]
+        raise ArgumentError, 'run_specs requires `path` (string).' unless path.is_a?(String) && !path.strip.empty?
+
+        absolute_path = File.expand_path(path, @pwd)
+        raise ArgumentError, "Path not found: #{path}" unless File.exist?(absolute_path)
+
+        formatters = normalize_formatters(raw_args['formatters'] || raw_args[:formatters])
+        mode = normalize_mode(raw_args['mode'] || raw_args[:mode])
+        out = normalize_optional_string(raw_args['out'] || raw_args[:out])
+        config = normalize_optional_string(raw_args['config'] || raw_args[:config])
+
+        if (formatters.length > 1 || formatters.include?('pdf')) && out.nil?
+          raise ArgumentError, 'Using multiple formatters or pdf requires `out`.'
+        end
+
+        {
+          path: absolute_path,
+          formatters: formatters,
+          mode: mode,
+          out: out,
+          config: config
+        }
+      end
+
+      def normalize_optional_string(value)
+        return nil if value.nil?
+        return value if value.is_a?(String) && !value.strip.empty?
+
+        raise ArgumentError, 'Optional arguments (`config`, `out`) must be non-empty strings when provided.'
+      end
+
+      def normalize_formatters(value)
+        return ['simple'] if value.nil?
+
+        unless value.is_a?(Array) && !value.empty?
+          raise ArgumentError, '`formatters` must be a non-empty array when provided.'
+        end
+
+        formatters = value.map do |formatter|
+          formatter_string = formatter.to_s.strip
+          raise ArgumentError, '`formatters` cannot contain empty values.' if formatter_string.empty?
+
+          formatter_string
+        end
+
+        unknown_formatter = formatters.find { |formatter| !SUPPORTED_FORMATTERS.include?(formatter) }
+        raise ArgumentError, "Unsupported formatter: #{unknown_formatter}" if unknown_formatter
+
+        formatters.uniq
+      end
+
+      def normalize_mode(value)
+        return 'synthetic' if value.nil?
+
+        mode = value.to_s
+        raise ArgumentError, "Unsupported mode: #{mode}" unless SUPPORTED_MODES.include?(mode)
+
+        mode
+      end
+
+      def build_command(args)
+        bin_path = File.expand_path('../../../bin/prd', __dir__)
+        command = ['bundle', 'exec', 'ruby', bin_path, args[:path]]
+        command << '--mode' << args[:mode]
+
+        args[:formatters].each do |formatter|
+          command << '-t' << formatter
+        end
+
+        if args[:config]
+          command << '-c' << File.expand_path(args[:config], @pwd)
+        end
+
+        if args[:out]
+          command << '-o' << File.expand_path(args[:out], @pwd)
+        end
+
+        command
+      end
+
+      def build_summary(args:, stdout:, parsed_json:)
+        parsed = parsed_json || parse_simple_summary(stdout)
+        return { passed: nil, failed: nil, pending: nil } unless parsed
+
+        pending_count = parsed[:pending]
+        if pending_count.nil? && args[:mode] == 'synthetic' && args[:formatters].include?('simple')
+          pending_count = pending_count_from_simple_output(stdout)
+        end
+
+        {
+          passed: parsed[:passed],
+          failed: parsed[:failed],
+          pending: pending_count
+        }
+      end
+
+      def parse_json_summary(args:, stdout:, base_out:)
+        return nil unless args[:formatters].include?('json')
+
+        json_payload = nil
+        if base_out
+          json_path = "#{base_out}#{FORMATTER_EXTENSIONS['json']}"
+          json_payload = File.read(json_path) if File.exist?(json_path)
+        elsif args[:formatters] == ['json']
+          json_payload = stdout
+        end
+
+        return nil unless json_payload
+
+        parsed = JSON.parse(json_payload)
+        summary = parsed['summary'] || {}
+
+        pending = nil
+        events = parsed['events']
+        if events.is_a?(Array)
+          pending = events.count do |event|
+            (event['type'] == 'test_result' && event['status'] == 'PENDING') || event['type'] == 'pending'
+          end
+        end
+
+        {
+          passed: summary['passed'],
+          failed: summary['failed'],
+          pending: pending
+        }
+      rescue JSON::ParserError
+        nil
+      end
+
+      def parse_simple_summary(stdout)
+        plain_output = strip_ansi(stdout)
+        matches = plain_output.scan(/(\d+)\s+passed,\s+(\d+)\s+failed/)
+        return nil if matches.empty?
+        match = matches.last
+
+        {
+          passed: match[0].to_i,
+          failed: match[1].to_i,
+          pending: nil
+        }
+      end
+
+      def pending_count_from_simple_output(stdout)
+        strip_ansi(stdout).scan(/^PENDING:\s+/).count
+      end
+
+      def strip_ansi(text)
+        text.gsub(/\e\[[0-9;]*m/, '')
+      end
+
+      def build_artifacts(args:, base_out:)
+        reports = []
+        if base_out
+          args[:formatters].each do |formatter|
+            report_path = "#{base_out}#{FORMATTER_EXTENSIONS.fetch(formatter)}"
+            reports << {
+              type: formatter,
+              path: report_path,
+              exists: File.exist?(report_path)
+            }
+          end
+        end
+
+        annex_dir = if base_out
+          candidate = File.join(File.dirname(base_out), 'annex')
+          candidate if Dir.exist?(candidate)
+        end
+
+        {
+          base_out: base_out,
+          reports: reports,
+          annex_dir: annex_dir
+        }
+      end
+
+      def output_base_path(out_path)
+        resolved = File.expand_path(out_path, @pwd)
+        if directory_like_path?(resolved)
+          File.join(resolved, DEFAULT_REPORT_BASENAME)
+        else
+          ext = File.extname(resolved).downcase
+          known_extensions = FORMATTER_EXTENSIONS.values
+          known_extensions.include?(ext) ? resolved[...-ext.length] : resolved
+        end
+      end
+
+      def directory_like_path?(path)
+        path.end_with?(File::SEPARATOR) || Dir.exist?(path)
+      end
+    end
+  end
+end

data/lib/pr_d/mcp/server.rb

@@ -0,0 +1,178 @@
+require 'json'
+
+module PrD
+  module Mcp
+    class Server
+      JSONRPC_VERSION = '2.0'.freeze
+      MCP_PROTOCOL_VERSION = '2024-11-05'.freeze
+      RUN_SPECS_TOOL_NAME = 'run_specs'.freeze
+
+      def initialize(input: $stdin, output: $stdout, run_specs_tool: RunSpecsTool.new)
+        @input = input
+        @output = output
+        @run_specs_tool = run_specs_tool
+      end
+
+      def run
+        while (message = read_message)
+          response = process_message(message)
+          write_message(response) if response
+        end
+      end
+
+      def process_message(message)
+        id = message['id']
+        method = message['method']
+        params = message['params'] || {}
+
+        case method
+        when 'initialize'
+          success_response(id, initialize_result)
+        when 'notifications/initialized'
+          nil
+        when 'tools/list'
+          success_response(id, tools_list_result)
+        when 'tools/call'
+          success_response(id, handle_tool_call(params))
+        else
+          return nil unless id
+
+          error_response(id, -32601, "Method not found: #{method}")
+        end
+      rescue StandardError => e
+        return nil unless id
+
+        error_response(id, -32603, "Internal error: #{e.message}")
+      end
+
+      private
+
+      def initialize_result
+        {
+          protocolVersion: MCP_PROTOCOL_VERSION,
+          capabilities: {
+            tools: {}
+          },
+          serverInfo: {
+            name: 'probatio-diabolica-mcp',
+            version: PrD::VERSION
+          }
+        }
+      end
+
+      def tools_list_result
+        {
+          tools: [run_specs_definition]
+        }
+      end
+
+      def run_specs_definition
+        {
+          name: RUN_SPECS_TOOL_NAME,
+          description: 'Run probatio_diabolica specs from a file or directory path.',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              path: { type: 'string', description: 'File or directory path containing spec(s).' },
+              config: { type: 'string', description: 'Optional config file, equivalent to `-c`.' },
+              out: { type: 'string', description: 'Optional output base path, equivalent to `-o`.' },
+              formatters: {
+                type: 'array',
+                description: 'Optional formatter list.',
+                items: {
+                  type: 'string',
+                  enum: RunSpecsTool::SUPPORTED_FORMATTERS
+                }
+              },
+              mode: {
+                type: 'string',
+                enum: RunSpecsTool::SUPPORTED_MODES,
+                description: 'Optional output mode.'
+              }
+            },
+            required: ['path']
+          }
+        }
+      end
+
+      def handle_tool_call(params)
+        tool_name = params['name']
+        arguments = params['arguments'] || {}
+
+        return tool_error("Unknown tool: #{tool_name}") unless tool_name == RUN_SPECS_TOOL_NAME
+
+        result = @run_specs_tool.call(arguments)
+
+        unless result[:ok]
+          return tool_error(result.dig(:logs, :stderr) || 'run_specs failed unexpectedly.')
+        end
+
+        tool_success(result)
+      rescue ArgumentError => e
+        tool_error(e.message)
+      end
+
+      def tool_success(payload)
+        {
+          content: [{ type: 'text', text: JSON.pretty_generate(payload) }],
+          structuredContent: payload
+        }
+      end
+
+      def tool_error(message)
+        {
+          content: [{ type: 'text', text: message }],
+          isError: true
+        }
+      end
+
+      def success_response(id, result)
+        {
+          jsonrpc: JSONRPC_VERSION,
+          id: id,
+          result: result
+        }
+      end
+
+      def error_response(id, code, message)
+        {
+          jsonrpc: JSONRPC_VERSION,
+          id: id,
+          error: {
+            code: code,
+            message: message
+          }
+        }
+      end
+
+      def read_message
+        headers = {}
+
+        while (line = @input.gets)
+          line = line.strip
+          break if line.empty?
+
+          key, value = line.split(':', 2)
+          next unless key && value
+
+          headers[key.downcase] = value.strip
+        end
+
+        return nil if headers.empty?
+
+        content_length = Integer(headers.fetch('content-length'))
+        raw = @input.read(content_length)
+        JSON.parse(raw)
+      rescue EOFError
+        nil
+      end
+
+      def write_message(message)
+        payload = JSON.dump(message)
+        @output.write("Content-Length: #{payload.bytesize}\r\n\r\n")
+        @output.write(payload)
+        @output.flush
+      end
+    end
+  end
+end

data/lib/pr_d/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PrD
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/probatio_diabolica.gemspec

@@ -22,17 +22,20 @@ Gem::Specification.new do |spec|
   spec.files = Dir[
     "lib/**/*.rb",
     "bin/prd",
+    "bin/prd_mcp",
     "README.md",
     "Gemfile",
     "probatio_diabolica.gemspec"
   ]
   spec.bindir        = "bin"
   spec.executables << "prd"
+  spec.executables << "prd_mcp"
   spec.require_paths = ["lib"]
 
   spec.add_dependency "ruby_llm"
   spec.add_dependency 'ruby_llm-schema'
   spec.add_dependency 'pdf-reader'
   spec.add_dependency 'prawn'
+  spec.add_dependency 'rouge'
   spec.add_dependency 'zeitwerk'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: probatio_diabolica
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Laporte Mathieu
@@ -65,6 +65,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rouge
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -85,13 +99,16 @@ email:
 - mathieu.laporte+prd@gmail.com
 executables:
 - prd
+- prd_mcp
 extensions: []
 extra_rdoc_files: []
 files:
 - Gemfile
 - README.md
 - bin/prd
+- bin/prd_mcp
 - lib/pr_d.rb
+- lib/pr_d/code.rb
 - lib/pr_d/formatters.rb
 - lib/pr_d/formatters/formatter.rb
 - lib/pr_d/formatters/html_formatter.rb
@@ -108,6 +125,8 @@ files:
 - lib/pr_d/matchers/includes_matcher.rb
 - lib/pr_d/matchers/llm_matcher.rb
 - lib/pr_d/matchers/matcher.rb
+- lib/pr_d/mcp/run_specs_tool.rb
+- lib/pr_d/mcp/server.rb
 - lib/pr_d/version.rb
 - lib/probatio_diabolica.rb
 - probatio_diabolica.gemspec