mailmate 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88d6dabd89e0d5e37026235c1e97fff082e6f1e2a81c6fe372ba224dacacbe7c
-  data.tar.gz: 816b35b9b2fa41b41e4f08e851af0b125c7fc7240c0deafdd29349b68672c107
+  metadata.gz: 34b3eb13fdd2c2a9ec690ec623a543c074014dc1e6b3f82aa3abe6e6cb8de2c7
+  data.tar.gz: 11417aa45bfa1980f946b6838ca4451c79e6fb2244976c5879253c37b96cbb72
 SHA512:
-  metadata.gz: 046523126145151e5c82cfbced95b6a00edba71825c2fa87d411054e26363f4a893c3afad22a0bb013ac08779da0ebf8c25e4787adfb84cf7670dfb4c5aada50
-  data.tar.gz: 9eb1bb09367e35cb763789857152258a4d104172fe93655f6966e8f473cc4b127df87cfd2e534cbce42415733560cffcf18009034ea77e72d43066dc3bf0d620
+  metadata.gz: d724662f4b0084dbbe7bb712f4678976b30654d26fa67479d038d203034c951a95d90b08c5e7266c7461103299ddb9c6dab03cd8ff3c83d09c7d2a6a9e0c7321
+  data.tar.gz: 1a56382a2a6792e0a0df2fc5e83ad26c51158238720c21bc9f7d222b3047dc013eb473dbee623ad0b23f6c53075489603b37d41f789f3019551bda0532443213

data/README.md

@@ -106,7 +106,7 @@ mmdiscover
 
 **On the vast majority of Ruby setups (stock `arm64-darwin` or `x86_64-darwin` Ruby) this step is a no-op — nokogiri ships a precompiled binary, you can skip the rest of this section and move on.** Keep reading only if your `gem install` actually fails.
 
-`mmmessage --markdown` renders HTML-only message bodies as readable markdown. It needs the `reverse_markdown` gem, which has `nokogiri` as a transitive dependency:
+`mmmessage --markdown` renders HTML-only message bodies as readable markdown, and (since 2.2.0) the quoted original of a reply or forward is the parent's HTML part rendered the same way, so it reads as the author laid it out. Both need the `reverse_markdown` gem, which has `nokogiri` as a transitive dependency:
 
 ```bash
 gem install reverse_markdown
@@ -114,7 +114,7 @@ gem install reverse_markdown
 
 That single command pulls `nokogiri` in automatically — no separate `gem install nokogiri` step. This is kept out of the base install because nokogiri ships a native extension. On Ruby/platform combinations without a precompiled match nokogiri falls back to compiling from source — it vendors its own libxml2/libxslt, but it does need a C compiler, which on macOS means Xcode Command Line Tools (`xcode-select --install`). If `gem install reverse_markdown` fails, that's almost certainly the cause.
 
-If you never use `--markdown`, you never pay any of this. If you do invoke `--markdown` without the gem installed, `mmmessage` warns with a clear install hint and falls back to the raw HTML body (it does not abort — so the in-process MCP server survives a missing optional dependency). The plugin launcher and one-line installer attempt this gem automatically and degrade the same way if it fails to build.
+If you never use `--markdown` or compose from a parent, you never pay any of this. Without the gem, a reply/forward quotes the plain-text part instead (or an honest placeholder for an HTML-only parent); if you invoke `--markdown` without it, `mmmessage` warns with a clear install hint and falls back to the raw HTML body (it does not abort — so the in-process MCP server survives a missing optional dependency). The plugin launcher and one-line installer attempt this gem automatically and degrade the same way if it fails to build.
 
 ### From source (development)
 
@@ -385,7 +385,7 @@ mm-send -f you@x --reply-all-to 12345 --send-now <<<"body"
 mm-send -f you@x --forward 12345 -t someone@example.com <<<"FYI"
 ```
 
-The parent is an eml-id or an RFC Message-ID. **Fields you pass explicitly win; fields you omit follow normal reply rules**, and overriding a visible field never drops the threading headers. `--no-quote` suppresses the quoted original. `--print-prefill` prints the derived fields as JSON and sends nothing — the hook for other tools that fill their own compose form.
+The parent is an eml-id or an RFC Message-ID. **Fields you pass explicitly win; fields you omit follow normal reply rules**, and overriding a visible field never drops the threading headers. `--no-quote` suppresses the quoted original (the parent's HTML part rendered to markdown when it has one, else its plain text — see `docs/Composing and threading.md`). `--print-prefill` prints the derived fields as JSON and sends nothing — the hook for other tools that fill their own compose form.
 
 Hand-assembly via `--header` still works and is the escape hatch when the parent isn't in MailMate's index. The `mailmate-mcp` `send` / `draft` tools take `in_reply_to` and `references` directly.
 

data/docs/Composing and threading.md

@@ -47,6 +47,8 @@ mm-send -f you@x -t them@y -s "Re: foo" \
 
 When a parent is supplied, **explicitly-passed fields always win; omitted fields follow normal reply rules** (parent's sender becomes the recipient, subject becomes `Re: <original>`, the quoted original seeds the body, reply-all additionally carries the other recipients minus your own identities).
 
+**What "the quoted original" is** (2.2.0): the parent's HTML part rendered to markdown when it has one — so the quote reads as the author laid it out (headings, links, emphasis) rather than as the text/plain alternative many senders neglect — else the plain part, else an honest placeholder saying there is no readable text. Raw HTML is never quoted, and a quote is never silently empty. The rendering needs the optional `reverse_markdown` gem (the same one `mmmessage --markdown` uses); without it the plain part is used. Same in every mode; a forward wraps it in the `---------- Forwarded message ----------` header block, a reply prefixes it with `> `.
+
 This rule is uniform across every surface that composes from a parent — the CLI flags above and markdownr's compose popup — so a caller who learns it once can predict all of them. Overriding a visible field never drops the threading headers.
 
 ## Header safety

data/lib/mailmate/cli/message.rb

@@ -146,42 +146,21 @@ module Mailmate
         ct.include?("text/html") || body =~ /\A\s*<(?:!doctype html|html|body|head)\b/i
       end
 
-      # HTML → clean markdown for terminal reading. Three preprocessing /
-      # postprocessing passes beyond plain reverse_markdown:
-      #   1. Drop <style> and <script> blocks before conversion — pure clutter
-      #      that reverse_markdown otherwise dumps as inline text.
-      #   2. Strip zero-width spacers that newsletters use to control inbox
-      #      preview text (U+034F, U+200B/C/D, U+FEFF). Without this, you get
-      #      long runs of `͏ ` in the output.
-      #   3. Collapse 3+ consecutive blank lines into a single blank line.
+      # HTML → clean markdown for terminal reading, via the shared converter
+      # (Mailmate::HtmlMarkdown — ReplyPrefill quotes HTML-only parents with
+      # the same passes). Degrades to the raw HTML with a hint rather than
+      # `exit`: a library method must not kill its host, and the in-process
+      # MCP server would otherwise die on the SystemExit (its dispatch rescues
+      # StandardError only).
       def html_to_markdown(html)
-        begin
-          require "nokogiri"
-          require "reverse_markdown"
-        rescue LoadError => e
-          warn "mmmessage --markdown needs the reverse_markdown gem (which pulls nokogiri)."
-          warn "Install it with:  gem install reverse_markdown"
-          warn "(underlying: #{e.message}) — falling back to raw HTML."
-          # Degrade to the raw HTML rather than `exit`: a library method must
-          # not kill its host, and the in-process MCP server would otherwise
-          # die on the SystemExit (its dispatch rescues StandardError only).
-          return html
-        end
-        doc = Nokogiri::HTML(html)
-        doc.css("style, script").remove
-        md = ReverseMarkdown.convert(doc.to_html)
-        # U+034F combining grapheme joiner, U+200B ZWSP, U+200C ZWNJ,
-        # U+200D ZWJ, U+FEFF BOM/ZWNBSP — newsletter preview-text padding.
-        md.gsub!(/[\u034F\u200B\u200C\u200D\uFEFF]/, "")
-        # Convert non-breaking spaces to regular spaces so rstrip can collapse
-        # them. Newsletter preview-text padding often uses runs of &nbsp; which
-        # Ruby's .rstrip leaves alone otherwise.
-        md.gsub!(/[\u00A0\u1680\u2000-\u200A\u202F\u205F\u3000]/, " ")
-        # Strip trailing whitespace per line - the spaces between the
-        # now-removed zero-width chars otherwise leave long whitespace runs.
-        md = md.lines.map(&:rstrip).join("\n")
-        md.gsub!(/\n{3,}/, "\n\n")
-        md.strip
+        require_relative "../html_markdown"
+        md = Mailmate::HtmlMarkdown.convert(html)
+        return md if md
+
+        warn "mmmessage --markdown needs the reverse_markdown gem (which pulls nokogiri)."
+        warn "Install it with:  gem install reverse_markdown"
+        warn "Falling back to raw HTML."
+        html
       end
     end
   end

data/lib/mailmate/html_markdown.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Mailmate
+  # @api public
+  #
+  # HTML → clean markdown, shared by `mmmessage --markdown` (terminal reading)
+  # and ReplyPrefill (quoting an HTML-only parent in a forward or reply).
+  #
+  # Depends on reverse_markdown (which pulls nokogiri), an OPTIONAL dependency
+  # so the base install stays free of native extensions. `available?` says
+  # whether the converter can run; `convert` returns nil when it can't, and
+  # each caller decides what an honest fallback looks like for its surface —
+  # mmmessage prints the raw HTML with a hint, a prefill uses a placeholder.
+  #
+  # Three passes beyond plain reverse_markdown, all learned from newsletters:
+  #   1. Drop <style> / <script> blocks and HTML comments before conversion —
+  #      pure clutter that reverse_markdown otherwise dumps as inline text.
+  #   2. Strip zero-width spacers used to control inbox preview text (U+034F,
+  #      U+200B/C/D, U+FEFF) and turn non-breaking spaces into plain ones, or
+  #      the output carries long runs of `͏ `.
+  #   3. Trim trailing whitespace per line and collapse 3+ blank lines to one.
+  module HtmlMarkdown
+    extend self
+
+    def available?
+      require "nokogiri"
+      require "reverse_markdown"
+      true
+    rescue LoadError
+      false
+    end
+
+    # Markdown String, or nil when the optional gems are missing.
+    def convert(html)
+      return nil unless available?
+
+      doc = Nokogiri::HTML(html.to_s)
+      doc.css("style, script").remove
+      # Comments too: newsletter templates leave `<!-- tdMobZ1BottomNew-->`
+      # markers that reverse_markdown would otherwise print verbatim.
+      doc.xpath("//comment()").remove
+      md = ReverseMarkdown.convert(doc.to_html)
+      # U+034F combining grapheme joiner, U+200B ZWSP, U+200C ZWNJ,
+      # U+200D ZWJ, U+FEFF BOM/ZWNBSP — newsletter preview-text padding.
+      md.gsub!(/[\u034F\u200B\u200C\u200D\uFEFF]/, "")
+      # Non-breaking spaces (and their Unicode cousins) → plain spaces so the
+      # per-line rstrip below can collapse the padding they hold open.
+      md.gsub!(/[\u00A0\u1680\u2000-\u200A\u202F\u205F\u3000]/, " ")
+      md = md.lines.map(&:rstrip).join("\n")
+      md.gsub!(/\n{3,}/, "\n\n")
+      md.strip
+    end
+  end
+end

data/lib/mailmate/reply_prefill.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "header_value"
+require_relative "html_markdown"
 
 module Mailmate
   # @api public
@@ -138,30 +139,47 @@ module Mailmate
     # Reply: email-classic "On <date>, <sender> wrote:" + a `> `-prefixed body.
     # Forward: the conventional un-prefixed forwarded-message block with its
     # own header summary, since the recipient has never seen the original.
+    #
+    # Which body gets quoted, in both modes: the HTML part rendered to
+    # markdown first — so the quote reads as the author laid it out
+    # (headings, links, emphasis) rather than as the text/plain alternative
+    # senders often neglect — then the plain part, then an honest placeholder
+    # when neither yields text (an HTML-only source with reverse_markdown not
+    # installed). A quote is never silently empty, and raw HTML is never
+    # quoted. (Until 2026-09-04 a reply preferred the plain part and a forward
+    # of an HTML-only message quoted nothing at all — the bug that prompted
+    # this: a bank alert forwarded as a bare header block.)
     def derive_quoted_body(mail, mode)
-      body = plain_body(mail)
       from = presence(mail["from"]&.value.to_s.strip) || "(unknown sender)"
       date = mail["date"]&.value.to_s.strip
 
       if mode == "forward"
+        body = quotable_body(mail) || FORWARD_PLACEHOLDER
         header = ["---------- Forwarded message ----------",
                   "From: #{from}",
                   ("Date: #{date}" unless date.empty?),
                   "Subject: #{mail.subject.to_s.strip}",
                   ("To: #{mail['to'].value}" if mail["to"])].compact.join("\n")
-        return "#{header}\n\n#{body}"
+        return "#{header}\n\n#{body.sub(/\n+\z/, '')}\n"
       end
 
       attribution = date.empty? ? "#{from} wrote:" : "On #{date}, #{from} wrote:"
-      return "#{attribution}\n> [no plain-text alternative — paste the original manually]\n" if body.strip.empty?
+      body = quotable_body(mail)
+      return "#{attribution}\n> #{REPLY_PLACEHOLDER}\n" if body.nil?
 
       quoted = body.sub(/\n+\z/, "").split("\n", -1).map { |l| "> #{l}".rstrip }.join("\n")
       "#{attribution}\n#{quoted}\n"
     end
 
-    # The text/plain alternative, or "" when the message is HTML-only. We do
-    # NOT synthesize text from the HTML part here: a lossy auto-conversion
-    # quoted back to the original sender is worse than an honest placeholder.
+    REPLY_PLACEHOLDER = "[no plain-text alternative — paste the original manually]"
+    FORWARD_PLACEHOLDER = "[the original has no readable text — it is HTML-only and the reverse_markdown gem is not installed; attach it or paste manually]"
+
+    # HTML-as-markdown, else plain text, else nil.
+    def quotable_body(mail)
+      presence(html_body_markdown(mail)) || presence(plain_body(mail))
+    end
+
+    # The text/plain alternative, or "" when the message is HTML-only.
     def plain_body(mail)
       part = mail.multipart? ? mail.text_part : mail
       return "" if part.nil?
@@ -172,6 +190,19 @@ module Mailmate
       ""
     end
 
+    # The text/html part rendered to markdown (Mailmate::HtmlMarkdown), or ""
+    # when there is no HTML part or the optional converter is missing.
+    # `decoded` (not `body.decoded`) so the part's declared charset — the
+    # iso-8859-1 of a bank alert — is transcoded to UTF-8 before parsing.
+    def html_body_markdown(mail)
+      part = mail.multipart? ? mail.html_part : (mail.content_type.to_s.downcase.include?("text/html") ? mail : nil)
+      return "" if part.nil?
+
+      Mailmate::HtmlMarkdown.convert(part.decoded.to_s).to_s
+    rescue StandardError
+      ""
+    end
+
     # Mail's address fields raise on malformed input often enough that a reply
     # to a slightly-broken message shouldn't blow up the whole derivation.
     def addresses(field)

data/lib/mailmate/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mailmate
-  VERSION = "2.1.0"
+  VERSION = "2.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mailmate
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Brian Murphy-Dye
@@ -145,6 +145,7 @@ files:
 - lib/mailmate/flag_check.rb
 - lib/mailmate/header_reader.rb
 - lib/mailmate/header_value.rb
+- lib/mailmate/html_markdown.rb
 - lib/mailmate/identity.rb
 - lib/mailmate/index_reader.rb
 - lib/mailmate/lexer.rb