mailmate 0.2.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52941d76f7875e2944527026ed3d8584eb15e718dded7c7db5b75cad880be7d2
-  data.tar.gz: bb5f9463d23b07f6b6755c1c1c54326a060b9bd5680554399ff97f23137f7b6c
+  metadata.gz: d762c124b353823c34d4b87eb5748727ed2901a507f8bc67a0d74f22b1ab1350
+  data.tar.gz: c02381fd0d81be1e8793d85d3d838d40378bf2e99bc4d96f82405144171a73ed
 SHA512:
-  metadata.gz: ac99eb6fee19f727a953228a599f5ec29d741339776388547ff514403a838c990635c586881dfee5750c3a0c6a72f6c66bdcc513f3dba4ed85eb0e980b588357
-  data.tar.gz: 6a293bf66d563b80d9f9a0e2f0808fa32db6ba4bd40bea65fbb364a73e0fbef3d0aa715b284ad07f464a7cbb695825da4d2f614903699f1d3e527101e7135edc
+  metadata.gz: cf2901c2df5341834cdcabeed160b33ea4d797c36cdaf24ee14ce1f48020f3a34ac8ff37f5c06a29f659ff486246838b575f73e5cf34e2fae0e986a64949650e
+  data.tar.gz: bf8f8e7fc3944a32b279a7ac8448def35020a430c38bad95f8f08d63e4e67d9eeef08ddb98f6775b0ba1b428fc6c20e93f27379833e73de28dd6425788158e07

data/README.md

@@ -1,6 +1,6 @@
 # mailmate
 
-Ruby toolkit for [MailMate](https://freron.com) on macOS — a smart-mailbox filter engine, on-disk index readers, and CLI tools (`mmsearch`, `mmmessage`, `mm-modify`, `mm-send`, `mmdiscover`) for searching, reading, modifying, and sending mail.
+Ruby toolkit for [MailMate](https://freron.com) on macOS — a smart-mailbox filter engine, on-disk index readers, and CLI tools (`mmsearch`, `mmmessage`, `mmopen`, `mm-mailboxes`, `mmtags`, `mm-modify`, `mm-send`, `mmdiscover`) for searching, reading, modifying, and sending mail.
 
 **Requires macOS with MailMate installed.** The library code (filter parser, evaluator) works anywhere, but the integration with MailMate itself — AppleScript, on-disk index reads, the `emate` binary — is macOS-only by way of MailMate being macOS-only.
 
@@ -39,8 +39,56 @@ mmmessage 183715 --raw
 
 # Body only, no headers block
 mmmessage 183715 --text-only
+
+# Open in MailMate's UI instead of printing (delegates to mmopen)
+mmmessage 183715 --mailmate
+
+# Render an HTML-only message as clean markdown (no-op for text/plain bodies)
+mmmessage 183715 --markdown
+```
+
+`--markdown` uses `reverse_markdown` + Nokogiri preprocessing to drop `<style>`/`<script>` blocks and strip newsletter preview-text padding (zero-width chars, runs of non-breaking / figure / narrow spaces, etc.). Conversion quality is good for plain replies/threads and rough for marketing-newsletter HTML (which uses nested layout tables); the raw source is still available with `--raw`.
+
+### `mmopen` — open a message in MailMate's UI
+
+```bash
+# By eml-id, Message-ID, message:// URL, or mid: URL — all six input forms
+# that EmlLookup.resolve_id understands.
+mmopen 183715
+mmopen '<abc@example.com>'
+mmopen 'message://%3Cabc%40example.com%3E'
+
+# Print the mid: URL instead of opening it (useful in pipelines)
+mmopen 183715 --print
+```
+
+### `mm-mailboxes` — list accounts and mailboxes
+
+```bash
+# Grouped by account, with .eml counts per IMAP mailbox + smart-mailbox names
+mm-mailboxes
+
+# Skip counts (much faster on large stores)
+mm-mailboxes --no-count
+
+# Flat CSV (one row per mailbox; account repeated in column 1)
+mm-mailboxes --csv
 ```
 
+Account names are URL-decoded for display (`%40` → `@`). Smart-mailbox names appear in their own section with `-` for count (not calculated — would require evaluating each filter).
+
+### `mmtags` — list tags
+
+```bash
+# Tags actually applied to messages, sorted by usage count
+mmtags
+
+# Tags defined in MailMate → Preferences → Tags (may include unused ones)
+mmtags --defined
+```
+
+The default reads MailMate's `#flags` index (IMAP keywords, system flags excluded). The two views can differ: tags can be applied programmatically (via IMAP keyword) without being registered in Preferences, and tags can be defined in Preferences without being applied to any message yet.
+
 ### `mm-modify` — change message state
 
 ```bash
@@ -50,6 +98,16 @@ mm-modify 183715 read flag archive
 # Add a tag
 mm-modify 183715 tag urgent
 
+# Pure-move (one or more moves, nothing else): same-account moves take a
+# fast path — direct .eml rename on disk, no UI, no focus theft.
+mm-modify 183715 move Archive
+
+# Chain with other actions: everything (including the move) goes through
+# MailMate's UI in user-supplied order. We're already paying for the UI for
+# the tag/read; letting MailMate do the move too keeps its state in sync
+# with itself, no #source-index staleness window.
+mm-modify 183715 tag processed read move Archive
+
 # Dry-run first
 mm-modify 183715 archive --dry-run
 
@@ -57,6 +115,8 @@ mm-modify 183715 archive --dry-run
 mm-modify 183715 read --verify
 ```
 
+**Tip — batch your actions.** Doing all related changes in **one** `mm-modify` invocation is still worthwhile: one open/close cycle instead of two, and the chain runs deterministically without you having to think about ordering. Splitting is safe — `path_for` falls back to a filesystem glob if MailMate's `#source` index is briefly stale after a fast-move — just slower than batching.
+
 ### `mm-send` — send mail
 
 `mm-send` is a thin wrapper around MailMate's bundled `emate mailto`, with `--markup markdown` enforced. The body is read from stdin.
@@ -81,20 +141,24 @@ mm-send -t friend@example.com -s "Photos" /path/to/photo1.jpg /path/to/photo2.jp
 
 The `mm` prefix is for tab completion: typing `mm<tab>` in a shell lists every command in the toolkit. The dash matters:
 
-- **`mm<name>`** (no dash) — **read** operations. `mmsearch`, `mmmessage`, `mmdiscover` only observe MailMate's on-disk state.
-- **`mm-<name>`** (with dash) — **write** operations. `mm-modify`, `mm-send` change state (or send mail). Typing `mm-<tab>` filters to just the write commands so you can see at a glance what mutates.
+- **`mm<name>`** (no dash) — **read** operations. `mmsearch`, `mmmessage`, `mmopen`, `mmtags`, `mmdiscover` observe MailMate's on-disk state without changing it. (`mmopen` activates MailMate's UI but doesn't modify any message.)
+- **`mm-<name>`** (with dash) — **write** operations. `mm-modify`, `mm-send` change state (or send mail). `mm-mailboxes` is an exception: read-only, but uses the dash to keep `mmm<tab>` free for the daily-driver `mmmessage`. Typing `mm-<tab>` filters to the write-leaning commands.
 
 ## Limitations
 
 A few rough edges to be aware of:
 
-1. **Search is slow against this wrapper, even though MailMate itself is fast.** MailMate has a fantastic search engine — its native quicksearch is near-instant even against large stores — but `mmsearch` doesn't yet route through it. The current implementation uses index prefilters plus direct `.eml` walks, which works but is orders of magnitude slower than MailMate's own UI search, and **painfully** slow once a body-text term (`b <term>`, a bare term that falls through to body matching, or a `--no-headers-only` query) disables the prefilter. Prefer narrowing with `f`/`t`/`s`/`d` first, and use `--headers-only` when you don't need the body matched. Finding a way to drive MailMate's native engine from the outside is open work.
+1. **Body search speed depends on MailMate's body-index coverage; everything else is fully index-driven.** Header-based filters (`f`/`t`/`c`/`s`/`a`/`T`/`K`/`d`) and every output column (subject, from, to, cc, date, tags, flags, …) read directly from MailMate's binary header indexes under `Database.noindex/Headers/`. No `.eml` is opened for those queries — performance is in the same ballpark as MailMate's own UI search (sub-second across large stores).
+
+   Body queries (`b <term>`, a bare term that falls through to `:message_or_body`, or explicit `m <term>` without `--headers-only`) check MailMate's `#unquoted` and `#quoted` body indexes. **Default behavior matches MailMate's UI body search** — only messages MailMate has body-indexed are searched. Sub-second on any archive size; the catch is that MailMate populates those indexes lazily (typically when you view or search messages in its UI), so a search may miss content in messages MailMate hasn't yet indexed. Coverage varies by user: a fresh install has a handful indexed; a heavy MailMate-search user has most.
+
+   Pass `--all` to fall back to reading and parsing the `.eml` on disk for messages without an index record. This finds everything but takes tens of seconds to minutes on large archives. Use `--all` when you need an exhaustive answer; stick with the default when you want a predictable-fast one.
 
-2. **Bulk `mm-modify` takes over the whole computer, not just MailMate.** Each invocation opens a message-viewer window via the `mid:` URL, runs AppleScript key-binding selectors against it, then closes the window. Two things follow from that:
+2. **Non-move `mm-modify` actions still take over the UI.** Same-account `move` actions use a fast path — a direct `.eml` rename on disk — so they're silent and don't activate MailMate. Everything else (`read`, `flag`, `tag`, `archive`, `junk`, `delete`, etc.) still drives MailMate's UI: each invocation opens a message-viewer window via the `mid:` URL, runs AppleScript key-binding selectors against it, then closes the window. Two consequences:
    - **Focus is stolen.** When the `mid:` URL fires, macOS brings MailMate forward and the spawned message-viewer window takes keyboard focus. Anything you were typing into another app goes to MailMate instead.
-   - **The close at the end can close the wrong window.** `mm-modify` ends by sending the standard "close window" keystroke. If focus has drifted (or the next app's window has come forward in the meantime), that keystroke lands on **your** window — your editor, your browser tab — not MailMate's viewer.
+   - **The close at the end can close the wrong window.** `mm-modify` ends by sending the standard "close window" keystroke. If focus has drifted (or another app's window has come forward in the meantime), that keystroke lands on **your** window — your editor, your browser tab — not MailMate's viewer.
 
-   For one-off changes this is just annoying; for a loop of hundreds of messages it makes the machine unusable while it runs. Batch multiple actions into one `mm-modify` invocation when you can — they share a single open/close cycle. The `--keep-window` flag avoids the close-keystroke entirely if you don't mind cleaning up viewers manually.
+   For one-off changes this is just annoying; for a loop of hundreds of messages it makes the machine unusable while it runs. Batch multiple actions into one `mm-modify` invocation when you can — they share a single open/close cycle (or skip it entirely for pure-move). The `--keep-window` flag avoids the close-keystroke entirely if you don't mind cleaning up viewers manually.
 
 3. **`eml-id` is machine-local; prefer `Message-ID:`.** The integer eml-id (also shown as MailMate's "Msg ID" column) is just the filename of the `.eml` on disk and differs on every install — copy/pasting an eml-id from your desktop to your laptop will refer to a different message (or none at all). For anything you want to keep, store the RFC `Message-ID:` header (which `mmmessage` prints) and pass that to the CLIs. The `mid:%3C<message-id>%3E` URL scheme works portably for the same reason.
 
@@ -137,8 +201,11 @@ Then `mmdiscover` as above.
 | Command | What it does |
 |---|---|
 | `mmsearch` | List messages matching a quicksearch expression. Output is aligned CSV. |
-| `mmmessage` | Print one message by `.eml` id (decoded headers + plain-text body). |
-| `mm-modify` | Mark read/flag/tag/archive/move a message via AppleScript. |
+| `mmmessage` | Print one message by id (decoded headers + plain-text body). `--mailmate` opens in MailMate instead; `--markdown` renders HTML-only bodies as clean markdown. |
+| `mmopen` | Open one message in MailMate's UI (via `open mid:…`). `--print` returns the URL. |
+| `mm-mailboxes` | List accounts, IMAP mailboxes (with optional counts), and smart-mailbox names. |
+| `mmtags` | List user tags applied to messages (with counts) or defined in Preferences. |
+| `mm-modify` | Mark read/flag/tag/archive a message via AppleScript; same-account `move` uses a fast `.eml`-rename path with no UI takeover. |
 | `mm-send` | Send mail through `emate` with a markdown body on stdin. |
 | `mmdiscover` | First-run bootstrap; (re-)writes the user config from MailMate's plists. |
 

data/exe/mailmate-mcp

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "mailmate"
+require "mailmate/mcp"
+
+exit Mailmate::MCP.run

data/exe/mm-mailboxes

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "mailmate"
+require "mailmate/cli/mailboxes"
+
+exit Mailmate::CLI::Mailboxes.run(ARGV)

data/exe/mmopen

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "mailmate"
+require "mailmate/cli/open"
+
+exit Mailmate::CLI::Open.run(ARGV)

data/exe/mmtags

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "mailmate"
+require "mailmate/cli/tags"
+
+exit Mailmate::CLI::Tags.run(ARGV)

data/lib/mailmate/cli/mailboxes.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "optparse"
+require "uri"
+
+module Mailmate
+  module CLI
+    # `mm-mailboxes` — enumerate accounts, their IMAP mailboxes, and the
+    # smart mailboxes MailMate has defined. Read-side (no UI activation), but
+    # uses the `mm-` prefix anyway so it doesn't shadow `mmmessage` in
+    # tab-completion: `mmm<tab>` keeps resolving to `mmmessage`.
+    # @api private
+    module Mailboxes
+      extend self
+
+      def run(argv)
+        opts = parse_options(argv)
+
+        accounts = enumerate_imap_accounts(count: opts[:count])
+        smart    = enumerate_smart_mailboxes
+
+        if opts[:csv]
+          emit_csv(accounts, smart, opts)
+        else
+          emit_grouped(accounts, smart, opts)
+        end
+        0
+      end
+
+      def parse_options(argv)
+        opts = { count: true, csv: false, align: true }
+        OptionParser.new do |o|
+          o.banner = "Usage: mm-mailboxes [options]"
+          o.separator ""
+          o.separator "List MailMate accounts, their IMAP mailboxes, and smart mailboxes."
+          o.separator "Default output groups by account with a section header per account."
+          o.on("--no-count",  "Skip .eml counts (faster on large stores)") { opts[:count] = false }
+          o.on("--csv",       "Flat CSV output (one row per mailbox, account repeated)") { opts[:csv] = true }
+          o.on("--no-align",  "Plain CSV (no column padding) — implies --csv") { opts[:csv] = true; opts[:align] = false }
+        end.parse!(argv)
+        opts
+      end
+
+      # ---- enumeration --------------------------------------------------------
+
+      # Returns [[account_display, [{mailbox: 'INBOX', count: 127}, …]], …]
+      # Account names are pulled from on-disk dir names under imap_root, with
+      # MailMate's URL-encoding decoded for display (`%40` → `@`).
+      def enumerate_imap_accounts(count: true)
+        root = Mailmate.config.imap_root
+        return [] unless File.directory?(root)
+
+        Dir.children(root).sort.filter_map do |dirname|
+          account_dir = File.join(root, dirname)
+          next unless File.directory?(account_dir)
+
+          mailboxes = collect_mailboxes(account_dir, count: count)
+          next if mailboxes.empty?
+
+          [decode_account(dirname), mailboxes]
+        end
+      end
+
+      def collect_mailboxes(account_dir, count:)
+        prefix = "#{account_dir}/"
+        Dir.glob("#{account_dir}/**/Messages").sort.filter_map do |messages_dir|
+          next unless File.directory?(messages_dir)
+          rel = messages_dir.sub(prefix, "").sub(%r{/Messages\z}, "")
+          # Strip the .mailbox suffix from each segment for display.
+          mailbox_name = rel.split("/").map { |s| s.sub(/\.mailbox\z/, "") }.join("/")
+          row = { mailbox: mailbox_name }
+          row[:count] = count ? Dir.children(messages_dir).count { |f| f.end_with?(".eml") } : nil
+          row
+        end
+      end
+
+      # Returns array of smart-mailbox names (sorted).
+      def enumerate_smart_mailboxes
+        graph = Mailmate::MailboxGraph.load
+        graph.by_uuid.values
+             .select { |m| m[:filter] }
+             .map    { |m| m[:name] }
+             .compact
+             .uniq
+             .sort
+      rescue StandardError
+        []
+      end
+
+      # MailMate's account dirs encode `@` as `%40` (they're literally IMAP
+      # URL fragments). Decode for display so users see real addresses.
+      def decode_account(dirname)
+        URI.decode_www_form_component(dirname)
+      end
+
+      # ---- output -------------------------------------------------------------
+
+      def emit_grouped(accounts, smart, opts)
+        accounts.each do |account, mailboxes|
+          $stdout.puts account
+          mailboxes.each do |m|
+            count_str = opts[:count] ? format_count(m[:count]) : ""
+            $stdout.puts "  #{m[:mailbox].ljust(50)}imap   #{count_str}"
+          end
+        end
+        unless smart.empty?
+          $stdout.puts
+          $stdout.puts "Smart Mailboxes"
+          smart.each { |name| $stdout.puts "  #{name.ljust(50)}smart  -" }
+        end
+      end
+
+      def emit_csv(accounts, smart, opts)
+        rows = []
+        accounts.each do |account, mailboxes|
+          mailboxes.each do |m|
+            rows << [account, m[:mailbox], "imap", opts[:count] ? format_count(m[:count]) : ""]
+          end
+        end
+        smart.each { |name| rows << ["(smart)", name, "smart", "-"] }
+
+        header = %w[account mailbox type count]
+        if opts[:align]
+          display = ([header] + rows)
+          widths  = Array.new(header.size, 0)
+          display.each { |r| r.each_with_index { |c, i| widths[i] = c.to_s.length if c.to_s.length > widths[i] } }
+          display.each do |r|
+            $stdout.puts r.each_with_index.map { |c, i| i == r.size - 1 ? c.to_s : c.to_s.ljust(widths[i]) }.join(",")
+          end
+        else
+          require "csv"
+          $stdout.puts CSV.generate_line(header)
+          rows.each { |r| $stdout.puts CSV.generate_line(r) }
+        end
+      end
+
+      def format_count(n)
+        n.nil? ? "-" : n.to_s
+      end
+    end
+  end
+end

data/lib/mailmate/cli/message.rb

@@ -34,6 +34,13 @@ module Mailmate
           return 1
         end
 
+        if opts[:mailmate]
+          require_relative "open"
+          # Hand off to mmopen — same id resolution already done, but Open re-resolves
+          # so the two paths stay symmetric. Tiny double-resolve is fine.
+          return Mailmate::CLI::Open.run([input])
+        end
+
         if opts[:raw]
           $stdout.binmode
           $stdout.write(File.binread(path))
@@ -42,28 +49,30 @@ module Mailmate
 
         mail = Mail.read(path)
         print_headers(mail, eml_id, path) unless opts[:text_only]
-        $stdout.puts text_body(mail)
+        $stdout.puts text_body(mail, markdown: opts[:markdown])
         0
       end
 
       def parse_options(argv)
-        opts = { raw: false, text_only: false }
+        opts = { raw: false, text_only: false, mailmate: false, markdown: false }
         OptionParser.new do |o|
-          o.banner = "Usage: mmmessage <id> [--raw|--text-only]"
+          o.banner = "Usage: mmmessage <id> [--raw|--text-only|--mailmate|--markdown]"
           o.separator ""
-          o.separator "<id> can be either a local eml-id (e.g. 183715) or an RFC"
-          o.separator "Message-ID (with or without angle brackets, e.g."
-          o.separator "<abc@example.com>). Message-IDs are portable across machines"
-          o.separator "and survive copy/paste between desktop/laptop/iPad."
+          o.separator "<id> can be a local eml-id (e.g. 183715), an RFC Message-ID"
+          o.separator "(with or without angle brackets, e.g. <abc@example.com>), or"
+          o.separator "a message://%3C...%3E URL. The latter two are portable across"
+          o.separator "machines and survive copy/paste between desktop/laptop/iPad."
           o.on("--raw", "Output raw .eml bytes") { opts[:raw] = true }
           o.on("--text-only", "Output decoded body only (no headers block)") { opts[:text_only] = true }
+          o.on("--mailmate", "Open in MailMate's UI instead of printing (alias for `mmopen <id>`)") { opts[:mailmate] = true }
+          o.on("--markdown", "Render HTML body as clean markdown (no-op for plain-text messages)") { opts[:markdown] = true }
         end.parse!(argv)
         opts
       end
 
       def usage_error(msg)
         warn "mmmessage: #{msg}"
-        warn "Usage: mmmessage <id> [--raw|--text-only]"
+        warn "Usage: mmmessage <id> [--raw|--text-only|--mailmate|--markdown]"
         warn "  <id> is either an eml-id (digits) or an RFC Message-ID."
         2
       end
@@ -94,16 +103,58 @@ module Mailmate
         $stdout.puts
       end
 
-      def text_body(mail)
+      def text_body(mail, markdown: false)
         if mail.text_part
+          # text/plain is already plain — markdown flag is a no-op here.
           mail.text_part.decoded.force_encoding("UTF-8").scrub
         elsif mail.html_part
-          "[no text/plain part — HTML rendered below; use --raw for original]\n\n" +
-            mail.html_part.decoded.force_encoding("UTF-8").scrub
+          html = mail.html_part.decoded.force_encoding("UTF-8").scrub
+          markdown ? html_to_markdown(html) : "[no text/plain part — HTML rendered below; use --raw for original]\n\n#{html}"
         else
-          mail.body.decoded.to_s.force_encoding("UTF-8").scrub
+          body = mail.body.decoded.to_s.force_encoding("UTF-8").scrub
+          if markdown && html_like?(mail, body)
+            html_to_markdown(body)
+          else
+            body
+          end
         end
       end
+
+      # Heuristic for "this body is HTML even though Mail couldn't structure it"
+      # — covers single-part text/html messages where mail.html_part is nil and
+      # we'd otherwise dump the raw markup.
+      def html_like?(mail, body)
+        ct = mail.content_type.to_s.downcase
+        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.
+      def html_to_markdown(html)
+        require "nokogiri"
+        require "reverse_markdown"
+        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
+      end
     end
   end
 end

data/lib/mailmate/cli/modify.rb

@@ -69,9 +69,10 @@ module Mailmate
           o.banner = <<~BANNER
             Usage: mm-modify <id> <action> [args...] [<action> [args...]]...
 
-            <id> can be either a local eml-id (e.g. 183715) or an RFC Message-ID
-            (with or without angle brackets, e.g. <abc@example.com>). Quote the
-            Message-ID in your shell so the < > aren't interpreted as redirection.
+            <id> can be a local eml-id (e.g. 183715), an RFC Message-ID (with or
+            without angle brackets, e.g. <abc@example.com>), or a message://%3C...%3E
+            URL. Quote the Message-ID in your shell so the < > aren't interpreted as
+            redirection.
 
             Selects the message in MailMate (via the `mid:` URL) and runs one or
             more AppleScript key-binding selectors against the now-selected message.
@@ -86,7 +87,13 @@ module Mailmate
               untag <name>                  Remove IMAP keyword <name>
               clear-tags                    Remove all keywords
               archive                       Move to the archive mailbox
-              move <mailbox-uuid>           Move to a specific mailbox (use UUID from MailMate)
+              move <mailbox>                Move to a specific mailbox. Bare names like 'Archive'
+                                            or 'Folder/Sub' resolve within the same account and
+                                            take a fast path (direct .eml rename — no UI, no
+                                            focus theft). Mailbox UUIDs and cross-account moves
+                                            fall back to the AppleScript driver. Chained with
+                                            other actions: tag/flag/etc. run first at the
+                                            original location, the rename happens last.
               junk / not-junk               Mark as junk / not junk
               mute                          Toggle mute state
               delete                        Delete (move to trash)
@@ -135,6 +142,117 @@ module Mailmate
       end
 
       def drive(eml_id, message_id, actions, opts)
+        # Fast-path moves apply ONLY when every requested action is a move.
+        # When the chain includes any non-move action (tag, flag, archive, …)
+        # we're paying for MailMate's UI anyway, so we let MailMate handle the
+        # move in-UI alongside the rest. Why this beats reordering moves to
+        # the end of the chain:
+        #
+        # - The marginal cost of one extra AppleScript `moveToMailbox:` call
+        #   is small next to the UI activation we're already eating.
+        # - MailMate sees the move it just made — no #source-index staleness
+        #   inside the same invocation or for follow-ups.
+        # - Simpler mental model: pure-move = silent + fast; mixed = all-UI.
+        fast_moves, other = actions.partition { |name, _, _| name == "move" }
+
+        if other.empty? && !fast_moves.empty?
+          current_path = Mailmate::EmlLookup.path_for(eml_id)
+          fast_moves.each do |_name, selector, args|
+            new_path = try_fast_move(eml_id, current_path, args.first, opts)
+            if new_path
+              current_path = new_path
+            else
+              # Fast-path declined for this one move (cross-account, target
+              # not found, perm error, …) — single UI-driven move as fallback.
+              drive_via_applescript(eml_id, message_id, [["move", selector, args]], opts)
+            end
+          end
+        else
+          # Mixed chain (or pure non-move chain): everything goes through the
+          # AppleScript driver in the user-supplied order.
+          drive_via_applescript(eml_id, message_id, actions, opts)
+        end
+      end
+
+      # Returns the new path on success (or in dry-run, the path we *would*
+      # have moved to). Returns nil if the caller should fall back to the
+      # AppleScript driver for this action (cross-account, unknown target,
+      # permission error, …).
+      def try_fast_move(eml_id, current_path, target_spec, opts)
+        return nil if current_path.nil?
+        account_dir = account_dir_for(current_path)
+        return nil if account_dir.nil?
+
+        dest_messages = find_target_in_account(account_dir, target_spec)
+        return nil if dest_messages.nil?
+
+        dest_path = File.join(dest_messages, "#{eml_id}.eml")
+        if dest_path == current_path
+          $stdout.puts "move (fast): #{eml_id}.eml is already in #{target_spec} — no-op"
+          return dest_path
+        end
+
+        if opts[:dry_run]
+          $stdout.puts "move (fast, dry-run): would rename"
+          $stdout.puts "  from: #{current_path}"
+          $stdout.puts "  to:   #{dest_path}"
+          return dest_path
+        end
+
+        File.rename(current_path, dest_path)
+        # The #source index still points at the old location until MailMate
+        # rescans; bust it so any subsequent path_for in this process re-reads
+        # (and eventually picks up MailMate's refreshed value).
+        Mailmate::IndexReader.reset!("#source") if defined?(Mailmate::IndexReader)
+        $stdout.puts "move (fast): renamed #{eml_id}.eml → #{relative_to_imap_root(dest_messages)}"
+        dest_path
+      rescue Errno::EACCES, Errno::EXDEV, Errno::ENOENT, Errno::EEXIST => e
+        warn "move (fast): rename failed (#{e.class}: #{e.message}); falling back to AppleScript"
+        nil
+      end
+
+      # The account directory is the first path segment under imap_root.
+      def account_dir_for(path)
+        imap_root = Mailmate.config.imap_root
+        return nil unless path.start_with?("#{imap_root}/")
+        rel = path.sub("#{imap_root}/", "")
+        first = rel.split("/", 2).first
+        return nil if first.nil? || first.empty?
+        File.join(imap_root, first)
+      end
+
+      # Resolve `target_spec` to a `.../Messages` directory within `account_dir`.
+      # Returns nil if not found unambiguously in the same account — caller
+      # should then fall back to AppleScript (which can handle cross-account
+      # moves, UUIDs, special mailboxes, etc.).
+      def find_target_in_account(account_dir, target_spec)
+        spec = target_spec.to_s.sub(%r{/Messages\z}, "").sub(/\.mailbox\z/, "")
+        return nil if spec.empty?
+
+        # 1. Exact relative path under the account, each segment .mailbox-suffixed.
+        nested = spec.split("/").map { |s| "#{s}.mailbox" }.join("/")
+        cand = File.join(account_dir, nested, "Messages")
+        return cand if File.directory?(cand)
+
+        # 2. Bare-name match anywhere inside the account.
+        matches = Dir.glob(File.join(account_dir, "**", "#{spec}.mailbox", "Messages"))
+                     .select { |p| File.directory?(p) }
+        case matches.size
+        when 0 then nil
+        when 1 then matches.first
+        else
+          warn "move (fast): ambiguous target '#{spec}' in account; matches:"
+          matches.each { |m| warn "  #{m}" }
+          nil
+        end
+      end
+
+      def relative_to_imap_root(path)
+        root = Mailmate.config.imap_root
+        path.start_with?("#{root}/") ? path.sub("#{root}/", "") : path
+      end
+
+      def drive_via_applescript(eml_id, message_id, actions, opts)
         driver  = Mailmate::AppleScriptDriver.new(dry_run: opts[:dry_run])
         mid_url = Mailmate::MidUrl.for(message_id)