openclacky 1.5.13 → 1.5.15

data/lib/clacky/ui2/ui_controller.rb

@@ -10,12 +10,14 @@ require_relative "components/welcome_banner"
 require_relative "components/inline_input"
 require_relative "thinking_verbs"
 require_relative "../ui_interface"
+require_relative "../cli_guidance"
 
 module Clacky
   module UI2
     # UIController is the MVC controller layer that coordinates UI state and user interactions
     class UIController
       include Clacky::UIInterface
+      include Clacky::CliGuidance
 
       attr_reader :layout, :renderer, :running, :inline_input, :input_area
       attr_accessor :config, :available_models
@@ -31,6 +33,7 @@ module Clacky
           working_dir: config[:working_dir],
           mode: config[:mode],
           model: config[:model],
+          reasoning_effort: config[:reasoning_effort],
           theme: config[:theme]
         }
 
@@ -81,6 +84,7 @@ module Clacky
           working_dir: @config[:working_dir],
           mode: @config[:mode],
           model: @config[:model],
+          reasoning_effort: @config[:reasoning_effort],
           tasks: @tasks_count,
           cost: @total_cost
         )
@@ -124,6 +128,7 @@ module Clacky
           working_dir: @config[:working_dir],
           mode: @config[:mode],
           model: @config[:model],
+          reasoning_effort: @config[:reasoning_effort],
           tasks: @tasks_count,
           cost: @total_cost,
           cost_source: cost_source,
@@ -132,6 +137,16 @@ module Clacky
         @layout.render_input
       end
 
+      def refresh_guidance
+        return unless @running
+        @layout.recalculate_layout
+        @layout.render_input
+      end
+
+      def show_user_message(content, created_at: nil, files: [], source: :web, steering: false)
+        append_output(@renderer.render_user_message(content, files: files)) if steering
+      end
+
       def show_goal_status(goal)
         @input_area.set_goal(goal)
         @layout.render_input
@@ -183,6 +198,8 @@ module Clacky
 
       # Set callback for user input
       # @param block [Proc] Callback to execute with user input
+      attr_accessor :queue_input_while_running
+
       def on_input(&block)
         @input_callback = block
       end
@@ -582,7 +599,7 @@ module Clacky
 
       # Show tool result
       # @param result [String] Formatted tool result
-      def show_tool_result(result)
+      def show_tool_result(result, ui: nil)
         output = @renderer.render_tool_result(result: result)
         append_output(output)
       end
@@ -1271,6 +1288,8 @@ module Clacky
           "",
           theme.format_text("Commands:", :info),
           "  #{theme.format_text("/model", :success)}       - Quickly switch the current model",
+          "  #{theme.format_text("/input-mode", :success)} - View or set steer / interrupt behavior",
+          "  #{theme.format_text("/think", :success)}       - Set the thinking (reasoning) effort level",
           "  #{theme.format_text("/config", :success)}      - Configure models, API keys, settings",
           "  #{theme.format_text("/goal", :success)}        - Set a standing goal for autonomous work",
           "    #{theme.format_text("/goal <text>", :dim)}       Set a goal and start working toward it",
@@ -1704,6 +1723,11 @@ module Clacky
           intervene_feedback_countdown
         end
 
+        if !@feedback_countdown && [:ctrl_d, :ctrl_g].include?(key)
+          action = key == :ctrl_d ? :remove : :send_now
+          return if request_guidance_action(action)
+        end
+
         result = @input_area.handle_key(key)
 
         # Handle height change first
@@ -1803,6 +1827,7 @@ module Clacky
             working_dir: @config[:working_dir],
             mode: @config[:mode],
             model: @config[:model],
+            reasoning_effort: @config[:reasoning_effort],
             tasks: @tasks_count,
             cost: @total_cost
           )
@@ -1816,15 +1841,18 @@ module Clacky
         # so no ticker thread is left writing into the buffer while we render
         # the new user message. Each handle's finish() renders its own final
         # frame with elapsed time, so the user still sees a summary.
-        interrupt_all_progress if progress_active?
+        queuing = guidance_deferred?(data[:text])
+        interrupt_all_progress if progress_active? && !queuing
 
         # Also clear stdout buffer used by Ctrl+O (unrelated to progress, but
         # we don't want stale command output carried across user turns).
-        @stdout_lines = nil
-        @stdout_partial_tail = false
+        unless queuing
+          @stdout_lines = nil
+          @stdout_partial_tail = false
+        end
 
         # Render user message immediately before running agent
-        unless data[:text].empty? && data[:files].empty?
+        unless queuing || (data[:text].empty? && data[:files].empty?)
           output = @renderer.render_user_message(data[:text], files: data[:files])
           append_output(output)
         end
@@ -1871,14 +1899,15 @@ module Clacky
             }
           end
 
-          # Add action buttons
-          choices << { name: "─" * 50, disabled: true }
-          choices << { name: "[+] Add New Model", value: { action: :add } }
+          # Add action buttons (sticky: always visible below the scrollable
+          # model list, so a long model list can't push them off screen)
+          choices << { name: "─" * 50, disabled: true, sticky: true }
+          choices << { name: "[+] Add New Model", value: { action: :add }, sticky: true }
           if current_config.models.length > 0
-            choices << { name: "[*] Edit Current Model", value: { action: :edit } }
-            choices << { name: "[-] Delete Model", value: { action: :delete } } if current_config.models.length > 1
+            choices << { name: "[*] Edit Current Model", value: { action: :edit }, sticky: true }
+            choices << { name: "[-] Delete Model", value: { action: :delete }, sticky: true } if current_config.models.length > 1
           end
-          choices << { name: "[X] Close", value: { action: :close } }
+          choices << { name: "[X] Close", value: { action: :close }, sticky: true }
 
           # Show menu
           result = modal.show(
@@ -1903,7 +1932,7 @@ module Clacky
             if new_model
               # Determine anthropic_format based on provider
               # For Anthropic provider, use Anthropic API format
-              anthropic_format = new_model[:provider] == "anthropic"
+              anthropic_format = new_model[:provider] == Clacky::Providers::ANTHROPIC_ID
 
               current_config.add_model(
                 model: new_model[:model],
@@ -2121,6 +2150,37 @@ module Clacky
         result # Return selected task_id or nil
       end
 
+      # Show a reasoning-effort picker for the `/think` command.
+      # @param current_effort [String, nil] the agent's current effort level
+      # @return [String, nil] the chosen level ("off"/"low"/.../"max") or nil if cancelled
+      public def show_reasoning_effort_menu(current_effort)
+        modal = Components::ModalComponent.new
+
+        descriptions = {
+          "off"    => "Provider default (no effort override)",
+          "low"    => "Light reasoning - fastest",
+          "medium" => "Balanced reasoning",
+          "high"   => "Deep reasoning",
+          "xhigh"  => "Extra deep reasoning",
+          "max"    => "Maximum reasoning - slowest"
+        }
+
+        active_index = nil
+        choices = descriptions.keys.each_with_index.map do |level, idx|
+          is_current = current_effort.nil? ? level == "off" : level == current_effort
+          active_index = idx if is_current
+          marker = is_current ? "● " : "  "
+          { name: "#{marker}#{level} - #{descriptions[level]}", value: level }
+        end
+
+        modal.show(
+          title: "Thinking Level - Set Reasoning Effort",
+          choices: choices,
+          initial_index: active_index,
+          on_close: -> { @layout.rerender_all }
+        )
+      end
+
       # Show form for editing a model
       # @param model [Hash, nil] Existing model hash or nil for new model
       # @return [Hash, nil] Updated model hash or nil if cancelled

data/lib/clacky/ui_interface.rb

@@ -14,7 +14,7 @@ module Clacky
     def show_subagent_start(skill: nil, iterations: nil, cost_usd: nil); end
     def show_subagent_end; end
     def show_tool_call(name, args); end
-    def show_tool_result(result); end
+    def show_tool_result(result, ui: nil); end
     def show_tool_stdout(lines); end
     def show_tool_error(error); end
     def show_tool_args(formatted_args); end

data/lib/clacky/utils/file_processor.rb

@@ -299,7 +299,9 @@ module Clacky
       Zip::InputStream.open(StringIO.new(body)) do |zis|
         while (entry = zis.get_next_entry)
           size = entry.size ? " (#{entry.size} bytes)" : ""
-          lines << "- #{entry.name}#{size}"
+          # rubyzip returns names as raw ASCII-8BIT bytes regardless of the zip's
+          # UTF-8 flag; convert so the listing never carries binary encoding.
+          lines << "- #{Clacky::Utils::Encoding.to_utf8(entry.name)}#{size}"
         end
       end
       lines.join("\n")
@@ -325,7 +327,7 @@ module Clacky
             tar.each do |entry|
               kind = entry.directory? ? "[dir] " : ""
               size = entry.header.size ? " (#{entry.header.size} bytes)" : ""
-              lines << "- #{kind}#{entry.full_name}#{size}"
+              lines << "- #{kind}#{Clacky::Utils::Encoding.to_utf8(entry.full_name)}#{size}"
             end
           end
         end
@@ -339,7 +341,7 @@ module Clacky
               tar.each do |entry|
                 kind = entry.directory? ? "[dir] " : ""
                 size = entry.header.size ? " (#{entry.header.size} bytes)" : ""
-                lines << "- #{kind}#{entry.full_name}#{size}"
+                lines << "- #{kind}#{Clacky::Utils::Encoding.to_utf8(entry.full_name)}#{size}"
               end
             end
           end
@@ -359,7 +361,7 @@ module Clacky
                   found_tar = true
                   kind = entry.directory? ? "[dir] " : ""
                   size = entry.header.size ? " (#{entry.header.size} bytes)" : ""
-                  lines << "- #{kind}#{entry.full_name}#{size}"
+                  lines << "- #{kind}#{Clacky::Utils::Encoding.to_utf8(entry.full_name)}#{size}"
                 end
               end
             end
@@ -388,7 +390,8 @@ module Clacky
           end
         end
         lines = ["# GZIP Contents\n"]
-        lines << "- Original filename: #{original_name || "(not recorded)"}"
+        display_name = original_name ? Clacky::Utils::Encoding.to_utf8(original_name) : "(not recorded)"
+        lines << "- Original filename: #{display_name}"
         lines << "- Compressed size:   #{File.size(path)} bytes"
         lines << "- Uncompressed size: #{uncompressed} bytes#{uncompressed && uncompressed > 64 * 1024 * 1024 ? " (truncated)" : ""}"
         lines.join("\n")
@@ -406,7 +409,14 @@ module Clacky
       FileUtils.mkdir_p(UPLOAD_DIR)
       safe_name = File.basename(original_path.to_s).gsub(/[\/\:\*?"<>|\x00]/, "_")
       dest = File.join(UPLOAD_DIR, "#{SecureRandom.hex(8)}_#{safe_name}.preview.md")
-      File.write(dest, content)
+      # File.write transcodes to the default external encoding and raises
+      # "\xE8 from ASCII-8BIT to UTF-8" on binary (ASCII-8BIT) content, which
+      # can leak in from archive entry names / external parsers.
+      text = content.to_s
+      unless text.encoding == ::Encoding::UTF_8 && text.valid_encoding?
+        text = Clacky::Utils::Encoding.to_utf8(text)
+      end
+      File.write(dest, text)
       dest
     end
 
@@ -540,7 +550,9 @@ module Clacky
     LOCAL_IMAGE_EXTENSIONS = %w[.png .jpg .jpeg .gif .webp].freeze
     LOCAL_VIDEO_EXTENSIONS = %w[.mp4 .webm .mov].freeze
     LOCAL_AUDIO_EXTENSIONS = %w[.wav .mp3 .ogg .aac .flac .m4a].freeze
-    LOCAL_MEDIA_EXTENSIONS = (LOCAL_IMAGE_EXTENSIONS + LOCAL_VIDEO_EXTENSIONS + LOCAL_AUDIO_EXTENSIONS).freeze
+    # .pdf: served by /api/local-image so the WebUI file viewer can embed it
+    # in an iframe (browser-native PDF rendering, no extra dependency).
+    LOCAL_MEDIA_EXTENSIONS = (LOCAL_IMAGE_EXTENSIONS + LOCAL_VIDEO_EXTENSIONS + LOCAL_AUDIO_EXTENSIONS + %w[.pdf]).freeze
 
     # Replace local image paths in markdown content with base64 data URLs.
     #

data/lib/clacky/utils/mac_app_detector.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require "open3"
+require "digest"
+require_relative "environment_detector"
+
+module Clacky
+  module Utils
+    # Detects installed macOS applications able to open a given file type.
+    #
+    # Builds an extension → apps index by scanning application bundles and
+    # parsing their Info.plist document declarations (CFBundleDocumentTypes),
+    # then applies a static supplement for well-known apps whose cross-format
+    # abilities are not declared in the plist — e.g. Keynote opens ppt/pptx
+    # without listing them. Non-macOS hosts always answer with an empty list.
+    module MacAppDetector
+      SEARCH_DIRS = [
+        "/Applications",
+        "/System/Applications",
+        File.expand_path("~/Applications")
+      ].freeze
+
+      # bundle name (without .app) => extensions it handles but does not
+      # declare in CFBundleDocumentTypes.
+      EXTRA_ABILITIES = {
+        "Keynote"              => %w[key kth ppt pptx pot pps ppsx],
+        "Pages"                => %w[pages doc docx dot rtf],
+        "Numbers"              => %w[numbers xls xlsx csv],
+        "Preview"              => %w[pdf png jpg jpeg gif tiff tif heic webp svg bmp],
+        "Microsoft PowerPoint" => %w[ppt pptx pot pps ppsx],
+        "Microsoft Word"       => %w[doc docx dot rtf],
+        "Microsoft Excel"      => %w[xls xlsx csv],
+      }.freeze
+
+      # @param ext [String] file extension, with or without leading dot
+      # @return [Array<Hash>] [{ "name" => ..., "path" => bundle path }]
+      def self.apps_for_ext(ext)
+        return [] unless Utils::EnvironmentDetector.os_type == :macos
+
+        ext = ext.to_s.downcase.sub(/\A\./, "")
+        return [] if ext.empty?
+
+        index[ext].sort_by { |a| a["name"] }
+      end
+
+      # Resolve an app name or bundle path to a scanned bundle path.
+      # @return [String, nil]
+      def self.app_path(name_or_path)
+        return nil unless Utils::EnvironmentDetector.os_type == :macos
+
+        all_apps[name_or_path.to_s] || all_apps.key(name_or_path.to_s)
+      end
+
+      # Return the application macOS would use to open `path` (the handler the
+      # plain `open` command would pick). Cached per file extension.
+      # @param path [String] absolute file path
+      # @return [Hash, nil] { "name" => ..., "path" => bundle path }
+      def self.default_app_for(path)
+        return nil unless Utils::EnvironmentDetector.os_type == :macos
+
+        ext = File.extname(path).downcase.sub(/\A\./, "")
+        return nil if ext.empty?
+
+        @default_app_cache ||= {}
+        return @default_app_cache[ext] if @default_app_cache.key?(ext)
+
+        bundle = default_app_bundle(path)
+        @default_app_cache[ext] =
+          if bundle && File.directory?(bundle)
+            { "name" => File.basename(bundle, ".app"), "path" => bundle }
+          end
+      end
+
+      # Query LaunchServices for the default handler of `path` via NSWorkspace.
+      # @return [String, nil] bundle path (…/*.app)
+      def self.default_app_bundle(path)
+        script = <<~JXA
+          (function() {
+            ObjC.import("AppKit");
+            var url = $.NSURL.fileURLWithPath(#{path.to_json});
+            var app = $.NSWorkspace.sharedWorkspace.URLForApplicationToOpenURL(url);
+            return app ? app.path.js : "";
+          })()
+        JXA
+        out, _err, _status = Open3.capture3("osascript", "-l", "JavaScript", "-e", script)
+        result = out.strip
+        result.empty? ? nil : result
+      rescue StandardError
+        nil
+      end
+
+      # Convert an application bundle icon (.icns) to a cached 64px PNG via the
+      # system `sips` tool. Used by the Web UI "open with" dropdown.
+      # @param bundle_path [String] application bundle path (…/*.app)
+      # @return [String, nil] path to the cached PNG file
+      def self.icon_png(bundle_path)
+        return nil unless Utils::EnvironmentDetector.os_type == :macos
+
+        bundle = bundle_path.to_s
+        return nil unless bundle.end_with?(".app") && File.directory?(bundle)
+
+        cache_dir = File.join(Dir.home, "Library", "Caches", "openclacky", "app-icons")
+        cache = File.join(cache_dir, Digest::MD5.hexdigest(bundle) + ".png")
+        return cache if File.exist?(cache)
+
+        info = read_plist(File.join(bundle, "Contents", "Info.plist"))
+        return nil unless info
+
+        icon = info["CFBundleIconFile"].to_s
+        return nil if icon.empty?
+        icon += ".icns" unless icon =~ /\.icns\z/i
+        icns = File.join(bundle, "Contents", "Resources", icon)
+        return nil unless File.exist?(icns)
+
+        require "fileutils"
+        FileUtils.mkdir_p(cache_dir)
+        ok = system("sips", "-s", "format", "png", "--resampleWidth", "64",
+                    icns, "--out", cache, out: File::NULL, err: File::NULL)
+        return nil unless ok && File.exist?(cache)
+        cache
+      end
+
+      # Open a file with a specific installed application (macOS only).
+      # @param path [String] absolute file path
+      # @param app [String] app name or bundle path, must be a scanned app
+      # @return [Boolean, nil] system() result, nil when the app is unknown
+      def self.open_with(path, app)
+        bundle = app_path(app.to_s)
+        return nil unless bundle
+        system("open", "-a", bundle, path)
+      end
+
+      def self.all_apps
+        return @all_apps if defined?(@all_apps)
+
+        @all_apps = {}
+        SEARCH_DIRS.each do |dir|
+          next unless File.directory?(dir)
+          Dir.glob(File.join(dir, "*.app")).each do |bundle|
+            @all_apps[File.basename(bundle, ".app")] = bundle
+          end
+        end
+        @all_apps
+      end
+
+      def self.index
+        return @index if defined?(@index)
+
+        @index = Hash.new { |h, k| h[k] = [] }
+
+        all_apps.each do |name, bundle|
+          info = read_plist(File.join(bundle, "Contents", "Info.plist"))
+          next unless info
+          (info["CFBundleDocumentTypes"] || []).each do |dt|
+            (dt["CFBundleTypeExtensions"] || []).each do |e|
+              add(@index, e.to_s.downcase, name, bundle)
+            end
+          end
+        end
+
+        EXTRA_ABILITIES.each do |name, exts|
+          bundle = all_apps[name]
+          next unless bundle
+          exts.each { |e| add(@index, e, name, bundle) }
+        end
+
+        @index
+      end
+
+      def self.add(index, ext, name, bundle)
+        return if ext.empty?
+        list = index[ext]
+        list << { "name" => name, "path" => bundle } unless list.any? { |a| a["path"] == bundle }
+      end
+
+      def self.read_plist(path)
+        out, _err, _status = Open3.capture3("plutil", "-convert", "json", "-o", "-", path)
+        return nil if out.nil? || out.empty?
+        require "json"
+        JSON.parse(out)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end