mailmate 1.9.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd43afdf338a47a4616748d1e3ecb7781466ee73c836030bb9fdd763af1e65e3
-  data.tar.gz: d0d87cfbe4166a9aa8868e237ff2fc628a3d00b57f8de8079eacdb4cb4282de1
+  metadata.gz: 88d6dabd89e0d5e37026235c1e97fff082e6f1e2a81c6fe372ba224dacacbe7c
+  data.tar.gz: 816b35b9b2fa41b41e4f08e851af0b125c7fc7240c0deafdd29349b68672c107
 SHA512:
-  metadata.gz: 052c4619e7cf07129903242c5d8081f61ae64a46371cdf04fc5df0a6f1dbbef982a4e944e5629d12aa82ff036f14016080fb0e77fc814e23f0a9595ef2064962
-  data.tar.gz: 1a9918739f80c5b5d46030214b58e9c8dcb87ba76e12c5dee14c9c79f2e96de34dc3bf2461f528edc9f22deb1e1f5497566e14c58d31f981e42cd8a819c76c65
+  metadata.gz: 046523126145151e5c82cfbced95b6a00edba71825c2fa87d411054e26363f4a893c3afad22a0bb013ac08779da0ebf8c25e4787adfb84cf7670dfb4c5aada50
+  data.tar.gz: 9eb1bb09367e35cb763789857152258a4d104172fe93655f6966e8f473cc4b127df87cfd2e534cbce42415733560cffcf18009034ea77e72d43066dc3bf0d620

data/README.md

@@ -169,8 +169,11 @@ mmsearch 's "invoice due" !draft'
 # Received in May 2026
 mmsearch 'd 2026-05'
 
-# Custom columns + cap results + raw CSV (no padding)
+# Custom columns + the 20 newest + raw CSV (no padding)
 mmsearch 'f acme' 'id flags subject from' --limit 20 --no-align
+
+# The 10 newest from acme, listed by sender (not the 10 alphabetically-first senders)
+mmsearch 'f acme' --limit 10 --sort from
 ```
 
 **Quicksearch syntax.** The search-string is a list of specs combined with **AND**; a bare `or` separates alternatives, and AND binds tighter (no parens — write `(f bob or f ann) s invoice` out as `f bob s invoice or f ann s invoice`). After `or`, a bare first term inherits the modifier in force: `d 2024 or 2025 or 2y`. Wrap multi-word terms in `"double quotes"` (also how to search for the literal word "or"). `mmsearch --help` is the canonical, always-current rendering of this table.
@@ -196,7 +199,9 @@ Dates match on the **display-zone day** — the same day the `date`/`time` outpu
 
 The `--mailbox` argument accepts an account, an `account/path`, a bare mailbox name matched across accounts, or a **smart-mailbox name** (e.g. `Newsletters`, `Receipts`, `Priority`) whose filter is ANDed into the search.
 
-**Output fields.** Default columns are `flags date time direction party subject`. Prefix a field list with `+` to add to the defaults; a bare list replaces them (`id` is always the first column).
+**Output fields.** Default columns are `flags date time direction party subject`. Prefix a field list with `+` to add to the defaults; a bare list replaces them (include `id` yourself if you want it).
+
+**Limiting and ordering.** `--limit N` returns the N *newest* matches, chosen after the full scan; `--limit-by KEY[:asc|desc]` changes which rows survive (`date:asc` = the N oldest). `--sort KEY[:asc|desc]` orders the emitted rows independently, so `--limit 10 --sort from` is the ten newest shown by sender. Bare `--sort asc|desc|none` still means date; a bare key reads the way the key does (date/time newest-first, text A→Z); ties break newest-first. A truncated result says so on stderr (`[limit] showing 200 of 319 matches …`) so stdout stays clean CSV. `--scan-limit N` is a different thing: it stops the *scan* after N matches in undefined order — a speed bound for slow `--all` body scans, never a way to pick rows. (Before 2.0, `--limit` had those scan-cap semantics: N arbitrary matches, however sorted.) `--offset N` skips the first N rows of that ordering before taking `--limit` — rows 1001–1200 newest-first is `--offset 1000 --limit 200`; offsets drift as mail arrives, so a date term (`d <2026-08-25`) is the stable way to page a live mailbox. `--stats` replaces the prose notices with one machine-readable line, first on stderr — `stats: {"schema":1,"matches":321,"returned":3,"scan_capped":false,…}` — whose keys are additive-only; scripts and the MCP server read that instead of parsing prose.
 
 | Field | What it shows |
 |---|---|

data/lib/mailmate/cli/search.rb

@@ -4,6 +4,8 @@ require "mail"
 require "optparse"
 require "date"
 require "csv"
+require "json"
+require "stringio"
 
 module Mailmate
   module CLI
@@ -38,6 +40,27 @@ module Mailmate
         "archive"   => "a",
       }.freeze
 
+      # One matched message on its way to the output. `cells` are the
+      # extracted output columns in `fields` order; `keys` holds the values
+      # of any sort/limit key that is NOT an output column (extracted while
+      # the message was live, so ordering never re-reads a .eml); `instant`
+      # is the absolute send time (nil when unknown); `index` is scan order,
+      # the last-resort tie-break. Ordering keys off these, never off the
+      # cells — a bare fields list may omit `id`, and the old
+      # `rows[0].to_i` shortcut silently sorted such runs by readdir order.
+      Row = Struct.new(:eml_id, :index, :instant, :cells, :keys) do
+        def instant_or_epoch = instant || Time.at(0)
+      end
+
+      # `--sort` / `--limit-by` values: `{ key: <field>, dir: :asc|:desc }`,
+      # or :none (sort only). Omitted `--sort` keeps the historical
+      # date-ascending output; omitted `--limit-by` keeps the N newest.
+      DEFAULT_SORT     = { key: "date", dir: :asc }.freeze
+      DEFAULT_LIMIT_BY = { key: "date", dir: :desc }.freeze
+      # A bare KEY (no :DIR) reads the way the key does: dates newest-first,
+      # text A→Z.
+      DESC_BY_DEFAULT = %w[date time].freeze
+
       # All output fields are now index-tier: MailMate maintains a per-header
       # binary index under Database.noindex/Headers/, so extracting from/to/
       # subject/etc. doesn't require opening the .eml. Spec/filter matching
@@ -63,22 +86,57 @@ module Mailmate
 
       def run(argv)
         opts = {
-          mailbox: "all", limit: nil, headers_only: false, all: false,
+          mailbox: "all", limit: nil, offset: 0, scan_limit: nil, limit_by: DEFAULT_LIMIT_BY,
+          headers_only: false, all: false,
           exclude_quoted: false,
-          header: true, align: true, sort: :asc,
+          header: true, align: true, sort: DEFAULT_SORT, stats: false,
         }
 
         parser = build_parser(opts)
-        parser.parse!(argv)
+        begin
+          parser.parse!(argv)
+        rescue OptionParser::ParseError => e
+          warn e.message
+          return 2
+        end
+
+        return search(argv, opts) unless opts[:stats]
+
+        # --stats promises one machine-readable line FIRST on stderr, but
+        # the run says other things there before the total is known (the
+        # translation notice, dead-branch warnings, [skip]s). Hold all of it
+        # back and release it, in order, after the stats line. A run that
+        # never reached the scan (usage error) produces no stats line — the
+        # held output is still released, so nothing is swallowed.
+        held = StringIO.new
+        real_err = $stderr
+        $stderr = held
+        begin
+          search(argv, opts)
+        ensure
+          $stderr = real_err
+          $stderr.puts "#{STATS_PREFIX}#{JSON.generate(opts[:stats_result])}" if opts[:stats_result]
+          $stderr.print held.string
+        end
+      end
+
+      # The `--stats` contract: this prefix, then one JSON object, on the
+      # first stderr line. `matches`, `returned` and `scan_capped` are always
+      # present; keys are additive-only, and `schema` increments only on a
+      # change that breaks that promise. Consumers (markdownr's search_mail,
+      # mailmate-mcp) parse this instead of the prose notices.
+      STATS_PREFIX = "stats: "
+      STATS_SCHEMA = 1
 
+      def search(argv, opts)
         self.date_order = opts[:european] ? :dmy : :mdy
 
-        search_string = argv[0] || DEFAULT_SEARCH
+        query = argv[0] || DEFAULT_SEARCH
         # Rewrite Gmail/Outlook-style key:value tokens to their exact
         # quicksearch equivalent — loudly, never silently: every rewrite is
         # announced on stderr so the transcript shows what actually ran (and
         # the caller learns the syntax). stdout stays clean CSV.
-        search_string, translations = Mailmate::SearchSyntax.translate(search_string, european: !!opts[:european])
+        search_string, translations = Mailmate::SearchSyntax.translate(query, european: !!opts[:european])
         if (notice = Mailmate::SearchSyntax.translation_notice(translations))
           warn notice
         end
@@ -163,36 +221,135 @@ module Mailmate
           opts: opts,
         )
 
-        sort_rows!(rows, opts[:sort])
-        emit_output(rows, fields, opts)
+        # The scan stops exactly at --scan-limit, so hitting it is inferable.
+        scan_capped = opts[:scan_limit] && rows.size >= opts[:scan_limit]
+        total = rows.size
+        rows = apply_limit(rows, opts[:limit], opts[:offset], opts[:limit_by], fields)
+        sort_rows!(rows, opts[:sort], fields)
+        emit_output(rows.map(&:cells), fields, opts)
+        # Truncation announces itself on stderr — same idiom as the
+        # zero-result hint below: stdout stays clean CSV, exit status stays
+        # 0. With --stats the JSON line carries it and the prose is
+        # suppressed. When the scan cap fired, the match total is itself a
+        # sample, so the [limit] notice's "of M" would be false precision;
+        # the scan notice speaks alone.
+        if opts[:stats]
+          opts[:stats_result] = {
+            schema: STATS_SCHEMA, matches: total, returned: rows.size,
+            limit: opts[:limit], offset: opts[:offset],
+            limit_by: order_to_s(opts[:limit_by]), sort: order_to_s(opts[:sort]),
+            scan_limit: opts[:scan_limit], scan_capped: !!scan_capped,
+            query: query, effective_query: search_string,
+          }
+        elsif scan_capped
+          warn "[scan-limit] stopped scanning after #{total} matches in undefined order — " \
+               "this is a sample, not the newest #{total}"
+        elsif rows.size < total
+          from = opts[:offset].positive? ? ", from #{opts[:offset] + 1}" : ""
+          warn "[limit] showing #{rows.size} of #{total} matches#{from} (#{describe_order(opts[:limit_by])}); " \
+               "add a date term such as `d 3d` to narrow, or raise --limit"
+        end
         # A query written in another mail system's dialect is not a syntax
         # error here — it parses as a literal term and quietly matches
         # nothing. Callers (people and agents alike) read that empty result
         # as "no such mail" and stop. Say so on stderr, so stdout stays
         # clean CSV and the exit status stays 0: the search DID run, it just
-        # cannot have found what the caller meant.
-        if rows.empty? && (hint = Mailmate::SearchSyntax.zero_result_hint(search_string))
+        # cannot have found what the caller meant. (Keyed on the match
+        # total, not the emitted rows: an --offset past the end is not a
+        # miss.)
+        if total.zero? && (hint = Mailmate::SearchSyntax.zero_result_hint(search_string))
           warn hint
         end
         0
       end
 
-      # ---- sort ---------------------------------------------------------------
+      # ---- ordering -----------------------------------------------------------
+      #
+      # Two orderings, two questions. `--limit-by` answers WHICH rows survive
+      # the cap (the N newest, by default); `--sort` answers the ORDER they
+      # are emitted in. They coincide when both are date — the default — and
+      # diverge exactly when MailMate's UI would: "sort by sender, limit 10"
+      # is the 10 newest shown by sender, not the 10 alphabetically-first
+      # senders. Both are applied AFTER the full scan; the only pre-scan
+      # bound is --scan-limit, which picks nothing (see build_parser).
+
+      # Parses a `--sort`/`--limit-by` value: bare `asc`/`desc` (date, kept
+      # for existing invocations), `none` (sort only), `KEY`, or `KEY:DIR`.
+      def parse_order(value, allow_none: false)
+        v = value.to_s.strip
+        return :none if v == "none" && allow_none
+        return { key: "date", dir: v.to_sym } if %w[asc desc].include?(v)
+        key, dir = v.split(":", 2)
+        key = "date" if key.nil? || key.empty?
+        unless VALID_FIELDS.include?(key)
+          raise OptionParser::InvalidArgument,
+                "#{value}: unknown field '#{key}' (valid: #{VALID_FIELDS.join(' ')})"
+        end
+        dir = (DESC_BY_DEFAULT.include?(key) ? "desc" : "asc") if dir.nil? || dir.empty?
+        unless %w[asc desc].include?(dir)
+          raise OptionParser::InvalidArgument,
+                "#{value}: direction must be asc or desc#{allow_none ? ' (or bare none)' : ''}"
+        end
+        { key: key, dir: dir.to_sym }
+      end
+
+      def order_to_s(order)
+        order == :none ? "none" : "#{order[:key]}:#{order[:dir]}"
+      end
 
-      # Sorts `rows` in place by the message's absolute send instant (UTC), so
-      # senders in different timezones still order correctly. The first column
-      # is always `id` (forced in `run`), which lets us hit the `#date` index
-      # without re-reading any .eml.
-      def sort_rows!(rows, mode)
-        return rows if mode == :none || rows.size < 2
-        reader = Mailmate::IndexReader.for("#date") rescue nil
-        epoch = Time.at(0)
-        rows.sort_by! do |r|
-          s = reader && (reader.value_for(r[0].to_i) rescue nil)
-          (s && !s.empty? && (fast_time(s) || (Time.parse(s) rescue nil))) || epoch
+      def describe_order(order)
+        return "scan order" if order == :none
+        what = order[:key] == "date" ? (order[:dir] == :desc ? "newest first" : "oldest first")
+                                     : "#{order[:key]} #{order[:dir] == :desc ? 'descending' : 'ascending'}"
+        "#{what} by #{order[:key]}"
+      end
+
+      # The sort key value for one row. `date` is the absolute send instant
+      # (so senders in different timezones still order correctly), `id` is
+      # numeric, everything else is the column text, case-folded.
+      def order_value(row, key, column)
+        case key
+        when "date" then row.instant_or_epoch
+        when "id"   then row.eml_id.to_i
+        else (column ? row.cells[column] : row.keys[key]).to_s.downcase
         end
-        rows.reverse! if mode == :desc
-        rows
+      end
+
+      # Orders `rows` in place by `order` (`{key:, dir:}`). The order is
+      # TOTAL: ties break newest-first, then by eml-id (in the date's
+      # direction when date is the key, else newest-first) — so "sorted by
+      # sender" lists each sender's mail newest-first, and two runs of the
+      # same query page identically (`--offset` depends on that). Ruby's
+      # sort is not stable, and stable-over-readdir would only preserve the
+      # undefined order this exists to get rid of.
+      def order_rows!(rows, order, fields)
+        return rows.sort_by!(&:index) if order == :none
+        return rows if rows.size < 2
+        key, sign = order[:key], (order[:dir] == :desc ? -1 : 1)
+        id_sign = key == "date" ? sign : -1
+        column = fields.index(key)
+        rows.sort! do |a, b|
+          c = (order_value(a, key, column) <=> order_value(b, key, column)) || 0
+          c *= sign
+          c = b.instant_or_epoch <=> a.instant_or_epoch if c.zero? && key != "date"
+          c = (a.eml_id.to_i <=> b.eml_id.to_i) * id_sign if c.zero?
+          c
+        end
+      end
+
+      # Keeps rows `offset` through `offset + limit` of the `limit_by`
+      # ordering, taken over the FULL match set. Returns the same array when
+      # no cap applies. Rows come back in limit-by order; `sort_rows!`
+      # re-orders them for output.
+      def apply_limit(rows, limit, offset, limit_by, fields)
+        return rows if offset.zero? && (limit.nil? || rows.size <= limit)
+        order_rows!(rows, limit_by, fields)
+        window = rows.drop(offset)
+        limit ? window.first(limit) : window
+      end
+
+      def sort_rows!(rows, order, fields)
+        order_rows!(rows, order, fields)
       end
 
       # ---- option parsing -----------------------------------------------------
@@ -213,14 +370,26 @@ module Mailmate
           o.separator "OPTIONS"
           o.on("--mailbox X", "Mailbox to search (default: all)") { |v| opts[:mailbox] = v }
           o.on("--fields F", "Fields list (alt to 2nd positional)") { |v| opts[:fields] = v }
-          o.on("--limit N", Integer, "Stop after N matches") { |n| opts[:limit] = n }
+          o.on("--limit N", Integer,
+               "Return at most N rows: the top N by --limit-by (default: the N newest), taken after the full scan. Announces truncation on stderr.") { |n| opts[:limit] = n }
+          o.on("--limit-by KEY[:DIR]",
+               "Which rows --limit keeps. KEY is any output field; DIR is asc|desc (bare date/time = desc, text keys = asc). Default: date:desc") { |v| opts[:limit_by] = parse_order(v) }
+          o.on("--offset N", Integer,
+               "Skip the first N rows of the --limit-by ordering before taking --limit: rows 1001-1200 newest-first is --offset 1000 --limit 200. Pages of a live mailbox drift as mail arrives; a date term (d <2026-08-25) is the stable way to page.") { |n|
+            raise OptionParser::InvalidArgument, "#{n}: offset cannot be negative" if n.negative?
+            opts[:offset] = n
+          }
+          o.on("--scan-limit N", Integer,
+               "Stop SCANNING after N matches, in undefined order — a speed bound for slow --all body scans, never a way to pick rows. Announces on stderr.") { |n| opts[:scan_limit] = n }
           o.on("--headers-only", "Skip body matching entirely") { opts[:headers_only] = true }
           o.on("--all", "Include un-indexed messages in body matching by lazily reading and parsing each .eml. Slow (tens of seconds to minutes on large archives). Default behavior matches MailMate's UI: only check messages MailMate has body-indexed — fast, but bounded.") { opts[:all] = true }
           o.on("--exclude-quoted", "Match body only against #unquoted text — skip MailMate's #quoted index (forwarded/replied-to text). Tightens search to fresh content; gets you closer to MailMate UI's body-search result set, at the cost of missing hits in quoted sections.") { opts[:exclude_quoted] = true }
           o.on("--no-header", "Suppress column header row") { opts[:header] = false }
           o.on("--no-align", "Plain CSV (no column padding)") { opts[:align] = false }
-          o.on("--sort MODE", %w[asc desc none],
-               "Sort rows by date+time: asc (default), desc, none") { |v| opts[:sort] = v.to_sym }
+          o.on("--sort KEY[:DIR]",
+               "Order of the emitted rows. asc|desc|none alone mean date; or any output field, e.g. from, subject:desc (bare date/time = desc, text keys = asc). Ties break newest-first. Default: date:asc") { |v| opts[:sort] = parse_order(v, allow_none: true) }
+          o.on("--stats",
+               "Write one machine-readable line FIRST on stderr — stats: {\"schema\":1,\"matches\":M,\"returned\":N,\"scan_capped\":false,...} — in place of the [limit]/[scan-limit] prose. Keys are additive-only; other stderr follows it.") { opts[:stats] = true }
           o.on("--european",
                "Slash dates are day-first: d 9/8/2026 = Aug 9 (default: month-first American)") { opts[:european] = true }
           o.separator ""
@@ -1166,7 +1335,7 @@ module Mailmate
       # Absolute send time for an eml_id, preferring the MailMate `#date` index
       # (cheap, no .eml read). Falls back to the parsed mail's Date header.
       def message_time(eml_id, mail)
-        s = (Mailmate::IndexReader.for("#date").value_for(eml_id.to_i) rescue nil)
+        s = (reader_for("#date")&.value_for(eml_id.to_i) rescue nil)
         if s && !s.empty?
           t = fast_time(s) || (Time.parse(s) rescue nil)
           return t if t
@@ -1191,7 +1360,7 @@ module Mailmate
       # safely interleave with UTF-8 strings in joined output rows.
       def header_index_value(eml_id, name)
         return nil if eml_id.nil?
-        v = Mailmate::IndexReader.for(name).value_for(eml_id.to_i)
+        v = reader_for(name)&.value_for(eml_id.to_i)
         v && v.dup.force_encoding("UTF-8").scrub
       rescue ArgumentError
         nil
@@ -1314,6 +1483,11 @@ module Mailmate
 
       def collect_rows(dirs:, specs:, fields:, smart_evaluator:, smart_literals:, filter_only_tier:, load_tier:, opts:)
         reset_run_caches!
+        # Sort/limit keys that are not output columns are extracted here,
+        # while the message is live, and ride along in Row#keys. `date` and
+        # `id` never need extracting: every row carries instant + eml_id.
+        extra_keys = [opts[:sort], opts[:limit_by]].grep(Hash).map { |o| o[:key] } - fields - %w[date id]
+        need_instant = opts[:sort] != :none || !opts[:limit].nil? || opts[:offset].positive?
         rows = []
         catch(:done) do
           dirs.each do |dir|
@@ -1354,8 +1528,10 @@ module Mailmate
                 end
               end
 
-              rows << fields.map { |f| extract(f, eml_id, path, mail) }
-              throw :done if opts[:limit] && rows.size >= opts[:limit]
+              cells = fields.map { |f| extract(f, eml_id, path, mail) }
+              keys  = extra_keys.to_h { |k| [k, extract(k, eml_id, path, mail)] }
+              rows << Row.new(eml_id, rows.size, need_instant ? message_time(eml_id, mail) : nil, cells, keys)
+              throw :done if opts[:scan_limit] && rows.size >= opts[:scan_limit]
             end
           end
         end

data/lib/mailmate/mcp.rb

@@ -127,9 +127,12 @@ module Mailmate
               type: "string",
               description: "Account, mailbox path, or smart-mailbox name. Default: all.",
             },
-            limit: { type: "integer", description: "Stop after N matches." },
+            limit: { type: "integer", description: "Return at most N rows — the top N by limit_by (default: the N newest), taken after the full scan. Truncation is announced on stderr, which is included in the result." },
+            limit_by: { type: "string", description: "Which rows limit keeps: KEY[:asc|desc], KEY any output field (bare date/time = desc, text keys = asc). Default: date:desc (the N newest)." },
+            offset: { type: "integer", description: "Skip the first N rows of the limit_by ordering before taking limit (rows 1001-1200 = offset 1000, limit 200). Offsets drift as mail arrives; a date term in the query (d <2026-08-25) is the stable way to page." },
+            scan_limit: { type: "integer", description: "Stop SCANNING after N matches, in undefined order — a speed bound for slow body scans, never a way to pick rows. Prefer limit." },
             headers_only: { type: "boolean", description: "Skip body matching (much faster on text searches)." },
-            sort: { type: "string", enum: %w[asc desc none], description: "Sort by date+time. Default: asc." },
+            sort: { type: "string", description: "Order of the emitted rows: asc|desc|none (by date), or KEY[:asc|desc] for any output field, e.g. from, subject:desc. Ties break newest-first. Default: asc (date)." },
             european: { type: "boolean", description: "Slash dates in the query are day-first (d 9/8/2026 = Aug 9). Default: month-first American." },
           },
           additionalProperties: false,
@@ -428,17 +431,30 @@ module Mailmate
     def call_search(args)
       argv = []
       argv.push("--mailbox", args["mailbox"].to_s)   if args["mailbox"]
-      argv.push("--limit",   args["limit"].to_i.to_s) if args["limit"]
+      argv.push("--limit",      args["limit"].to_i.to_s)      if args["limit"]
+      argv.push("--limit-by",   args["limit_by"].to_s)        if args["limit_by"]
+      argv.push("--scan-limit", args["scan_limit"].to_i.to_s) if args["scan_limit"]
+      argv.push("--offset",     args["offset"].to_i.to_s)     if args["offset"]
       argv.push("--headers-only")                    if args["headers_only"]
       argv.push("--sort",    args["sort"].to_s)      if args["sort"]
       argv.push("--european")                        if args["european"]
+      # Always ask for the stats line: it carries the true match total and
+      # the truncation facts as one JSON object, first on stderr, in place
+      # of the prose notices. It stays in the text (readable as-is) and is
+      # ALSO surfaced as structuredContent for clients that render it.
+      argv.push("--stats")
       # Positionals: search-string then fields. Only include if the caller
       # gave us either — otherwise let the CLI apply its defaults.
       if args.key?("query") || args["fields"]
         argv << (args["query"] || "")
         argv << args["fields"].to_s if args["fields"]
       end
-      run_cli(Mailmate::CLI::Search, argv)
+      res = run_cli(Mailmate::CLI::Search, argv)
+      if (m = res[:content].first[:text].match(/^#{Regexp.escape(Mailmate::CLI::Search::STATS_PREFIX)}(\{.*\})$/))
+        stats = (JSON.parse(m[1]) rescue nil)
+        res[:structuredContent] = { stats: stats } if stats
+      end
+      res
     end
 
     def call_message(args)

data/lib/mailmate/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mailmate
 version: !ruby/object:Gem::Version
-  version: 1.9.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Brian Murphy-Dye
@@ -182,7 +182,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.12
+rubygems_version: 4.0.19
 specification_version: 4
 summary: Ruby toolkit for MailMate on macOS — search, read, modify, send, and smart-mailbox
   evaluation