teems 0.3.2 → 0.3.3

data/lib/teems/commands/transcripts.rb

@@ -39,6 +39,24 @@ module Teems
         A failing or timed-out command is reported but does not fail the sync.
       HELP
 
+      OPTION_HANDLERS = {
+        '--since' => ->(opts, args) { opts[:since] = Integer(args.shift, exception: false) },
+        '--date' => ->(opts, args) { opts.merge!(Transcripts.date_option(args.shift)) },
+        '--dry-run' => ->(opts, _args) { opts[:dry_run] = true },
+        '--no-post-sync' => ->(opts, _args) { opts[:no_post_sync] = true }
+      }.freeze
+
+      def self.date_option(value)
+        { date: Date.iso8601(value) }
+      rescue ArgumentError, TypeError
+        { invalid_date: true }
+      end
+
+      def initialize(args, runner:)
+        @options = {}
+        super
+      end
+
       def execute
         validation = validate_options
         return validation if validation
@@ -54,13 +72,10 @@ module Teems
       protected
 
       def handle_option(arg, pending)
-        case arg
-        when '--since' then @options[:since] = Integer(pending.shift, exception: false)
-        when '--date' then parse_date_option(pending.shift)
-        when '--dry-run' then @options[:dry_run] = true
-        when '--no-post-sync' then @options[:no_post_sync] = true
-        else super
-        end
+        handler = OPTION_HANDLERS[arg]
+        return super unless handler
+
+        handler.call(@options, pending)
       end
 
       def transcript_settings
@@ -68,13 +83,53 @@ module Teems
         settings.is_a?(Hash) ? settings : {}
       end
 
-      def parse_date_option(value)
-        @options[:date] = Date.iso8601(value)
-      rescue ArgumentError, TypeError
-        @options[:invalid_date] = true
+      def help_text = HELP
+    end
+
+    # Where transcript sync keeps its files: XDG data for transcripts, XDG state for the manifest
+    TranscriptPaths = Data.define(:output_dir, :markdown_dir, :state_dir) do
+      def self.from_env
+        data_dir = Support::XdgPaths.new.data_dir
+        state_home = ENV.fetch('XDG_STATE_HOME') { File.join(Dir.home, '.local', 'state') }
+        new(output_dir: File.join(data_dir, 'transcripts'), markdown_dir: File.join(data_dir, 'transcripts-md'),
+            state_dir: File.join(state_home, 'teems'))
       end
 
-      def help_text = HELP
+      def manifest = File.join(state_dir, 'transcript-sync.json')
+
+      def lock = File.join(state_dir, 'transcript-sync.lock')
+    end
+
+    # A scheduled Teams meeting on one calendar date (one occurrence of a recurring series)
+    TranscriptMeeting = Data.define(:date, :event) do
+      def id = event.fetch('id')
+
+      def name = event['subject'].to_s.gsub(/[\r\n]/, ' ')[0, 100]
+
+      def status_line(status) = "#{date}: #{status}: #{name}"
+
+      def command_args = ['meeting', id, '--date', date.iso8601]
+
+      # Manifest key for one recording's transcript
+      def recording_key(url) = Digest::SHA256.hexdigest("#{date.iso8601}:#{id}:#{url}")
+
+      # Manifest key used before transcripts were tracked per recording
+      def legacy_key = Digest::SHA256.hexdigest("#{date.iso8601}:#{id}")
+    end
+
+    # One recording of a meeting; each has its own transcript
+    TranscriptRecording = Data.define(:meeting, :url) do
+      def key = meeting.recording_key(url)
+
+      def legacy_key = meeting.legacy_key
+
+      def date = meeting.date
+
+      def transcript_args(dir) = [*meeting.command_args, '--transcript', '--recording-url', url, '-o', dir]
+
+      def manifest_entry(file_name)
+        { 'file' => file_name, 'downloaded_at' => Time.now.iso8601, 'date' => date.iso8601, 'subject' => meeting.name }
+      end
     end
 
     # Private on-disk storage, separate from meeting-capture.
@@ -82,38 +137,44 @@ module Teems
       private
 
       def prepare_private_directories
-        [@output_dir, @state_dir].each do |dir|
-          FileUtils.mkdir_p(dir, mode: 0o700)
-          File.chmod(0o700, dir)
-        end
+        [@paths.output_dir, @paths.state_dir].each { |dir| private_directory(dir) }
       end
 
+      def private_directory(dir)
+        FileUtils.mkdir_p(dir, mode: 0o700)
+        File.chmod(0o700, dir)
+      end
+
+      # Transcripts live flat in the output dir; manifest entries are trusted only for their basename
+      def transcript_path(file) = File.join(@paths.output_dir, File.basename(file))
+
       def log_locked
         log 'Another transcript sync is running; skipping.'
         0
       end
 
       def load_manifest
-        File.file?(@manifest_path) ? JSON.parse(File.read(@manifest_path)) : { 'events' => {} }
+        path = @paths.manifest
+        File.file?(path) ? JSON.parse(File.read(path)) : { 'events' => {} }
       end
 
       def downloaded?(key, manifest)
         prior = manifest.fetch('events', {})[key]
-        prior && valid_vtt?(File.join(@output_dir, File.basename(prior.fetch('file'))))
+        prior && valid_vtt?(transcript_path(prior.fetch('file')))
       end
 
-      def persist_download(date, event, key, file, manifest)
-        adopted = adopt_legacy_download(date, event, file, manifest)
+      def persist_download(recording, file, manifest)
+        key = recording.key
+        adopted = adopt_legacy_download(recording, file, manifest)
         target_name = adopted || store_download(file, key)
-        manifest['events'][key] = { 'file' => target_name, 'downloaded_at' => Time.now.iso8601,
-                                    'date' => date.iso8601, 'subject' => event_name(event) }
+        manifest['events'][key] = recording.manifest_entry(target_name)
         save_manifest(manifest)
-        log "#{date}: #{adopted ? 'already had' : 'saved'} #{target_name}"
+        log "#{recording.date}: #{adopted ? 'already had' : 'saved'} #{target_name}"
       end
 
       def store_download(file, key)
         target_name = "#{File.basename(file, '.vtt')}--#{key[0, 10]}.vtt"
-        target = File.join(@output_dir, target_name)
+        target = transcript_path(target_name)
         File.rename(file, target) unless valid_vtt?(target)
         File.chmod(0o600, target)
         target_name
@@ -121,15 +182,16 @@ module Teems
 
       # Earlier syncs kept one transcript per event. Reuse that file when it is
       # this recording's transcript instead of saving a duplicate.
-      def adopt_legacy_download(date, event, file, manifest)
-        key = legacy_key(date, event)
-        legacy = manifest['events'][key]
+      def adopt_legacy_download(recording, file, manifest)
+        events = manifest['events']
+        key = recording.legacy_key
+        legacy = events[key]
         return unless legacy
 
-        existing = File.join(@output_dir, File.basename(legacy.fetch('file')))
+        existing = transcript_path(legacy.fetch('file'))
         return unless valid_vtt?(existing) && FileUtils.identical?(existing, file)
 
-        manifest['events'].delete(key)
+        events.delete(key)
         File.basename(existing)
       end
 
@@ -137,12 +199,14 @@ module Teems
         File.file?(file) && File.size(file) > 10 && File.open(file, 'rb') { |io| io.read(6) == 'WEBVTT' }
       end
 
-      def valid_download?(status, files)
-        status.success? && files.length == 1 && valid_vtt?(files.first)
+      # The single valid WebVTT `teems meeting --transcript` wrote into dir, if any
+      def downloaded_vtt(dir)
+        vtt, *extra = Dir.glob(File.join(dir, '*.vtt'))
+        vtt if extra.empty? && valid_vtt?(vtt.to_s)
       end
 
       def save_manifest(manifest)
-        write_private(@manifest_path, "#{JSON.pretty_generate(manifest)}\n")
+        write_private(@paths.manifest, "#{JSON.pretty_generate(manifest)}\n")
       end
 
       def write_private(path, content)
@@ -159,42 +223,43 @@ module Teems
     module TranscriptSyncMarkdown
       private
 
+      # Returns [Markdown paths written this run, whether every export succeeded]
       def sync_markdown(manifest)
-        FileUtils.mkdir_p(@markdown_dir, mode: 0o700)
-        File.chmod(0o700, @markdown_dir)
+        private_directory(@paths.markdown_dir)
         results = manifest.fetch('events', {}).values.map { |entry| export_markdown(entry) }
-        written = results.count(:written)
-        log "Markdown: updated #{written} transcript(s)" if written.positive?
-        results
+        written = results.grep(String)
+        log "Markdown: updated #{written.length} transcript(s)" unless written.empty?
+        [written, !results.include?(:failed)]
       end
 
+      # Returns the Markdown path it wrote, or :missing, :current, or :failed
       def export_markdown(entry)
-        vtt = File.join(@output_dir, File.basename(entry.fetch('file')))
+        vtt = transcript_path(entry.fetch('file'))
         return :missing unless valid_vtt?(vtt)
 
-        target = File.join(@markdown_dir, "#{File.basename(vtt, '.vtt')}.md")
+        target = File.join(@paths.markdown_dir, "#{File.basename(vtt, '.vtt')}.md")
         return :current if markdown_current?(target, vtt)
 
         write_private(target, markdown_for(vtt, entry))
-        @changed_markdown << target
-        :written
+        target
       rescue StandardError => e
-        markdown_failure(entry, e)
+        markdown_failure(entry, "#{e.class}: #{e.message}")
       end
 
       def markdown_current?(target, vtt) = File.file?(target) && File.mtime(target) >= File.mtime(vtt)
 
-      def markdown_failure(entry, error)
-        failure "Markdown export failed for #{File.basename(entry['file'].to_s)} (#{error.class}: #{error.message})"
+      def markdown_failure(entry, reason)
+        failure "Markdown export failed for #{File.basename(entry['file'].to_s)} (#{reason})"
         :failed
       end
 
       def markdown_for(vtt, entry)
+        subject, date = entry.values_at('subject', 'date')
         stem = File.basename(vtt, '.vtt').sub(/--\h{10}\z/, '')
         Formatters::TranscriptMarkdown.new(
           File.read(vtt, encoding: 'bom|utf-8'),
-          title: entry['subject'] || stem.sub(/\A\d{4}-\d{2}-\d{2} - /, '').sub(/-\d{8}_\d{6}UTC\z/, ''),
-          date: entry['date'] || transcript_date(stem),
+          title: subject || stem.sub(/\A\d{4}-\d{2}-\d{2} - /, '').sub(/-\d{8}_\d{6}UTC\z/, ''),
+          date: date || transcript_date(stem),
           source: File.basename(vtt)
         ).render
       end
@@ -247,124 +312,130 @@ module Teems
 
       private
 
-      def sync_event(date, event, manifest)
-        urls = recording_urls(date, event)
-        return unavailable?(date, event) if urls.empty?
-        return preview_event?(date, event, urls, manifest) if @options[:dry_run]
+      def sync_event(meeting, manifest)
+        urls = recording_urls(meeting)
+        return unavailable?(meeting) if urls.empty?
+        return preview_event?(meeting, urls, manifest) if @options[:dry_run]
 
-        urls.map { |url| sync_recording?(date, event, url, manifest) }.all?
+        urls.map { |url| sync_recording?(TranscriptRecording.new(meeting: meeting, url: url), manifest) }.all?
       rescue StandardError => e
-        failure "#{date}: failed: #{event_name(event)} (#{e.class}: #{e.message})"
+        failure "#{meeting.status_line('failed')} (#{e.class}: #{e.message})"
         false
       end
 
-      def recording_urls(date, event)
-        stdout, stderr, status = Open3.capture3(teems_executable, 'meeting', event.fetch('id'),
-                                                '--date', date.iso8601, '--json')
+      def recording_urls(meeting)
+        stdout, stderr, status = Open3.capture3(teems_executable, *meeting.command_args, '--json')
         return recordings_from(stdout) if status.success?
-        return [] if NO_TRANSCRIPT.match?("#{stderr} #{stdout}")
 
-        raise "teems meeting failed (exit #{status.exitstatus}): #{redacted_error("#{stderr} #{stdout}")}"
+        message = "#{stderr} #{stdout}"
+        return [] if NO_TRANSCRIPT.match?(message)
+
+        raise "teems meeting failed (exit #{status.exitstatus}): #{redacted_error(message)}"
       end
 
+      # Recording URLs in start-time order, skipping recordings without a sharing link
       def recordings_from(json)
-        recordings = JSON.parse(json).fetch('recordings', [])
-        recordings.select { |rec| rec['url'] }.sort_by { |rec| rec['time'].to_s }.map { |rec| rec['url'] }.uniq
+        pairs = JSON.parse(json).fetch('recordings', []).map { |rec| rec.values_at('time', 'url') }
+        pairs.select(&:last).sort_by { |time, _url| time.to_s }.map(&:last).uniq
       end
 
-      def recording_key(date, event, url) = Digest::SHA256.hexdigest("#{date.iso8601}:#{event.fetch('id')}:#{url}")
-
-      def legacy_key(date, event) = Digest::SHA256.hexdigest("#{date.iso8601}:#{event.fetch('id')}")
-
-      def sync_recording?(date, event, url, manifest)
-        key = recording_key(date, event, url)
-        downloaded?(key, manifest) || download_recording?(date, event, url, key, manifest)
+      def sync_recording?(recording, manifest)
+        downloaded?(recording.key, manifest) || download_recording?(recording, manifest)
       end
 
-      def preview_event?(date, event, urls, manifest)
-        pending = urls.count { |url| !downloaded?(recording_key(date, event, url), manifest) }
-        pending -= 1 if pending.positive? && downloaded?(legacy_key(date, event), manifest)
-        log "#{date}: candidate: #{event_name(event)} (#{urls.length} recording(s), #{pending} not yet saved)"
+      def preview_event?(meeting, urls, manifest)
+        pending = urls.count { |url| !downloaded?(meeting.recording_key(url), manifest) }
+        pending -= 1 if pending.positive? && downloaded?(meeting.legacy_key, manifest)
+        log "#{meeting.status_line('candidate')} (#{urls.length} recording(s), #{pending} not yet saved)"
         true
       end
 
-      def download_recording?(date, event, url, key, manifest)
-        Dir.mktmpdir('teems-transcript-', @output_dir) do |temp_dir|
-          stdout, stderr, status = Open3.capture3(teems_executable, 'meeting', event.fetch('id'),
-                                                  '--date', date.iso8601, '--transcript',
-                                                  '--recording-url', url, '-o', temp_dir)
-          files = Dir.glob(File.join(temp_dir, '*.vtt'))
-          return download_failure?(date, event, status, "#{stderr} #{stdout}") unless valid_download?(status, files)
+      def download_recording?(recording, manifest)
+        Dir.mktmpdir('teems-transcript-', @paths.output_dir) do |temp_dir|
+          stdout, stderr, status = Open3.capture3(teems_executable, *recording.transcript_args(temp_dir))
+          vtt = downloaded_vtt(temp_dir)
+          return download_failure?(recording.meeting, status, "#{stderr} #{stdout}") unless status.success? && vtt
 
-          persist_download(date, event, key, files.first, manifest)
+          persist_download(recording, vtt, manifest)
         end
         true
       end
 
-      def download_failure?(date, event, status, message)
-        return unavailable?(date, event) if NO_TRANSCRIPT.match?(message)
+      def download_failure?(meeting, status, message)
+        return unavailable?(meeting) if NO_TRANSCRIPT.match?(message)
 
-        failure "#{date}: failed: #{event_name(event)} (exit #{status.exitstatus}; #{redacted_error(message)})"
+        failure "#{meeting.status_line('failed')} (exit #{status.exitstatus}; #{redacted_error(message)})"
         false
       end
 
-      def unavailable?(date, event)
-        log "#{date}: unavailable via teems: #{event_name(event)}"
+      def unavailable?(meeting)
+        log meeting.status_line('unavailable via teems')
         true
       end
     end
 
     # Optional user command run after a sync changes Markdown, e.g. to refresh a qmd index.
     # A failing or slow command is reported but never fails the sync itself.
-    module TranscriptSyncHook
-      DEFAULT_HOOK_TIMEOUT = 300
+    class TranscriptPostSyncHook
+      DEFAULT_TIMEOUT = 300
 
-      private
+      def initialize(settings, paths:, output:, quiet:)
+        @settings = settings
+        @paths = paths
+        @output = output
+        @quiet = quiet
+      end
 
-      def run_post_sync_hook
-        command = @hook['post_sync_command'].to_s.strip
-        return if command.empty? || @options[:no_post_sync] || @changed_markdown.empty?
+      def run(changed)
+        command = @settings['post_sync_command'].to_s.strip
+        return if command.empty? || changed.empty?
 
-        log "Post-sync: running command for #{@changed_markdown.length} changed transcript(s)"
-        report_hook(*execute_hook(command))
+        log "Post-sync: running command for #{changed.length} changed transcript(s)"
+        report(*execute(command, changed))
       rescue StandardError => e
         @output.warn("Post-sync command could not run (#{e.class}: #{e.message})")
       end
 
+      private
+
+      def log(message)
+        @output.puts(message) unless @quiet
+      end
+
       # Runs in its own process group so a timeout can stop the whole pipeline.
-      def execute_hook(command)
-        Open3.popen2e(hook_env, 'sh', '-c', command, pgroup: true) do |stdin, stdout, wait|
+      def execute(command, changed)
+        Open3.popen2e(env(changed), 'sh', '-c', command, pgroup: true) do |stdin, stdout, wait|
           stdin.close
           reader = Thread.new { stdout.read }
-          finished = wait.join(hook_timeout)
-          stop_hook(wait.pid) unless finished
+          finished = wait.join(timeout)
+          stop(wait.pid) unless finished
           [finished ? wait.value : nil, reader.value]
         end
       end
 
-      def stop_hook(pid)
+      def stop(pid)
         Process.kill('KILL', -pid)
       rescue Errno::ESRCH
         nil
       end
 
-      def hook_env
-        { 'TEEMS_TRANSCRIPTS_CHANGED' => @changed_markdown.join("\n"),
-          'TEEMS_TRANSCRIPTS_CHANGED_COUNT' => @changed_markdown.length.to_s,
-          'TEEMS_TRANSCRIPTS_MARKDOWN_DIR' => @markdown_dir,
-          'TEEMS_TRANSCRIPTS_DIR' => @output_dir }
+      def env(changed)
+        { 'TEEMS_TRANSCRIPTS_CHANGED' => changed.join("\n"),
+          'TEEMS_TRANSCRIPTS_CHANGED_COUNT' => changed.length.to_s,
+          'TEEMS_TRANSCRIPTS_MARKDOWN_DIR' => @paths.markdown_dir,
+          'TEEMS_TRANSCRIPTS_DIR' => @paths.output_dir }
       end
 
-      def hook_timeout = [@hook['post_sync_timeout']].grep(Numeric).find(&:positive?) || DEFAULT_HOOK_TIMEOUT
+      def timeout = [@settings['post_sync_timeout']].grep(Numeric).find(&:positive?) || DEFAULT_TIMEOUT
 
-      def report_hook(status, hook_output)
+      def report(status, hook_output)
         return log('Post-sync: done') if status&.success?
 
-        reason = status ? "exit #{status.exitstatus}" : "timed out after #{hook_timeout}s"
-        @output.warn("Post-sync command failed (#{reason}): #{hook_tail(hook_output)}")
+        reason = status ? "exit #{status.exitstatus}" : "timed out after #{timeout}s"
+        @output.warn("Post-sync command failed (#{reason}): #{tail(hook_output)}")
       end
 
-      def hook_tail(text)
+      def tail(text)
         lines = text.to_s.scrub.lines.map(&:strip).reject(&:empty?).last(3)
         lines.empty? ? 'no output' : lines.join(' | ')[0, 300]
       end
@@ -376,7 +447,6 @@ module Teems
       include TranscriptSyncCalendar
       include TranscriptSyncMarkdown
       include TranscriptSyncRecordings
-      include TranscriptSyncHook
 
       DEFAULT_LOOKBACK = 7
       INITIAL_LOOKBACK = 30
@@ -384,30 +454,26 @@ module Teems
       def initialize(options, output, hook: {})
         @options = options
         @output = output
-        @hook = hook
-        @changed_markdown = []
-        data_home = ENV.fetch('XDG_DATA_HOME', File.join(Dir.home, '.local', 'share'))
-        state_home = ENV.fetch('XDG_STATE_HOME', File.join(Dir.home, '.local', 'state'))
-        @output_dir = File.join(data_home, 'teems', 'transcripts')
-        @markdown_dir = File.join(data_home, 'teems', 'transcripts-md')
-        @state_dir = File.join(state_home, 'teems')
-        @manifest_path = File.join(@state_dir, 'transcript-sync.json')
+        @paths = TranscriptPaths.from_env
+        @hook = TranscriptPostSyncHook.new(hook, paths: @paths, output: output, quiet: options[:quiet])
       end
 
       def run
         File.umask(0o077)
-        return scan(load_manifest) if @options[:dry_run]
+        @options[:dry_run] ? scan(load_manifest) : locked_scan
+      end
+
+      private
 
+      def locked_scan
         prepare_private_directories
-        File.open(File.join(@state_dir, 'transcript-sync.lock'), File::RDWR | File::CREAT, 0o600) do |lock|
+        File.open(@paths.lock, File::RDWR | File::CREAT, 0o600) do |lock|
           return log_locked unless lock.flock(File::LOCK_EX | File::LOCK_NB)
 
           scan(load_manifest)
         end
       end
 
-      private
-
       def log(message)
         @output.puts(message) unless @options[:quiet]
       end
@@ -417,14 +483,16 @@ module Teems
       end
 
       def dates_to_scan(manifest)
-        return [@options[:date]] if @options[:date]
+        date = @options[:date]
+        return [date] if date
 
-        days = lookback_days(manifest)
-        log "Scanning #{days} day(s) through #{Date.today} on this machine"
-        ((Date.today - days + 1)..Date.today).to_a
+        today = Date.today
+        days = lookback_days(manifest, today)
+        log "Scanning #{days} day(s) through #{today} on this machine"
+        ((today - days + 1)..today).to_a
       end
 
-      def lookback_days(manifest)
+      def lookback_days(manifest, today)
         days = @options.fetch(:since, DEFAULT_LOOKBACK)
         return days unless days == DEFAULT_LOOKBACK
 
@@ -432,35 +500,35 @@ module Teems
         return INITIAL_LOOKBACK unless previous
 
         # Catch up after time away, capped at the requested initial window.
-        (Date.today - Date.iso8601(previous) + 1).to_i.clamp(days, INITIAL_LOOKBACK)
+        (today - Date.iso8601(previous) + 1).to_i.clamp(days, INITIAL_LOOKBACK)
       end
 
       def scan(manifest)
         results = dates_to_scan(manifest).map { |date| scan_date(date, manifest) }
-        unless @options[:dry_run]
-          persist_scan(manifest, results.include?(nil))
-          results << !sync_markdown(manifest).include?(:failed)
-          run_post_sync_hook
-        end
+        results << finish_scan(manifest, results) unless @options[:dry_run]
         results.all? ? 0 : 1
       end
 
       def scan_date(date, manifest)
-        results = calendar_events(date).map { |event| sync_event(date, event, manifest) }
+        results = calendar_events(date).map do |event|
+          sync_event(TranscriptMeeting.new(date: date, event: event), manifest)
+        end
         results.all?
       rescue StandardError => e
         failure "#{date}: calendar error (#{e.class}: #{e.message})"
         nil
       end
 
-      def persist_scan(manifest, calendar_failed)
-        # Failed artifacts stay in the log and get seven-day retries. A calendar
-        # failure leaves the wider scan pending so historical days aren't lost.
-        manifest['last_scan_date'] = Date.today.iso8601 unless @options[:date] || calendar_failed
+      # Records the scan, refreshes Markdown, and runs the post-sync hook; returns whether Markdown export succeeded.
+      # Failed artifacts stay in the log and get seven-day retries. A calendar failure (nil result)
+      # leaves the wider scan pending so historical days aren't lost.
+      def finish_scan(manifest, results)
+        manifest['last_scan_date'] = Date.today.iso8601 unless @options[:date] || results.include?(nil)
         save_manifest(manifest)
+        changed, markdown_ok = sync_markdown(manifest)
+        @hook.run(changed) unless @options[:no_post_sync]
+        markdown_ok
       end
-
-      def event_name(event) = event['subject'].to_s.gsub(/[\r\n]/, ' ')[0, 100]
     end
   end
 end

data/lib/teems/formatters/format_utils.rb

@@ -26,6 +26,9 @@ module Teems
         att.is_a?(Hash) ? (att['fileName'] || att['name'] || 'file') : att.to_s
       end
 
+      # One-line description of a message's inline images, e.g. "image (881x179), chart"
+      def image_summary(images) = images.map(&:label).join(', ')
+
       def format_single_reaction(reaction, emoji_map)
         type = reaction[:type]
         emoji = emoji_map[type] || type

data/lib/teems/formatters/markdown_formatter.rb

@@ -15,10 +15,12 @@ module Teems
         '1f440_eyes' => "\u{1F440}", 'thumbsdown' => "\u{1F44E}"
       }.freeze
 
-      def initialize(chat_name:, chat_type: nil, synced_at: nil)
+      # image_link: optional callable returning a relative path for a locally saved InlineImage
+      def initialize(chat_name:, chat_type: nil, synced_at: nil, image_link: nil)
         @chat_name = chat_name
         @chat_type = chat_type
         @synced_at = synced_at
+        @image_link = image_link
       end
 
       # Format an array of Message objects into a Markdown string.
@@ -68,6 +70,7 @@ module Teems
         content = msg.content
         result = content.to_s.empty? ? [] : [content]
         result.concat(format_message_attachments(msg))
+        result.concat(msg.images.map { |image| format_image(image) })
         result.concat(format_message_reactions(msg))
       end
 
@@ -93,6 +96,12 @@ module Teems
         url&.start_with?('https://') ? "\u{1F4CE} [#{name}](#{url})" : "\u{1F4CE} #{name}"
       end
 
+      def format_image(image)
+        label = "image: #{image.label}"
+        path = @image_link&.call(image)
+        path ? "![#{label}](#{path})" : "[#{label}]"
+      end
+
       def format_message_reactions(msg)
         reactions = msg.reactions
         return [] unless displayable_reactions?(reactions)

data/lib/teems/formatters/message_formatter.rb

@@ -21,8 +21,8 @@ module Teems
 
       def format(message)
         content = highlight_mentions(message.content, message.mentions)
-        [format_header(message), "  #{content}", format_attachments(message), format_reactions(message)]
-          .compact.join("\n")
+        [format_header(message), "  #{content}", format_attachments(message), format_images(message),
+         format_reactions(message)].compact.join("\n")
       end
 
       private
@@ -44,6 +44,11 @@ module Teems
         "  #{@output.gray("\u{1F4CE} #{attachment_names(attachments)}")}"
       end
 
+      def format_images(message)
+        summary = FormatUtils.image_summary(message.images)
+        "  #{@output.gray("\u{1F5BC}\u{FE0F} #{summary}")}" unless summary.empty?
+      end
+
       def format_reactions(message)
         reactions = message.reactions
         return unless reactions.any?