openclacky 0.8.2 → 0.8.4

data/lib/clacky/ui2/screen_buffer.rb

@@ -15,6 +15,10 @@ module Clacky
         @buffer = []
         @last_input_time = nil
         @rapid_input_threshold = 0.01 # 10ms threshold for detecting paste-like rapid input
+
+        # Keep stdin in UTF-8 mode so getc returns complete multi-byte characters (e.g. CJK).
+        # Switching to BINARY would cause getc to return one byte at a time, breaking Chinese input.
+        $stdin.set_encoding('UTF-8')
       end
 
       # Move cursor to specific position (0-indexed)
@@ -138,8 +142,6 @@ module Clacky
       # @param timeout [Float] Timeout in seconds
       # @return [Symbol, String, Hash, nil] Key symbol, character, or { type: :rapid_input, text: String }
       def read_key(timeout: nil)
-        $stdin.set_encoding('UTF-8')
-
         current_time = Time.now.to_f
         is_rapid_input = @last_input_time && (current_time - @last_input_time) < @rapid_input_threshold
         @last_input_time = current_time
@@ -147,8 +149,9 @@ module Clacky
         char = read_char(timeout: timeout)
         return nil unless char
 
-        # Ensure character is UTF-8 encoded
-        char = char.force_encoding('UTF-8') if char.is_a?(String) && char.encoding != Encoding::UTF_8
+        # Convert raw BINARY bytes to valid UTF-8. Invalid/undefined bytes are dropped
+        # rather than raising ArgumentError (which would crash the input loop).
+        char = safe_to_utf8(char) if char.is_a?(String)
 
         # Handle escape sequences for special keys
         if char == "\e"
@@ -179,7 +182,6 @@ module Clacky
         # If this is rapid input or there are more characters available
         if is_rapid_input || has_more_input
           buffer = char.to_s.dup
-          buffer.force_encoding('UTF-8')
 
           # Keep reading available characters
           loop_count = 0
@@ -190,10 +192,10 @@ module Clacky
             has_data = IO.select([$stdin], nil, nil, 0)
 
             if has_data
-              next_char = $stdin.getc
+              next_char = $stdin.getc rescue nil
               break unless next_char
 
-              next_char = next_char.force_encoding('UTF-8') if next_char.encoding != Encoding::UTF_8
+              next_char = safe_to_utf8(next_char)
               buffer << next_char
               loop_count += 1
               empty_checks = 0  # Reset empty check counter
@@ -213,6 +215,8 @@ module Clacky
 
           # If we buffered multiple characters or newlines, treat as rapid input (paste)
           if buffer.length > 1 || buffer.include?("\n") || buffer.include?("\r")
+            # Ensure the accumulated buffer is valid UTF-8 before regex operations
+            buffer = safe_to_utf8(buffer)
             # Remove any trailing \r or \n from rapid input buffer
             cleaned_buffer = buffer.gsub(/[\r\n]+\z/, '')
             return { type: :rapid_input, text: cleaned_buffer } if cleaned_buffer.length > 0
@@ -251,6 +255,19 @@ module Clacky
       end
 
       private
+
+      # Ensure a string is valid UTF-8.
+      # stdin stays in UTF-8 mode so getc returns complete characters (including CJK).
+      # This method handles the rare case where an invalid byte slips through
+      # (e.g. a stray terminal escape or a partial sequence) by scrubbing it out
+      # rather than letting ArgumentError crash the input loop.
+      # @param str [String] String from getc (UTF-8 encoded, but may have invalid bytes)
+      # @return [String] Valid UTF-8 string
+      private def safe_to_utf8(str)
+        return str if str.valid_encoding?
+
+        str.encode('UTF-8', 'UTF-8', invalid: :replace, undef: :replace, replace: '')
+      end
     end
   end
 end

data/lib/clacky/ui2/ui_controller.rb

@@ -90,6 +90,13 @@ module Clacky
         input_loop
       end
 
+      # Set skill loader for command suggestions in the input area
+      # @param skill_loader [Clacky::SkillLoader] The skill loader instance
+      # @param agent_profile [Clacky::AgentProfile, nil] Current agent profile for skill filtering
+      def set_skill_loader(skill_loader, agent_profile = nil)
+        @input_area.set_skill_loader(skill_loader, agent_profile)
+      end
+
       # Update session bar with current stats
       # @param tasks [Integer] Number of completed tasks (optional)
       # @param cost [Float] Total cost (optional)
@@ -170,11 +177,11 @@ module Clacky
         @time_machine_callback = block
       end
 
-      # Set skill loader for command suggestions
-      # @param skill_loader [Clacky::SkillLoader] The skill loader instance
+      # Set agent for command suggestions
+      # @param agent [Clacky::Agent] The agent instance with skill management
       # @param agent_profile [Clacky::AgentProfile, nil] Current agent profile for skill filtering
-      def set_skill_loader(skill_loader, agent_profile = nil)
-        @input_area.set_skill_loader(skill_loader, agent_profile)
+      def set_agent(agent, agent_profile = nil)
+        @input_area.set_agent(agent, agent_profile)
       end
 
       # Append output to the output area
@@ -450,6 +457,10 @@ module Clacky
         @progress_message = message || Clacky::THINKING_VERBS.sample
         @progress_start_time = Time.now
         @progress_output_buffer = output_buffer
+        # Flag used by the progress thread to know when to stop gracefully.
+        # Using a flag + join is safe because Thread#kill can interrupt a thread
+        # while it holds @render_mutex, causing a permanent deadlock.
+        @progress_thread_stop = false
 
         # Show initial progress (yellow, active)
         append_output("") if prefix_newline
@@ -459,15 +470,19 @@ module Clacky
 
         # Start background thread to update elapsed time
         @progress_thread = Thread.new do
-          while @progress_start_time
+          until @progress_thread_stop
             sleep 0.5
-            next unless @progress_start_time
+            next if @progress_thread_stop
+
+            start = @progress_start_time
+            next unless start
 
-            elapsed = (Time.now - @progress_start_time).to_i
-            hint = output_buffer ? "(Ctrl+C to interrupt · Ctrl+O to view output · #{elapsed}s)" : "(Ctrl+C to interrupt · #{elapsed}s)"
+            elapsed = (Time.now - start).to_i
+            buf = @progress_output_buffer
+            hint = buf ? "(Ctrl+C to interrupt · Ctrl+O to view output · #{elapsed}s)" : "(Ctrl+C to interrupt · #{elapsed}s)"
             update_progress_line(@renderer.render_working("#{@progress_message}… #{hint}"))
           end
-        rescue => e
+        rescue StandardError
           # Silently handle thread errors
         end
       end
@@ -489,14 +504,32 @@ module Clacky
         end
       end
 
-      # Stop the progress update thread
+      # Stop the fullscreen refresh thread gracefully via flag + join.
+      def stop_fullscreen_refresh_thread
+        @fullscreen_refresh_stop = true
+        if @fullscreen_refresh_thread&.alive?
+          joined = @fullscreen_refresh_thread.join(1.0)
+          @fullscreen_refresh_thread.kill unless joined
+        end
+        @fullscreen_refresh_thread = nil
+        @fullscreen_refresh_stop = false
+      end
+
+      # Stop the progress update thread gracefully.
+      # We signal the thread via a stop flag and then join it, avoiding Thread#kill
+      # which can interrupt a thread mid-critical-section (e.g. while holding
+      # @render_mutex) and leave the mutex permanently locked.
       def stop_progress_thread
         @progress_start_time = nil
-        @progress_output_buffer = nil  # Clear output buffer reference
+        @progress_output_buffer = nil
+        @progress_thread_stop = true
         if @progress_thread&.alive?
-          @progress_thread.kill
-          @progress_thread = nil
+          # Join with a short timeout; fall back to kill only as a last resort
+          joined = @progress_thread.join(1.0)
+          @progress_thread.kill unless joined
         end
+        @progress_thread = nil
+        @progress_thread_stop = false
       end
 
       # Show info message
@@ -703,12 +736,15 @@ module Clacky
         lines = build_command_output_lines
         @layout.enter_fullscreen(lines, hint: "Press Ctrl+O to return · Output updates in real-time")
 
-        # Start background thread to refresh fullscreen content in real-time
+        # Start background thread to refresh fullscreen content in real-time.
+        # Use a dedicated stop flag so we can join() the thread cleanly and
+        # avoid Thread#kill interrupting the thread while it holds @render_mutex.
         buffer_ref = @progress_output_buffer
+        @fullscreen_refresh_stop = false
         @fullscreen_refresh_thread = Thread.new do
-          while @layout.fullscreen_mode?
+          until @fullscreen_refresh_stop || !@layout.fullscreen_mode?
             sleep 0.3
-            break unless @layout.fullscreen_mode?
+            next if @fullscreen_refresh_stop || !@layout.fullscreen_mode?
 
             updated_lines = build_command_output_lines_from(buffer_ref)
             @layout.refresh_fullscreen(updated_lines)
@@ -863,9 +899,10 @@ module Clacky
         # If in fullscreen mode, only handle Ctrl+O to exit
         if @layout.fullscreen_mode?
           if key == :ctrl_o
-            # Kill the real-time refresh thread before exiting fullscreen
-            @fullscreen_refresh_thread&.kill
-            @fullscreen_refresh_thread = nil
+            # Signal the real-time refresh thread to stop gracefully, then join it.
+            # Avoid Thread#kill which can interrupt the thread mid-render and
+            # leave @render_mutex permanently locked.
+            stop_fullscreen_refresh_thread
             @layout.exit_fullscreen
             # Restore main screen content after returning from alternate buffer
             @layout.rerender_all

data/lib/clacky/version.rb

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