openclacky 0.7.0 → 0.7.2

data/lib/clacky/ui2/ui_controller.rb

@@ -6,12 +6,15 @@ require_relative "components/input_area"
 require_relative "components/todo_area"
 require_relative "components/welcome_banner"
 require_relative "components/inline_input"
-require_relative "../thinking_verbs"
+require_relative "thinking_verbs"
+require_relative "../ui_interface"
 
 module Clacky
   module UI2
     # UIController is the MVC controller layer that coordinates UI state and user interactions
     class UIController
+      include Clacky::UIInterface
+
       attr_reader :layout, :renderer, :running, :inline_input, :input_area
       attr_accessor :config
 
@@ -42,11 +45,13 @@ module Clacky
         @running = false
         @input_callback = nil
         @interrupt_callback = nil
+        @time_machine_callback = nil
         @tasks_count = 0
         @total_cost = 0.0
         @progress_thread = nil
         @progress_start_time = nil
         @progress_message = nil
+        @last_diff_lines = nil
       end
 
       # Start the UI controller
@@ -129,6 +134,18 @@ module Clacky
         @layout.cleanup_screen
       end
 
+      # Clear the input area
+      def clear_input
+        @input_area.clear
+      end
+
+      # Set input tips message
+      # @param message [String] Tip message to display
+      # @param type [Symbol] Tip type (:info, :warning, etc.)
+      def set_input_tips(message, type: :info)
+        @input_area.set_tips(message, type: type)
+      end
+
       # Set callback for user input
       # @param block [Proc] Callback to execute with user input
       def on_input(&block)
@@ -147,6 +164,12 @@ module Clacky
         @mode_toggle_callback = block
       end
 
+      # Set callback for time machine (ESC key)
+      # @param block [Proc] Callback to execute on time machine
+      def on_time_machine(&block)
+        @time_machine_callback = block
+      end
+
       # Set skill loader for command suggestions
       # @param skill_loader [Clacky::SkillLoader] The skill loader instance
       def set_skill_loader(skill_loader)
@@ -621,18 +644,31 @@ module Clacky
         diff = Diffy::Diff.new(old_content, new_content, context: 3)
         diff_lines = diff.to_s(:color).lines
 
+        # Store for fullscreen toggle
+        @last_diff_lines = diff_lines
+
         # Show diff without line numbers
         diff_lines.take(max_lines).each do |line|
           append_output(line.chomp)
         end
 
         if diff_lines.size > max_lines
-          append_output("\n... (#{diff_lines.size - max_lines} more lines, diff truncated)")
+          append_output("\n... (#{diff_lines.size - max_lines} more lines, diff truncated. Press Ctrl+O to expand)")
         end
       rescue LoadError
         # Fallback if diffy is not available
         append_output("   Old size: #{old_content.bytesize} bytes")
         append_output("   New size: #{new_content.bytesize} bytes")
+        @last_diff_lines = nil
+      end
+
+      # Show fullscreen diff view (only if not already expanded)
+      private def redisplay_diff
+        return unless @last_diff_lines
+        return if @layout.fullscreen_mode?  # Already in fullscreen, ignore
+
+        # Enter fullscreen diff mode
+        @layout.enter_fullscreen(@last_diff_lines, hint: "Press Ctrl+O to return")
       end
 
       private
@@ -686,15 +722,17 @@ module Clacky
         )
         append_output(content)
 
-        # Check if API key is configured
+        # Check if API key is configured (show warning AFTER banner)
         check_api_key_configuration
       end
 
       # Check if API key is configured and show warning if missing
       private def check_api_key_configuration
-        config = Clacky::Config.load
+        config = Clacky::AgentConfig.load
         
-        if config.api_key.nil? || config.api_key.empty?
+        if !config.models_configured?
+          show_warning("No models configured! Please run /config to set up your models and API keys.")
+        elsif config.api_key.nil? || config.api_key.empty?
           show_warning("API key is not configured! Please run /config to set up your API key.")
         end
       end
@@ -748,6 +786,14 @@ module Clacky
       # Handle keyboard input - delegate to InputArea or InlineInput
       # @param key [Symbol, String, Hash] Key input or rapid input hash
       def handle_key(key)
+        # If in fullscreen mode, only handle Ctrl+O to exit
+        if @layout.fullscreen_mode?
+          if key == :ctrl_o
+            @layout.exit_fullscreen
+          end
+          return
+        end
+
         # If InlineInput is active, delegate to it
         if @inline_input&.active?
           handle_inline_input_key(key)
@@ -778,19 +824,23 @@ module Clacky
           # Notify CLI to handle interrupt (stop agent or exit)
           @interrupt_callback&.call(input_was_empty: input_was_empty)
         when :clear_output
-          # Clear the screen
-          @layout.clear_output
-          # Notify the callback to reset session/agent
-          @input_callback&.call("/clear", [])
+          # Pass to callback with data for display
+          @input_callback&.call("/clear", [], display: result[:data][:display])
         when :scroll_up
           @layout.scroll_output_up
         when :scroll_down
           @layout.scroll_output_down
         when :help
-          show_help
-          @input_area.clear
+          # Pass to callback with data for display
+          @input_callback&.call("/help", [], display: result[:data][:display])
         when :toggle_mode
           toggle_mode
+        when :toggle_expand
+          # Enter fullscreen diff view
+          redisplay_diff
+        when :time_machine
+          # Trigger time machine callback
+          @time_machine_callback&.call
         end
 
         # Always re-render input area after key handling
@@ -813,6 +863,9 @@ module Clacky
         when :submit, :cancel
           # InlineInput is done, will be cleaned up by request_confirmation after collect returns
           nil
+        when :toggle_expand
+          # Enter fullscreen diff view (will return when user presses Ctrl+O)
+          redisplay_diff
         when :toggle_mode
           # Update mode and session bar info, but don't render yet
           current_mode = @config[:mode]
@@ -841,64 +894,290 @@ module Clacky
 
       # Handle submit action
       private def handle_submit(data)
-        # Call callback first (allows interrupting previous agent before showing new input)
-        @input_callback&.call(data[:text], data[:images])
-
-        # Append the input content to output area after callback completes
+        # Append the input content to output area first (so it displays before callback execution)
         @layout.append_output(data[:display]) unless data[:display].empty?
+
+        # Then call callback (allows interrupting previous agent before processing new input)
+        @input_callback&.call(data[:text], data[:images])
       end
 
-      # Show configuration modal dialog
-      # @param current_config [Clacky::Config] Current configuration object
+      # Show configuration modal dialog with multi-model support
+      # @param current_config [Clacky::AgentConfig] Current configuration object
       # @return [Hash, nil] Hash with updated config values, or nil if cancelled
       public def show_config_modal(current_config, test_callback: nil)
         modal = Components::ModalComponent.new
+        
+        loop do
+          # Build menu choices
+          choices = []
+          
+          # Add model list
+          current_config.models.each_with_index do |model, idx|
+            is_current = (idx == current_config.current_model_index)
+            model_name = model["model"] || "unnamed"
+            masked_key = mask_api_key(model["api_key"])
+            
+            # Add type badge if present
+            type_badge = case model["type"]
+                        when "default" then "[default] "
+                        when "lite" then "[lite] "
+                        else ""
+                        end
+            
+            display_name = "#{type_badge}#{model_name} (#{masked_key})"
+            choices << {
+              name: display_name,
+              value: { action: :switch, index: idx }
+            }
+          end
+          
+          # Add action buttons
+          choices << { name: "─" * 50, disabled: true }
+          choices << { name: "[+] Add New Model", value: { action: :add } }
+          choices << { name: "[*] Edit Current Model", value: { action: :edit } }
+          choices << { name: "[-] Delete Model", value: { action: :delete } } if current_config.models.length > 1
+          choices << { name: "[X] Close", value: { action: :close } }
+          
+          # Show menu
+          result = modal.show(title: "Model Configuration", choices: choices)
+          
+          return nil if result.nil?
+          
+          case result[:action]
+          when :switch
+            current_config.switch_model(result[:index])
+            # Auto-save after switching
+            current_config.save
+            # Return to indicate config changed (need to update client)
+            return { action: :switch }
+          when :add
+            new_model = show_model_edit_form(nil, test_callback: test_callback)
+            if new_model
+              # Determine anthropic_format based on provider
+              # For Anthropic provider, use Anthropic API format
+              anthropic_format = new_model[:provider] == "anthropic"
+              
+              current_config.add_model(
+                model: new_model[:model],
+                api_key: new_model[:api_key],
+                base_url: new_model[:base_url],
+                anthropic_format: anthropic_format
+              )
+              # Auto-save after adding
+              current_config.save
+              # Set newly added model as default
+              current_config.switch_model(current_config.models.length - 1)
+              current_config.save
+              # Return to exit the menu
+              return { action: :switch }
+            end
+          when :edit
+            current_model = current_config.current_model
+            edited = show_model_edit_form(current_model, test_callback: test_callback)
+            if edited
+              # Update current model in place (keep anthropic_format unchanged)
+              current_model["api_key"] = edited[:api_key]
+              current_model["model"] = edited[:model]
+              current_model["base_url"] = edited[:base_url]
+              # Auto-save after editing
+              current_config.save
+              # Return to indicate config changed (need to update client)
+              return { action: :edit }
+            end
+          when :delete
+            if current_config.models.length <= 1
+              # Can't delete - show error and continue
+              next
+            end
+            
+            # Delete current model
+            current_config.remove_model(current_config.current_model_index)
+            # Auto-save after deleting
+            current_config.save
+          when :close
+            # Just close the modal
+            return nil
+          end
+        end
+      end
 
+      # Show time machine menu for task undo/redo
+      # @param history [Array<Hash>] Task history with format: [{task_id, summary, status, has_branches}]
+      # @return [Integer, nil] Selected task ID or nil if cancelled
+      public def show_time_machine_menu(history)
+        modal = Components::ModalComponent.new
+        
+        # Build menu choices from history
+        choices = history.map do |task|
+          # Build visual indicator
+          indicator = if task[:status] == :current
+            "→ "  # Current task
+          elsif task[:status] == :future
+            "↯ "  # Future task (after undo)
+          else
+            "  "  # Past task
+          end
+          
+          # Add branch indicator
+          indicator += "⎇ " if task[:has_branches]
+          
+          # Truncate summary to fit on screen
+          max_summary_length = 60
+          summary = task[:summary]
+          if summary.length > max_summary_length
+            summary = summary[0...max_summary_length] + "..."
+          end
+          
+          {
+            name: "#{indicator}Task #{task[:task_id]}: #{summary}",
+            value: task[:task_id]
+          }
+        end
+        
+        # Show modal
+        result = modal.show(
+          title: "Time Machine - Select Task to Navigate",
+          choices: choices
+        )
+        
+        result # Return selected task_id or nil
+      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
+      private def show_model_edit_form(model, test_callback: nil)
+        modal = Components::ModalComponent.new
+        
+        is_new = model.nil?
+        model ||= {}
+        
+        # For new models, show provider selection first
+        selected_provider = nil
+        if is_new
+          # Build provider choices
+          provider_choices = Clacky::Providers.list.map do |id, name|
+            { name: name, value: id }
+          end
+          provider_choices << { name: "─" * 40, disabled: true }
+          provider_choices << { name: "Custom (manual configuration)", value: "custom" }
+          
+          # Show provider selection
+          selected_provider = modal.show(
+            title: "Select Provider",
+            choices: provider_choices
+          )
+          
+          # User cancelled
+          return nil if selected_provider.nil?
+        end
+        
         # Prepare masked API key for display
-        masked_key = if current_config.api_key && !current_config.api_key.empty?
-          "#{current_config.api_key[0..7]}#{'*' * 20}#{current_config.api_key[-4..]}"
-        else
-          "not set"
+        masked_key = mask_api_key(model["api_key"])
+        
+        # Pre-fill values from provider preset if selected
+        provider_preset = nil
+        if selected_provider && selected_provider != "custom"
+          provider_preset = Clacky::Providers.get(selected_provider)
         end
-
+        
+        # Get default values from provider or existing model
+        default_model = provider_preset ? provider_preset["default_model"] : model["model"]
+        default_base_url = provider_preset ? provider_preset["base_url"] : model["base_url"]
+        default_api_key = model["api_key"] || ""
+        
         # Define fields
         fields = [
           {
             name: :api_key,
-            label: "API Key (current: #{masked_key}):",
+            label: "API Key #{is_new ? '' : "(current: #{masked_key})"}:",
             default: "",
             mask: true
           },
           {
             name: :model,
-            label: "Model (current: #{current_config.model}):",
-            default: ""
+            label: "Model #{is_new && default_model ? "(default: #{default_model})" : (is_new ? '' : "(current: #{model['model']})")}:",
+            default: default_model || ""
           },
           {
             name: :base_url,
-            label: "Base URL (current: #{current_config.base_url}):",
-            default: ""
+            label: "Base URL #{is_new && default_base_url ? "(default: #{default_base_url})" : (is_new ? '' : "(current: #{model['base_url']})")}:",
+            default: default_base_url || ""
           }
         ]
-
+        
         # Create validator if test_callback provided
         validator = if test_callback
           lambda do |values|
-            # Merge values with current config
-            test_config = current_config.dup
-            test_config.api_key = values[:api_key] unless values[:api_key].to_s.empty?
-            test_config.model = values[:model] unless values[:model].to_s.empty?
-            test_config.base_url = values[:base_url] unless values[:base_url].to_s.empty?
+            # Merge values: use user input if provided, otherwise keep existing model value
+            api_key = values[:api_key].to_s.empty? ? model["api_key"] : values[:api_key]
+            model_name = values[:model].to_s.empty? ? model["model"] : values[:model]
+            base_url = values[:base_url].to_s.empty? ? model["base_url"] : values[:base_url]
+            anthropic_format = model["anthropic_format"] # Not editable in form, use model's value
+            
+            test_config_values = {
+              "api_key" => api_key,
+              "model" => model_name,
+              "base_url" => base_url,
+              "anthropic_format" => anthropic_format
+            }
             
-            # Call the test callback with merged config
-            test_callback.call(test_config)
+            # For new models, require all fields
+            if is_new
+              if test_config_values["api_key"].to_s.empty?
+                return { success: false, error: "API Key is required for new model" }
+              end
+              if test_config_values["model"].to_s.empty?
+                return { success: false, error: "Model name is required" }
+              end
+              if test_config_values["base_url"].to_s.empty?
+                return { success: false, error: "Base URL is required" }
+              end
+            end
+            
+            # Create a temporary config for testing
+            temp_config = Clacky::AgentConfig.new(models: [test_config_values], current_model_index: 0)
+            test_callback.call(temp_config)
           end
         else
           nil
         end
-
+        
+        # Determine modal title based on provider
+        modal_title = if is_new && selected_provider && selected_provider != "custom"
+          provider_name = Clacky::Providers.get(selected_provider)&.dig("name") || selected_provider
+          "Add #{provider_name} Model"
+        elsif is_new
+          "Add Custom Model"
+        else
+          "Edit Model"
+        end
+        
         # Show modal and collect values
-        modal.show(title: "Configuration", fields: fields, validator: validator)
+        result = modal.show(
+          title: modal_title,
+          fields: fields,
+          validator: validator
+        )
+        
+        return nil if result.nil?
+        
+        # Merge with existing model values or provider defaults
+        {
+          api_key: result[:api_key].to_s.empty? ? model["api_key"] : result[:api_key],
+          model: result[:model].to_s.empty? ? (model["model"] || default_model) : result[:model],
+          base_url: result[:base_url].to_s.empty? ? (model["base_url"] || default_base_url) : result[:base_url],
+          provider: selected_provider
+        }
+      end
+      
+      # Mask API key for display
+      private def mask_api_key(api_key)
+        if api_key && !api_key.empty?
+          "#{api_key[0..5]}...#{api_key[-4..]}"
+        else
+          "not set"
+        end
       end
     end
   end

data/lib/clacky/ui2.rb

@@ -3,6 +3,8 @@
 # UI2 - MVC-based terminal UI system for Clacky
 # Provides split-screen interface with scrollable output and fixed input
 
+require_relative "ui2/thinking_verbs"
+require_relative "ui2/progress_indicator"
 require_relative "ui2/theme_manager"
 require_relative "ui2/screen_buffer"
 require_relative "ui2/layout_manager"

data/lib/clacky/ui_interface.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Clacky
+  # UIInterface defines the standard interface between Agent/CLI and UI implementations.
+  # All UI controllers (UIController, JsonUIController) must implement these methods.
+  module UIInterface
+    # === Output display ===
+    def show_user_message(content, images: []); end
+    def show_assistant_message(content); end
+    def show_tool_call(name, args); end
+    def show_tool_result(result); end
+    def show_tool_error(error); end
+    def show_tool_args(formatted_args); end
+    def show_file_write_preview(path, is_new_file:); end
+    def show_file_edit_preview(path); end
+    def show_file_error(error_message); end
+    def show_shell_preview(command); end
+    def show_diff(old_content, new_content, max_lines: 50); end
+    def show_token_usage(token_data); end
+    def show_complete(iterations:, cost:, duration: nil, cache_stats: nil, awaiting_user_feedback: false); end
+    def append_output(content); end
+
+    # === Status messages ===
+    def show_info(message, prefix_newline: true); end
+    def show_warning(message); end
+    def show_error(message); end
+    def show_success(message); end
+    def log(message, level: :info); end
+
+    # === Progress ===
+    def show_progress(message = nil, prefix_newline: true); end
+    def clear_progress; end
+
+    # === State updates ===
+    def update_sessionbar(tasks: nil, cost: nil, status: nil); end
+    def update_todos(todos); end
+    def set_working_status; end
+    def set_idle_status; end
+
+    # === Blocking interaction ===
+    def request_confirmation(message, default: true); end
+
+    # === Input control (CLI layer) ===
+    def clear_input; end
+    def set_input_tips(message, type: :info); end
+
+    # === Lifecycle ===
+    def stop; end
+  end
+end

data/lib/clacky/utils/arguments_parser.rb

@@ -29,14 +29,42 @@ module Clacky
 
       private
 
-      # Simple JSON repair: complete brackets and quotes
+      # Simple JSON repair: complete brackets and quotes, and remove XML contamination
       def self.repair_json(json_str)
         result = json_str.strip
 
-        # Complete unclosed strings
+        # Step 1: Remove XML-style parameter tags that Claude might mix in
+        # Pattern 1: </parameter> closing tags - remove completely
+        result = result.gsub(/<\/parameter>/, '')
+        
+        # Pattern 2: <parameter name="key"> or <parameter name="key": opening tags -> convert to JSON key
+        # Example: \n<parameter name="end_line"> 330 -> , "end_line": 330
+        # Also handles: \n<parameter name="end_line": 330 -> , "end_line": 330
+        result = result.gsub(/<parameter\s+name="([^"]+)":\s*/) { |match| ", \"#{$1}\": " }
+        result = result.gsub(/<parameter\s+name="([^"]+)">/) { |match| ", \"#{$1}\":" }
+        
+        # Pattern 3: Remove any remaining XML-like tags
+        result = result.gsub(/<[^>]+>/, '')
+
+        # Step 2: Clean up newlines with commas
+        # Example: 315\n, "end_line" -> 315, "end_line"
+        result = result.gsub(/\n\s*,/, ',')
+        result = result.gsub(/,\s*\n/, ',')
+
+        # Step 3: Clean up formatting issues
+        # Remove multiple consecutive commas
+        result = result.gsub(/,+/, ',')
+        # Remove trailing commas before closing braces/brackets
+        result = result.gsub(/,\s*}/, '}')
+        result = result.gsub(/,\s*\]/, ']')
+        # Remove leading commas after opening braces/brackets
+        result = result.gsub(/\{\s*,/, '{')
+        result = result.gsub(/\[\s*,/, '[')
+
+        # Step 4: Complete unclosed strings
         result += '"' if result.count('"').odd?
 
-        # Complete unclosed braces
+        # Step 5: Complete unclosed braces
         depth = 0
         result.each_char { |c| depth += 1 if c == '{'; depth -= 1 if c == '}' }
         result += '}' * depth if depth > 0

data/lib/clacky/utils/file_processor.rb

@@ -166,35 +166,30 @@ module Clacky
         end
 
         # Check if file is binary (not text)
-        # @param data [String] File content
+        # @param data [String] File content (should be read in binary mode, encoding: ASCII-8BIT)
         # @param sample_size [Integer] Number of bytes to check (default: 8192)
         # @return [Boolean] True if file appears to be binary
-        def binary_file?(data, sample_size: 8192, min_binary_length: 512)
-          # Check first N bytes for binary content
-          sample = data[0, sample_size] || ""
+        #
+        # Strategy: only trust known magic byte signatures.
+        # We intentionally avoid heuristics (byte-ratio, UTF-8 validity, etc.) because
+        # they produce false positives on legitimate text files containing multibyte
+        # characters (e.g. Chinese, Japanese). Occasionally missing an unlabelled binary
+        # is acceptable; misclassifying a real text file is not.
+        def binary_file?(data, sample_size: 8192)
+          sample = data.b[0, sample_size] || ""
           return false if sample.empty?
 
-          # Check for known binary signatures first
+          # Check for known binary file signatures (magic bytes)
           FILE_SIGNATURES.each do |signature, _format|
             return true if sample.start_with?(signature)
           end
 
-          # Check for WebP (RIFF format)
-          if sample.start_with?("RIFF".b) && sample.length >= 12 && sample[8..11] == "WEBP".b
+          # Check for WebP (RIFF....WEBP header)
+          if sample.start_with?("RIFF".b) && sample.bytesize >= 12 && sample[8..11] == "WEBP".b
             return true
           end
 
-          # Only check non-printable ratio for samples above minimum length
-          # This prevents short outputs from being incorrectly flagged as binary
-          return false if sample.size < min_binary_length
-
-          # Count non-printable characters (excluding common whitespace)
-          non_printable = sample.bytes.count do |byte|
-            byte < 32 && ![9, 10, 13].include?(byte) || byte >= 127
-          end
-
-          # If more than 30% non-printable, consider it binary
-          (non_printable.to_f / sample.size) > 0.3
+          false
         end
 
         # Check if a file at the given path is binary (not text)

data/lib/clacky/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Clacky
-  VERSION = "0.7.0"
+  VERSION = "0.7.2"
 end