openclacky 0.6.2 → 0.6.4

data/lib/clacky/ui2/layout_manager.rb

@@ -14,6 +14,7 @@ module Clacky
         @todo_area = todo_area
         @render_mutex = Mutex.new
         @output_row = 0  # Track current output row position
+        @last_fixed_area_height = 0  # Track previous fixed area height to detect shrinkage
 
         calculate_layout
         setup_resize_handler
@@ -91,11 +92,19 @@ module Clacky
       def position_inline_input_cursor(inline_input)
         return unless inline_input
 
-        # Calculate the actual terminal cursor position considering multi-byte characters
-        # InlineInput is on the last output line (@output_row - 1)
-        cursor_row = @output_row - 1
-        cursor_col = inline_input.cursor_col  # This already considers display width
-        
+        # Use the shared method from LineEditor to calculate cursor position with wrap
+        prompt = inline_input.prompt
+        width = screen.width
+        wrap_row, wrap_col = inline_input.cursor_position_with_wrap(prompt, width)
+
+        # Get the number of lines InlineInput occupies (considering wrapping)
+        line_count = inline_input.line_count(width)
+
+        # InlineInput starts at @output_row - line_count
+        # Cursor is at wrap_row within that
+        cursor_row = @output_row - line_count + wrap_row
+        cursor_col = wrap_col
+
         # Move terminal cursor to the correct position
         screen.move_cursor(cursor_row, cursor_col)
         screen.flush
@@ -184,11 +193,11 @@ module Clacky
 
         @render_mutex.synchronize do
           lines = content.split("\n", -1)  # -1 to keep trailing empty strings
-          
+
           lines.each_with_index do |line, index|
             # Wrap long lines to prevent display issues
             wrapped_lines = wrap_long_line(line)
-            
+
             wrapped_lines.each do |wrapped_line|
               write_output_line(wrapped_line)
             end
@@ -200,40 +209,72 @@ module Clacky
         end
       end
 
-      # Update the last line in output area (for progress indicator)
-      # @param content [String] Content to update
-      def update_last_line(content)
+      # Update the last N lines in output area (for inline input updates)
+      # @param content [String] Content to update (may contain newlines for wrapped lines)
+      # @param old_line_count [Integer] Number of lines currently occupied (for clearing)
+      def update_last_line(content, old_line_count = 1)
         @render_mutex.synchronize do
           return if @output_row == 0  # No output yet
-          
-          # Last written line is at @output_row - 1
-          last_row = @output_row - 1
-          screen.move_cursor(last_row, 0)
-          screen.clear_line
-          print content
-          
-          # Hide terminal cursor to avoid showing two cursors
-          # InlineInput uses visual cursor (white background) which is better for multi-byte chars
-          screen.hide_cursor
+
+          # Calculate start row (last N lines)
+          start_row = @output_row - old_line_count
+          start_row = 0 if start_row < 0
+
+          # Clear all lines that will be updated
+          (start_row...@output_row).each do |row|
+            screen.move_cursor(row, 0)
+            screen.clear_line
+          end
+
+          # Re-render the content
+          lines = content.split("\n", -1)
+          current_row = start_row
+
+          lines.each_with_index do |line, idx|
+            screen.move_cursor(current_row, 0)
+            print line
+            current_row += 1
+          end
+
+          # Update output_row to new line count
+          @output_row = start_row + lines.length
+
+          # Clear any remaining old lines if new content has fewer lines
+          # This handles the case where content shrinks (e.g., delete from 2 lines to 1 line)
+          old_end_row = @output_row + (old_line_count - lines.length)
+          if old_end_row > @output_row && old_end_row <= start_row + old_line_count
+            # Clear the extra old lines
+            (@output_row...old_end_row).each do |row|
+              screen.move_cursor(row, 0)
+              screen.clear_line
+            end
+          end
+
+          # Re-render fixed areas to restore cursor position in input area
+          render_fixed_areas
           screen.flush
-          
-          # Don't re-render fixed areas - we're just updating existing content
         end
       end
 
-      # Remove the last line from output area
-      def remove_last_line
+      # Remove the last N lines from output area
+      # @param line_count [Integer] Number of lines to remove (default: 1)
+      def remove_last_line(line_count = 1)
         @render_mutex.synchronize do
           return if @output_row == 0  # No output to remove
-          
-          # Clear the last written line
-          last_row = @output_row - 1
-          screen.move_cursor(last_row, 0)
-          screen.clear_line
-          
-          # Move output row back
-          @output_row = last_row
-          
+
+          # Calculate start row for removal
+          start_row = @output_row - line_count
+          start_row = 0 if start_row < 0
+
+          # Clear all lines being removed
+          (start_row...@output_row).each do |row|
+            screen.move_cursor(row, 0)
+            screen.clear_line
+          end
+
+          # Update output_row
+          @output_row = start_row
+
           # Re-render fixed areas to ensure consistency
           render_fixed_areas
           screen.flush
@@ -416,11 +457,26 @@ module Clacky
         # The InlineInput is rendered inline with output
         return if input_area.paused?
 
+        current_fixed_height = fixed_area_height
         start_row = fixed_area_start_row
         gap_row = start_row
         todo_row = gap_row + 1
         input_row = todo_row + (@todo_area&.height || 0)
 
+        # If fixed area shrank, clear the extra lines at the top to remove residual content
+        if @last_fixed_area_height > current_fixed_height
+          height_diff = @last_fixed_area_height - current_fixed_height
+          old_start_row = screen.height - @last_fixed_area_height
+          # Clear the extra lines that are no longer part of fixed area
+          (old_start_row...(old_start_row + height_diff)).each do |row|
+            screen.move_cursor(row, 0)
+            screen.clear_line
+          end
+        end
+
+        # Update last height for next comparison
+        @last_fixed_area_height = current_fixed_height
+
         # Render gap line
         screen.move_cursor(gap_row, 0)
         screen.clear_line

data/lib/clacky/ui2/line_editor.rb

@@ -188,14 +188,154 @@ module Clacky
         # Strip ANSI codes from prompt to get actual display width
         visible_prompt = strip_ansi_codes(prompt)
         prompt_display_width = calculate_display_width(visible_prompt)
-        
+
         # Calculate display width of text before cursor
         chars = @line.chars
         text_before_cursor = chars[0...@cursor_position].join
         text_display_width = calculate_display_width(text_before_cursor)
-        
+
         prompt_display_width + text_display_width
       end
+
+      # Get cursor position considering line wrapping
+      # @param prompt [String] Prompt string before the line (may contain ANSI codes)
+      # @param width [Integer] Terminal width for wrapping
+      # @return [Array<Integer>] Row and column position (0-indexed)
+      def cursor_position_with_wrap(prompt = "", width = TTY::Screen.width)
+        return [0, cursor_column(prompt)] if width <= 0
+
+        prompt_width = calculate_display_width(strip_ansi_codes(prompt))
+        available_width = width - prompt_width
+
+        # Get wrapped segments for current line
+        wrapped_segments = wrap_line(@line, available_width)
+
+        # Find which segment contains cursor
+        cursor_segment_idx = 0
+        cursor_pos_in_segment = @cursor_position
+
+        wrapped_segments.each_with_index do |segment, idx|
+          if @cursor_position >= segment[:start] && @cursor_position < segment[:end]
+            cursor_segment_idx = idx
+            cursor_pos_in_segment = @cursor_position - segment[:start]
+            break
+          elsif @cursor_position >= segment[:end] && idx == wrapped_segments.size - 1
+            cursor_segment_idx = idx
+            cursor_pos_in_segment = segment[:end] - segment[:start]
+            break
+          end
+        end
+
+        # Calculate display width of text before cursor in this segment
+        chars = @line.chars
+        segment_start = wrapped_segments[cursor_segment_idx][:start]
+        text_in_segment_before_cursor = chars[segment_start...(segment_start + cursor_pos_in_segment)].join
+        display_width = calculate_display_width(text_in_segment_before_cursor)
+
+        col = prompt_width + display_width
+        row = cursor_segment_idx
+
+        [row, col]
+      end
+
+      # Wrap a line into multiple segments based on available width
+      # Considers display width of characters (multi-byte characters like Chinese)
+      # @param line [String] The line to wrap
+      # @param max_width [Integer] Maximum display width per wrapped line
+      # @return [Array<Hash>] Array of segment info: { text: String, start: Integer, end: Integer }
+      def wrap_line(line, max_width)
+        return [{ text: "", start: 0, end: 0 }] if line.empty?
+        return [{ text: line, start: 0, end: line.length }] if max_width <= 0
+
+        segments = []
+        chars = line.chars
+        segment_start = 0
+        current_width = 0
+        current_end = 0
+
+        chars.each_with_index do |char, idx|
+          char_width = char_display_width(char)
+
+          # If adding this character exceeds max width, complete current segment
+          if current_width + char_width > max_width && current_end > segment_start
+            segments << {
+              text: chars[segment_start...current_end].join,
+              start: segment_start,
+              end: current_end
+            }
+            segment_start = idx
+            current_end = idx + 1
+            current_width = char_width
+          else
+            current_end = idx + 1
+            current_width += char_width
+          end
+        end
+
+        # Add the last segment
+        if current_end > segment_start
+          segments << {
+            text: chars[segment_start...current_end].join,
+            start: segment_start,
+            end: current_end
+          }
+        end
+
+        segments.empty? ? [{ text: "", start: 0, end: 0 }] : segments
+      end
+
+      # Calculate display width of a single character
+      # @param char [String] Single character
+      # @return [Integer] Display width (1 or 2)
+      def char_display_width(char)
+        code = char.ord
+        # East Asian Wide and Fullwidth characters take 2 columns
+        if (code >= 0x1100 && code <= 0x115F) ||
+           (code >= 0x2329 && code <= 0x232A) ||
+           (code >= 0x2E80 && code <= 0x303E) ||
+           (code >= 0x3040 && code <= 0xA4CF) ||
+           (code >= 0xAC00 && code <= 0xD7A3) ||
+           (code >= 0xF900 && code <= 0xFAFF) ||
+           (code >= 0xFE10 && code <= 0xFE19) ||
+           (code >= 0xFE30 && code <= 0xFE6F) ||
+           (code >= 0xFF00 && code <= 0xFF60) ||
+           (code >= 0xFFE0 && code <= 0xFFE6) ||
+           (code >= 0x1F300 && code <= 0x1F9FF) ||
+           (code >= 0x20000 && code <= 0x2FFFD) ||
+           (code >= 0x30000 && code <= 0x3FFFD)
+          2
+        else
+          1
+        end
+      end
+
+      # Render a segment of a line with cursor if cursor is in this segment
+      # @param line [String] Full line text
+      # @param segment_start [Integer] Start position of segment in line (char index)
+      # @param segment_end [Integer] End position of segment in line (char index)
+      # @return [String] Rendered segment with cursor if applicable
+      def render_line_segment_with_cursor(line, segment_start, segment_end)
+        chars = line.chars
+        segment_chars = chars[segment_start...segment_end]
+
+        # Check if cursor is in this segment
+        if @cursor_position >= segment_start && @cursor_position < segment_end
+          # Cursor is in this segment
+          cursor_pos_in_segment = @cursor_position - segment_start
+          before_cursor = segment_chars[0...cursor_pos_in_segment].join
+          cursor_char = segment_chars[cursor_pos_in_segment] || " "
+          after_cursor = segment_chars[(cursor_pos_in_segment + 1)..-1]&.join || ""
+
+          "#{@pastel.white(before_cursor)}#{@pastel.on_white(@pastel.black(cursor_char))}#{@pastel.white(after_cursor)}"
+        elsif @cursor_position == segment_end && segment_end == line.length
+          # Cursor is at the very end of the line, show it in last segment
+          segment_text = segment_chars.join
+          "#{@pastel.white(segment_text)}#{@pastel.on_white(@pastel.black(' '))}"
+        else
+          # Cursor is not in this segment, just format normally
+          @pastel.white(segment_chars.join)
+        end
+      end
     end
   end
 end

data/lib/clacky/ui2/themes/hacker_theme.rb

@@ -32,7 +32,7 @@ module Clacky
           user: [:white, :white],
           assistant: [:bright_green, :white],
           tool_call: [:bright_cyan, :cyan],
-          tool_result: [:cyan, :white],
+          tool_result: [:bright_cyan, :cyan],
           tool_denied: [:bright_yellow, :yellow],
           tool_planned: [:bright_cyan, :cyan],
           tool_error: [:bright_red, :red],

data/lib/clacky/ui2/themes/minimal_theme.rb

@@ -29,7 +29,7 @@ module Clacky
           user: [:white, :white],
           assistant: [:green, :white],
           tool_call: [:cyan, :cyan],
-          tool_result: [:white, :white],
+          tool_result: [:cyan, :cyan],
           tool_denied: [:yellow, :yellow],
           tool_planned: [:cyan, :cyan],
           tool_error: [:red, :red],

data/lib/clacky/ui2/ui_controller.rb

@@ -147,6 +147,12 @@ module Clacky
         @mode_toggle_callback = block
       end
 
+      # Set skill loader for command suggestions
+      # @param skill_loader [Clacky::SkillLoader] The skill loader instance
+      def set_skill_loader(skill_loader)
+        @input_area.set_skill_loader(skill_loader)
+      end
+
       # Append output to the output area
       # @param content [String] Content to append
       def append_output(content)
@@ -214,7 +220,7 @@ module Clacky
 
         # Delta tokens with color coding (green/yellow/red + dim)
         delta_tokens = token_data[:delta_tokens]
-        delta_str = "+#{delta_tokens}"
+        delta_str = delta_tokens.negative? ? "#{delta_tokens}" : "+#{delta_tokens}"
         color_style = if delta_tokens > 10000
           :red
         elsif delta_tokens > 5000
@@ -222,7 +228,11 @@ module Clacky
         else
           :green
         end
-        colored_delta = pastel.decorate(delta_str, color_style, :dim)
+        colored_delta = if delta_tokens.negative?
+          pastel.cyan(delta_str)
+        else
+          pastel.decorate(delta_str, color_style, :dim)
+        end
         token_info << colored_delta
 
         # Cache status indicator (using theme)
@@ -342,10 +352,13 @@ module Clacky
 
         # Remove <think>...</think> blocks (multiline, case-insensitive)
         # Also handles variations like <thinking>...</thinking>
-        filtered = content.gsub(%r{<think(?:ing)?>\s*.*?\s*</think(?:ing)?>}mi, '')
+        filtered = content.gsub(%r{<think(?:ing)?>[\s\S]*?</think(?:ing)?>}mi, '')
 
-        # Clean up extra whitespace left behind
-        filtered.gsub(/\n{3,}/, "\n\n").strip
+        # Clean up multiple empty lines left behind (max 2 consecutive newlines)
+        filtered.gsub!(/\n{3,}/, "\n\n")
+
+        # Remove leading and trailing whitespace
+        filtered.strip
       end
 
       # Show tool call
@@ -380,7 +393,7 @@ module Clacky
       def show_complete(iterations:, cost:, duration: nil, cache_stats: nil)
         # Update status back to 'idle' when task is complete
         update_sessionbar(status: 'idle')
-        
+
         # Clear user tip when agent stops working
         @input_area.clear_user_tip
         @layout.render_input
@@ -439,10 +452,10 @@ module Clacky
       def clear_progress
         # Calculate elapsed time before stopping
         elapsed_time = @progress_start_time ? (Time.now - @progress_start_time).to_i : 0
-        
+
         # Stop the progress thread
         stop_progress_thread
-        
+
         # Update the final progress line to gray (stopped state)
         if @progress_message && elapsed_time > 0
           final_output = @renderer.render_progress("#{@progress_message}… (#{elapsed_time}s)")
@@ -544,7 +557,7 @@ module Clacky
 
         # Create InlineInput with styled prompt
         inline_input = Components::InlineInput.new(
-          prompt: "  Press Enter to approve, 'n' to reject, or provide feedback: ",
+          prompt: "Press Enter/y to approve(Shift+Tab for all), 'n' to reject, or type feedback: ",
           default: nil
         )
         @inline_input = inline_input
@@ -556,8 +569,9 @@ module Clacky
         # Collect input (blocks until user presses Enter)
         result_text = inline_input.collect
 
-        # Clean up - remove the inline input line (use layout to track position)
-        @layout.remove_last_line
+        # Clean up - remove the inline input lines (handle wrapped lines)
+        line_count = inline_input.line_count
+        @layout.remove_last_line(line_count)
 
         # Append the final response to output
         if result_text.nil?
@@ -594,41 +608,15 @@ module Clacky
         require 'diffy'
 
         diff = Diffy::Diff.new(old_content, new_content, context: 3)
-        all_lines = diff.to_s(:color).lines
-        plain_lines = diff.to_s.lines
-
-        # Add line numbers to diff output
-        old_line_num = 0
-        new_line_num = 0
-
-        numbered_lines = all_lines.each_with_index.map do |line, index|
-          # Use plain text to detect line type (remove ANSI codes)
-          plain_line = plain_lines[index]&.chomp || line.gsub(/\e\[[0-9;]*m/, '').chomp
-
-          # Remove trailing newline from colored line to avoid double newlines
-          colored_line = line.chomp
-
-          # Determine line type and number (use single line number for simplicity)
-          if plain_line.start_with?('+') || plain_line.start_with?('-') || plain_line.start_with?(' ')
-            new_line_num += 1
-            sprintf("%4d | %s", new_line_num, colored_line)
-          elsif plain_line.start_with?('@@')
-            # Diff header: extract line numbers from @@ -old_start,old_count +new_start,new_count @@
-            if plain_line =~ /@@ -(\d+)(?:,\d+)? (\d+)(?:,\d+)? @@/
-              new_line_num = $2.to_i - 1
-            end
-            sprintf("%4s | %s", "", colored_line)
-          else
-            # Other lines (headers, etc.)
-            sprintf("%4s | %s", "", colored_line)
-          end
-        end
+        diff_lines = diff.to_s(:color).lines
 
-        display_lines = numbered_lines.first(max_lines)
-        display_lines.each { |line| append_output(line) }
+        # Show diff without line numbers
+        diff_lines.take(max_lines).each do |line|
+          append_output(line.chomp)
+        end
 
-        if all_lines.size > max_lines
-          append_output("\n... (#{all_lines.size - max_lines} more lines, diff truncated)")
+        if diff_lines.size > max_lines
+          append_output("\n... (#{diff_lines.size - max_lines} more lines, diff truncated)")
         end
       rescue LoadError
         # Fallback if diffy is not available
@@ -788,16 +776,19 @@ module Clacky
 
       # Handle key input for InlineInput
       def handle_inline_input_key(key)
+        # Get old line count BEFORE modification
+        old_line_count = @inline_input.line_count
+
         result = @inline_input.handle_key(key)
 
         case result[:action]
         when :update
-          # Update the last line of output with current input (use layout to track position)
-          @layout.update_last_line(@inline_input.render)
+          # Update the output area with current input (considering wrapped lines)
+          @layout.update_last_line(@inline_input.render, old_line_count)
           # Position cursor for inline input
           @layout.position_inline_input_cursor(@inline_input)
         when :submit, :cancel
-          # InlineInput is done, will be cleaned up by request_confirmation
+          # InlineInput is done, will be cleaned up by request_confirmation after collect returns
           nil
         when :toggle_mode
           # Update mode and session bar info, but don't render yet

data/lib/clacky/utils/file_ignore_helper.rb

@@ -30,20 +30,18 @@ module Clacky
         /\.ini$/,
         /\.conf$/,
         /\.config$/,
-        /config\//,
-        /\.config\//
       ].freeze
 
       # Find .gitignore file in the search path or parent directories
       # Only searches within the search path and up to the current working directory
       def self.find_gitignore(path)
         search_path = File.directory?(path) ? path : File.dirname(path)
-        
+
         # Look for .gitignore in current and parent directories
         current = File.expand_path(search_path)
         cwd = File.expand_path(Dir.pwd)
         root = File.expand_path('/')
-        
+
         # Limit search: only go up to current working directory
         # This prevents finding .gitignore files from unrelated parent directories
         # when searching in temporary directories (like /tmp in tests)
@@ -52,16 +50,16 @@ module Clacky
                       else
                         current
                       end
-        
+
         loop do
           gitignore = File.join(current, '.gitignore')
           return gitignore if File.exist?(gitignore)
-          
+
           # Stop if we've reached the search limit or root
           break if current == search_limit || current == root
           current = File.dirname(current)
         end
-        
+
         nil
       end
 
@@ -71,10 +69,10 @@ module Clacky
         # Expand both paths to handle symlinks and relative paths correctly
         expanded_file = File.expand_path(file)
         expanded_base = File.expand_path(base_path)
-        
+
         # For files, use the directory as base
         expanded_base = File.dirname(expanded_base) if File.file?(expanded_base)
-        
+
         # Calculate relative path
         if expanded_file.start_with?(expanded_base)
           relative_path = expanded_file[(expanded_base.length + 1)..-1] || File.basename(expanded_file)
@@ -82,10 +80,10 @@ module Clacky
           # File is outside base path - use just the filename
           relative_path = File.basename(expanded_file)
         end
-        
+
         # Clean up relative path
         relative_path = relative_path.sub(/^\.\//, '') if relative_path
-        
+
         if gitignore
           # Use .gitignore rules
           gitignore.ignored?(relative_path)
@@ -96,7 +94,7 @@ module Clacky
               File.fnmatch(pattern, relative_path, File::FNM_PATHNAME | File::FNM_DOTMATCH)
             else
               # Match pattern as a path component (not substring of absolute path)
-              relative_path.start_with?("#{pattern}/") || 
+              relative_path.start_with?("#{pattern}/") ||
               relative_path.include?("/#{pattern}/") ||
               relative_path == pattern ||
               File.basename(relative_path) == pattern

data/lib/clacky/version.rb

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

data/lib/clacky.rb

@@ -3,6 +3,8 @@
 require_relative "clacky/version"
 require_relative "clacky/config"
 require_relative "clacky/client"
+require_relative "clacky/skill"
+require_relative "clacky/skill_loader"
 
 # Agent system
 require_relative "clacky/model_pricing"
@@ -35,6 +37,7 @@ require_relative "clacky/agent"
 require_relative "clacky/cli"
 
 module Clacky
-  class Error < StandardError; end
+  class AgentError < StandardError; end
   class AgentInterrupted < StandardError; end
+  class ToolCallError < AgentError; end  # Raised when tool call fails due to invalid parameters
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openclacky
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.6.4
 platform: ruby
 authors:
 - windy
@@ -159,6 +159,7 @@ files:
 - clacky-legacy/clacky.gemspec
 - clacky-legacy/clarky.gemspec
 - docs/ui2-architecture.md
+- docs/why-openclacky.md
 - homebrew/README.md
 - homebrew/openclacky.rb
 - lib/clacky.rb
@@ -167,11 +168,14 @@ files:
 - lib/clacky/cli.rb
 - lib/clacky/client.rb
 - lib/clacky/config.rb
+- lib/clacky/default_skills/skill-add/SKILL.md
 - lib/clacky/gitignore_parser.rb
 - lib/clacky/hook_manager.rb
 - lib/clacky/model_pricing.rb
 - lib/clacky/progress_indicator.rb
 - lib/clacky/session_manager.rb
+- lib/clacky/skill.rb
+- lib/clacky/skill_loader.rb
 - lib/clacky/thinking_verbs.rb
 - lib/clacky/tool_registry.rb
 - lib/clacky/tools/base.rb
@@ -191,6 +195,7 @@ files:
 - lib/clacky/ui2.rb
 - lib/clacky/ui2/README.md
 - lib/clacky/ui2/components/base_component.rb
+- lib/clacky/ui2/components/command_suggestions.rb
 - lib/clacky/ui2/components/common_component.rb
 - lib/clacky/ui2/components/inline_input.rb
 - lib/clacky/ui2/components/input_area.rb