openclacky 1.2.5 → 1.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 234f676c7efe1f2803eeb4f262b20014e2a4b967442a03af70dc3e04e81b4f6b
-  data.tar.gz: 6e9161983ebec82c44467a28e92ff25636718942bec953ebdc7ef6593b515c7e
+  metadata.gz: a71c34a2e50f2202679cafd9c31fe7807ea5e9a6a6fad42ba352e19f9ea01282
+  data.tar.gz: 3baa2b1aed288586bec516576bf8729b630392e4e4b9aeb3b65bca704060b3d1
 SHA512:
-  metadata.gz: afd3471fa15b77e3921aa640fbfd7cf937030478d834c06d0ad2d52faa6ada82561929ce7aa4ac2b075a71b1cf97bd5295ec80af4d2903dbf55c983bb4263e1f
-  data.tar.gz: 7713e3b3a0aa9775a4a993b651a536552963320787f072ea6f79dbde0bf345a1d680b3cc0a07eec1d5667da69899f770344ba376b52d44d12360ac3ec60402a4
+  metadata.gz: e334e6f5e8726d02933c60d69aed8da4b98f417b1f7d0e0676b3d58bc8a15f9214317a5cde6f3ef8094f69e1fdff8cee6fb822beb076c0eef9e5544770256029
+  data.tar.gz: 76c8e019789e513382079f942dd7d4036dd68f7b6dac26822e6ec4e0dda410e8d2ad55b1ebaabd58ad388fb2cafa4fa1cb3350fc9a5673fbbb9120893c98ffd6

data/CHANGELOG.md

@@ -5,6 +5,29 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.2.6] - 2026-05-29
+
+### Added
+- WPS format support for document processing
+- `--json` flag support with `-m` option
+
+### Improved
+- Billing UI and model filtering experience
+- Brand skill download now retries on failure
+- DeepSeek compatibility handling within OpenRouter provider
+
+### Fixed
+- Claude `tool_use.id` error when switching between models
+- Browser page navigation pageid bug
+- Browser IIFE execution issue
+- WSL UTF-8 command encoding bug
+- File preview path directory resolution
+
+### More
+- Remove list/undo/redo task tool
+- Clean up legacy provider code
+- Improve platform error messages for easier diagnostics
+
 ## [1.2.5] - 2026-05-28
 
 ### Fixed

data/lib/clacky/agent/cost_tracker.rb

@@ -17,7 +17,8 @@ module Clacky
       # Updates total cost and displays iteration statistics
       # @param usage [Hash] Usage data from API response
       # @param raw_api_usage [Hash, nil] Raw API usage data for debugging
-      def track_cost(usage, raw_api_usage: nil)
+      # @param model [String, nil] Model name to use for billing (defaults to current_model)
+      def track_cost(usage, raw_api_usage: nil, model: nil)
         # Priority 1: Use API-provided cost if available (OpenRouter, LiteLLM, etc.)
         iteration_cost = nil
         if usage[:api_cost]
@@ -28,7 +29,10 @@ module Clacky
           @ui&.log("Using API-provided cost: $#{usage[:api_cost]}", level: :debug) if @config.verbose
         else
           # Priority 2: Calculate from tokens using ModelPricing
-          result = ModelPricing.calculate_cost(model: current_model, usage: usage)
+          # Use provided model name (from API call time) to ensure accurate billing
+          # even if the user switches models during the API call
+          billing_model = model || current_model
+          result = ModelPricing.calculate_cost(model: billing_model, usage: usage)
           cost = result[:cost]
           pricing_source = result[:source]
 
@@ -101,7 +105,7 @@ module Clacky
 
         # Persist billing record (skip for subagents to avoid double-counting)
         unless @is_subagent
-          persist_billing_record(usage, iteration_cost)
+          persist_billing_record(usage, iteration_cost, model: model)
         end
 
         # Return token_data so the caller can display it at the right moment
@@ -111,25 +115,29 @@ module Clacky
       # Persist a billing record to the billing store
       # @param usage [Hash] Usage data from API
       # @param cost [Float, nil] Calculated cost for this iteration
-      def persist_billing_record(usage, cost)
-        return if cost.nil? # Skip if cost is unknown
+      # @param model [String, nil] Model name to use for billing (defaults to current_model)
+      def persist_billing_record(usage, cost, model: nil)
+        # Always save billing records for usage tracking, even if cost is unknown (nil).
+        # This ensures all API calls are recorded for statistics purposes.
+        billing_model = model || current_model
+        effective_cost = cost || 0.0  # Use 0 if pricing is unknown
 
         record = Billing::BillingRecord.new(
           session_id: @session_id,
           timestamp: Time.now,
-          model: current_model,
+          model: billing_model,
           prompt_tokens: usage[:prompt_tokens] || 0,
           completion_tokens: usage[:completion_tokens] || 0,
           cache_read_tokens: usage[:cache_read_input_tokens] || 0,
           cache_write_tokens: usage[:cache_creation_input_tokens] || 0,
-          cost_usd: cost,
-          cost_source: @cost_source
+          cost_usd: effective_cost,
+          cost_source: cost.nil? ? :unknown : @cost_source
         )
 
         billing_store.append(record)
       rescue => e
         # Billing persistence is non-critical; log and continue
-        @ui&.log("Failed to persist billing record: #{e.message}", level: :debug) if @config&.verbose
+        Clacky::Logger.warn("billing.persist_error", error: e.message, model: billing_model)
       end
 
       # Estimate token count for a message content

data/lib/clacky/agent/llm_caller.rb

@@ -88,6 +88,11 @@ module Clacky
         # the error propagate.
         context_overflow_retry_attempted = false
 
+        # Capture model name at API call time for accurate billing tracking.
+        # If the user switches models while the API call is in progress, we still
+        # want to bill under the model that actually handled the request.
+        api_call_model = current_model
+
         begin
           begin
           # Use active_messages (Time Machine) when undone, otherwise send full history.
@@ -100,7 +105,7 @@ module Clacky
 
           response = @client.send_messages_with_tools(
             messages_to_send,
-            model: current_model,
+            model: api_call_model,
             tools: tools_to_send,
             max_tokens: @config.max_tokens,
             enable_caching: @config.enable_prompt_caching,
@@ -124,8 +129,22 @@ module Clacky
           # block below handles retry + fallback identically to 5xx/429.
           detect_upstream_truncation!(response)
 
+          # Empty response detector: model returned nothing (no content, no
+          # tool_calls, finish_reason != "stop"). DeepSeek via OpenRouter
+          # occasionally does this. Treat as transient failure and retry.
+          if response[:content].to_s.strip.empty? &&
+              (response[:tool_calls].nil? || response[:tool_calls].empty?) &&
+              response[:finish_reason].to_s != "stop" &&
+              response[:finish_reason].to_s != "length"
+            Clacky::Logger.warn("llm.empty_response_detected",
+              model: api_call_model,
+              finish_reason: response[:finish_reason].to_s,
+              completion_tokens: response.dig(:token_usage, :completion_tokens)
+            )
+            raise RetryableError, "[LLM] Model returned empty response (no content, no tool_calls), retrying..."
+          end
+
         rescue Faraday::TimeoutError => e
-          # ── Read-timeout path (distinct from connection-level failures) ──
           # Faraday::TimeoutError on our non-streaming POST almost always means
           # the *response* took longer than the 300s read-timeout to come back —
           # i.e. the model is trying to produce a huge output in one shot
@@ -210,6 +229,7 @@ module Clacky
           if retries <= current_max
             if retries == RETRIES_BEFORE_FALLBACK && !@config.fallback_active?
               if try_activate_fallback(current_model)
+                api_call_model = current_model
                 retries = 0
                 retry
               end
@@ -299,7 +319,9 @@ module Clacky
         end
 
         # Track cost and collect token usage data.
-        token_data = track_cost(response[:usage], raw_api_usage: response[:raw_api_usage])
+        # Pass the model name captured at API call time to ensure accurate billing
+        # even if the user switched models during the (potentially long) API call.
+        token_data = track_cost(response[:usage], raw_api_usage: response[:raw_api_usage], model: api_call_model)
         response[:token_usage] = token_data
 
         # [DIAG] Log raw client response shape. Only emit when we see the

data/lib/clacky/agent/tool_executor.rb

@@ -108,6 +108,15 @@ module Clacky
           preview_error
         rescue JSON::ParserError
           nil
+        rescue StandardError => e
+          @debug_logs << {
+            timestamp: Time.now.iso8601,
+            event: "tool_preview_error",
+            tool_name: call[:name],
+            error_class: e.class.name,
+            error_message: e.message
+          }
+          nil
         end
       end
 
@@ -397,6 +406,11 @@ module Clacky
           return { error: "File not found: #{path}", path: path }
         end
 
+        if File.directory?(expanded_path)
+          @ui&.show_file_error("Path is a directory, not a file: #{path}")
+          return { error: "Path is a directory, not a file: #{path}", path: path }
+        end
+
         if old_string.empty?
           @ui&.show_file_error("No old_string provided (nothing to replace)")
           return { error: "No old_string provided (nothing to replace)" }

data/lib/clacky/agent/tool_registry.rb

@@ -59,13 +59,6 @@ module Clacky
       "ask_user" => "request_user_feedback",
       "user_feedback" => "request_user_feedback",
       "ask" => "request_user_feedback",
-      # undo_task aliases
-      "undo" => "undo_task",
-      # redo_task aliases
-      "redo" => "redo_task",
-      # list_tasks aliases
-      "tasks" => "list_tasks",
-      "task_history" => "list_tasks",
       # trash_manager aliases
       "trash" => "trash_manager",
       "delete" => "trash_manager",

data/lib/clacky/agent.rb

@@ -902,11 +902,6 @@ module Clacky
             args[:skill_loader] = @skill_loader
           end
 
-          # Special handling for Time Machine tools: inject agent
-          if ["undo_task", "redo_task", "list_tasks"].include?(call[:name])
-            args[:agent] = self
-          end
-
           # Inject working_dir so tools don't rely on Dir.chdir global state
           args[:working_dir] = @working_dir if @working_dir
 
@@ -1183,9 +1178,6 @@ module Clacky
       @tool_registry.register(Tools::TodoManager.new)
       @tool_registry.register(Tools::RequestUserFeedback.new)
       @tool_registry.register(Tools::InvokeSkill.new)
-      @tool_registry.register(Tools::UndoTask.new)
-      @tool_registry.register(Tools::RedoTask.new)
-      @tool_registry.register(Tools::ListTasks.new)
       @tool_registry.register(Tools::Browser.new)
     end
 

data/lib/clacky/billing/billing_store.rb

@@ -74,10 +74,11 @@ module Clacky
 
       # Get summary statistics for a time period
       # @param period [Symbol] :day, :week, :month, :year, or :all
+      # @param model [String, nil] Filter by model name
       # @return [Hash] Summary with total_cost, total_tokens, by_model, etc.
-      def summary(period: :month)
+      def summary(period: :month, model: nil)
         from_time = period_start(period)
-        records = query(from: from_time)
+        records = query(from: from_time, model: model)
 
         total_cost = records.sum { |r| r.cost_usd || 0 }
         total_prompt = records.sum { |r| r.prompt_tokens || 0 }
@@ -116,10 +117,11 @@ module Clacky
 
       # Get daily cost breakdown for the last N days
       # @param days [Integer] Number of days to include
+      # @param model [String, nil] Filter by model name
       # @return [Array<Hash>] Daily summaries with date and cost
-      def daily_breakdown(days: 30)
+      def daily_breakdown(days: 30, model: nil)
         from_time = Time.now - (days * 24 * 60 * 60)
-        records = query(from: from_time)
+        records = query(from: from_time, model: model)
 
         by_day = records.group_by { |r| r.timestamp.strftime("%Y-%m-%d") }
 
@@ -159,6 +161,62 @@ module Clacky
         deleted
       end
 
+      # Clear billing records
+      # @param scope [Symbol] :today or :all
+      # @return [Integer] Number of records/files deleted
+      def clear(scope: :today)
+        case scope
+        when :today
+          clear_today
+        when :all
+          clear_all
+        else
+          0
+        end
+      end
+
+      private def clear_today
+        # Remove today's records from the current month file
+        month_file = current_month_file
+        return 0 unless File.exist?(month_file)
+
+        today_start = Time.new(Time.now.year, Time.now.month, Time.now.day)
+        kept_lines = []
+        deleted_count = 0
+
+        File.foreach(month_file) do |line|
+          next if line.strip.empty?
+
+          begin
+            hash = JSON.parse(line, symbolize_names: true)
+            record_time = Time.parse(hash[:timestamp].to_s) rescue nil
+
+            if record_time && record_time >= today_start
+              deleted_count += 1
+            else
+              kept_lines << line
+            end
+          rescue JSON::ParserError
+            kept_lines << line
+          end
+        end
+
+        # Rewrite the file without today's records
+        File.open(month_file, "w") do |f|
+          kept_lines.each { |line| f.print(line) }
+        end
+        FileUtils.chmod(0o600, month_file) if File.exist?(month_file)
+
+        deleted_count
+      end
+
+      private def clear_all
+        # Delete all billing files
+        files = billing_files
+        files.each { |f| File.delete(f) }
+        files.size
+      end
+
       private def ensure_billing_dir
         FileUtils.mkdir_p(@billing_dir) unless Dir.exist?(@billing_dir)
       end

data/lib/clacky/brand_config.rb

@@ -737,6 +737,9 @@ module Clacky
       dl = platform_client.download_file(url, tmp_zip)
       raise dl[:error].to_s unless dl[:success]
 
+      zip_size = File.size?(tmp_zip).to_i
+      raise "Empty ZIP downloaded for #{slug}" if zip_size < 22  # min valid zip = empty central directory
+
       # Extract into dest_dir (overwrite existing files).
       # Auto-detect whether the zip has a single root folder to strip.
       # Uses get_input_stream instead of entry.extract to avoid rubyzip 3.x
@@ -780,6 +783,12 @@ module Clacky
 
       FileUtils.rm_f(tmp_zip)
 
+      if encrypted
+        manifest_path = File.join(dest_dir, "MANIFEST.enc.json")
+        raise "MANIFEST.enc.json missing after extraction" unless File.exist?(manifest_path)
+        JSON.parse(File.read(manifest_path))
+      end
+
       record_installed_skill(slug, version, skill_info["description"],
                              encrypted: encrypted,
                              description_zh: skill_info["description_zh"],
@@ -787,6 +796,8 @@ module Clacky
 
       { success: true, name: slug, version: version }
     rescue StandardError, ScriptError => e
+      FileUtils.rm_f(tmp_zip) if defined?(tmp_zip) && tmp_zip
+      FileUtils.rm_rf(dest_dir) if defined?(dest_dir) && dest_dir
       { success: false, error: e.message }
     end
 

data/lib/clacky/cli.rb

@@ -403,6 +403,23 @@ module Clacky
         agent.rename(auto_name)
       end
 
+      # Format error message and backtrace (first 3 lines) for session saving
+      private def format_error(e)
+        "#{e.message}\n#{e.backtrace&.first(3)&.join("\n")}"
+      end
+
+      # Validates non-interactive file paths and maps them to hashes with detected MIME types
+      private def prepare_non_interactive_files(file_paths)
+        file_paths.each do |path|
+          raise ArgumentError, "File not found: #{path}" unless File.exist?(path)
+        end
+        # Convert file paths to file hashes — agent.run decides how to handle each
+        file_paths.map do |path|
+          mime = Utils::FileProcessor.detect_mime_type(path) rescue "application/octet-stream"
+          { name: File.basename(path), mime_type: mime, path: path }
+        end
+      end
+
       def validate_working_directory(path, config = nil)
         working_dir = path || Dir.pwd
 
@@ -540,7 +557,7 @@ module Clacky
           session_manager&.save(agent.to_session_data(status: :interrupted))
           ui_controller.show_warning("Task interrupted by user")
         else
-          error_message = "#{exception.message}\n#{exception.backtrace&.first(3)&.join("\n")}"
+          error_message = format_error(exception)
           session_manager&.save(agent.to_session_data(status: :error, error_message: error_message))
           ui_controller.show_error("Error: #{exception.message}")
         end
@@ -553,31 +570,61 @@ module Clacky
         # Force auto-approve — no one is around to confirm anything
         agent_config.permission_mode = :auto_approve
 
-        # Validate paths up-front so we fail fast with a clear message
-        file_paths.each do |path|
-          raise ArgumentError, "File not found: #{path}" unless File.exist?(path)
-        end
+        is_json = !!options[:json]
 
-        # Convert file paths to file hashes — agent.run decides how to handle each
-        files = file_paths.map do |path|
-          mime = Utils::FileProcessor.detect_mime_type(path) rescue "application/octet-stream"
-          { name: File.basename(path), mime_type: mime, path: path }
+        # Validate and prepare files up-front (DRY)
+        begin
+          files = prepare_non_interactive_files(file_paths)
+        rescue => e
+          session_manager&.save(agent.to_session_data(status: :error, error_message: format_error(e)))
+
+          if is_json
+            ui = Clacky::JsonUIController.new
+            ui.emit("error", message: e.message)
+            ui.set_idle_status
+          else
+            $stderr.puts "Error: #{e.message}"
+          end
+          exit(1)
         end
 
-        # Wire up plain-text stdout UI so all agent output is visible
-        plain_ui = Clacky::PlainUIController.new
-        agent.instance_variable_set(:@ui, plain_ui)
 
-        auto_name_session(agent, message)
-        agent.run(message, files: files)
-        session_manager&.save(agent.to_session_data(status: :success))
-        exit(0)
-      rescue Clacky::AgentInterrupted
-        $stderr.puts "\nInterrupted."
-        exit(1)
-      rescue => e
-        $stderr.puts "Error: #{e.message}"
-        exit(1)
+        # Wire up the appropriate UI controller and execute
+        if is_json
+          ui = Clacky::JsonUIController.new
+          agent.instance_variable_set(:@ui, ui)
+          ui.emit("system", message: "Agent started", model: agent_config.model_name, working_dir: agent.working_dir)
+
+          status = run_json_task(agent, ui, session_manager) do
+            auto_name_session(agent, message)
+            agent.run(message, files: files)
+          end
+
+          if status == :success
+            ui.emit("done", total_cost: agent.total_cost, total_tasks: agent.total_tasks)
+            exit(0)
+          else
+            exit(1)
+          end
+        else
+          ui = Clacky::PlainUIController.new
+          agent.instance_variable_set(:@ui, ui)
+
+          begin
+            auto_name_session(agent, message)
+            agent.run(message, files: files)
+            session_manager&.save(agent.to_session_data(status: :success))
+            exit(0)
+          rescue Clacky::AgentInterrupted
+            session_manager&.save(agent.to_session_data(status: :interrupted))
+            $stderr.puts "\nInterrupted."
+            exit(1)
+          rescue => e
+            session_manager&.save(agent.to_session_data(status: :error, error_message: format_error(e)))
+            $stderr.puts "Error: #{e.message}"
+            exit(1)
+          end
+        end
       end
 
       # Run agent with JSON (NDJSON) output mode — persistent process.
@@ -620,6 +667,7 @@ module Clacky
               next
             end
 
+
             # Handle built-in commands
             case content.downcase
             when "/exit", "/quit"
@@ -658,12 +706,15 @@ module Clacky
         yield
         session_manager&.save(agent.to_session_data(status: :success))
         json_ui.update_sessionbar(tasks: agent.total_tasks, cost: agent.total_cost)
+        :success
       rescue Clacky::AgentInterrupted
         session_manager&.save(agent.to_session_data(status: :interrupted))
         json_ui.emit("interrupted")
+        :interrupted
       rescue => e
-        session_manager&.save(agent.to_session_data(status: :error, error_message: e.message))
+        session_manager&.save(agent.to_session_data(status: :error, error_message: format_error(e)))
         json_ui.emit("error", message: e.message)
+        :error
       ensure
         json_ui.set_idle_status
       end

data/lib/clacky/client.rb

@@ -351,7 +351,10 @@ module Clacky
         end
       end
 
-      raise_error(response) unless response.status == 200
+      unless response.status == 200
+        response.env.body = sse_buf if response.body.to_s.empty?
+        raise_error(response)
+      end
       MessageFormat::OpenAI.parse_response(aggregator.to_h)
     end
 
@@ -534,6 +537,12 @@ module Clacky
       error_body    = JSON.parse(response.body) rescue nil
       error_message = extract_error_message(error_body, response.body)
 
+      Clacky::Logger.warn("client.raise_error",
+        status: response.status,
+        body: response.body.to_s[0, 2000],
+        error_message: error_message.to_s[0, 500]
+      )
+
       case response.status
       when 400
         # Well-behaved APIs (Anthropic, OpenAI) never put quota/availability issues in 400.
@@ -570,14 +579,39 @@ module Clacky
         return "Invalid API endpoint or server error (received HTML instead of JSON)"
       end
 
+      return "(empty response body)" if raw_body.to_s.strip.empty? && !error_body.is_a?(Hash)
       return raw_body unless error_body.is_a?(Hash)
 
       error_body["upstreamMessage"]&.then { |m| return m unless m.empty? }
-      error_body.dig("error", "message")&.then { |m| return m } if error_body["error"].is_a?(Hash)
+
+      if error_body["error"].is_a?(Hash)
+        upstream_msg = extract_upstream_error(error_body["error"])
+        return upstream_msg if upstream_msg
+      end
+
       error_body["message"]&.then             { |m| return m }
       error_body["error"].is_a?(String) ? error_body["error"] : (raw_body.to_s[0..200] + (raw_body.to_s.length > 200 ? "..." : ""))
     end
 
+    # OpenRouter nests the real provider error inside metadata.raw as a JSON string.
+    private def extract_upstream_error(error_hash)
+      raw = error_hash.dig("metadata", "raw")
+      if raw.is_a?(String) && !raw.empty?
+        nested = JSON.parse(raw) rescue nil
+        if nested.is_a?(Hash)
+          details = nested.dig("error", "details")
+          if details.is_a?(String) && !details.empty?
+            innermost = JSON.parse(details) rescue nil
+            if innermost.is_a?(Hash) && innermost.dig("error", "message")
+              return innermost.dig("error", "message")
+            end
+          end
+          return nested.dig("error", "message") if nested.dig("error", "message")
+        end
+      end
+      error_hash["message"]
+    end
+
     # Parse JSON with user-friendly error messages.
     # @param json_string [String] the JSON string to parse
     # @param context [String] a description of what's being parsed (e.g., "LLM response")

data/lib/clacky/default_parsers/wps_parser.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+#
+# Clacky WPS Parser — CLI interface
+#
+# Handles WPS Office formats:
+#   .wps — WPS Writer (word processor)
+#   .et  — WPS Spreadsheet
+#   .dps — WPS Presentation
+#
+# Usage:
+#   ruby wps_parser.rb <file_path>
+#
+# Output:
+#   stdout — extracted text content (UTF-8)
+#   stderr — error messages
+#   exit 0 — success
+#   exit 1 — failure
+#
+# VERSION: 1
+
+require "open3"
+require "tmpdir"
+require "fileutils"
+
+MIN_CONTENT_BYTES = 20
+
+# Convert WPS formats to text using LibreOffice headless mode.
+# .et (spreadsheet) → csv for structured output; .wps/.dps → txt.
+def try_libreoffice(path, ext)
+  Dir.mktmpdir("clacky-wps") do |dir|
+    output_ext = ext == ".et" ? "csv" : "txt"
+    _stdout, _stderr, status = Open3.capture3(
+      "libreoffice", "--headless", "--convert-to", output_ext,
+      "--outdir", dir, path
+    )
+    return nil unless status.success?
+
+    output_file = Dir.glob(File.join(dir, "*.#{output_ext}")).first
+    return nil unless output_file && File.exist?(output_file)
+
+    text = File.read(output_file).strip
+    return nil if text.bytesize < MIN_CONTENT_BYTES
+    text
+  end
+rescue Errno::ENOENT
+  nil
+end
+
+# --- main ---
+
+path = ARGV[0]
+
+if path.nil? || path.empty?
+  warn "Usage: ruby wps_parser.rb <file_path>"
+  exit 1
+end
+
+unless File.exist?(path)
+  warn "File not found: #{path}"
+  exit 1
+end
+
+ext = File.extname(path).downcase
+
+unless %w[.wps .et .dps].include?(ext)
+  warn "Unsupported WPS format: #{ext}"
+  exit 1
+end
+
+text = try_libreoffice(path, ext)
+
+if text
+  print text
+  exit 0
+else
+  warn "Could not extract text from #{ext} file."
+  warn "Tip: install LibreOffice to enable WPS format support."
+  warn "  macOS:  brew install --cask libreoffice"
+  warn "  Linux:  apt install libreoffice"
+  exit 1
+end