openclacky 0.6.0 → 0.6.2

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

@@ -5,71 +5,43 @@ require "pastel"
 module Clacky
   module UI2
     module Themes
-      # BaseTheme defines the interface for all themes
-      # Subclasses should override SYMBOLS and color methods
+      # BaseTheme defines the abstract interface for all themes
+      # Subclasses MUST define SYMBOLS and COLORS constants
       class BaseTheme
-        SYMBOLS = {
-          user: "[>>]",
-          assistant: "[<<]",
-          tool_call: "[=>]",
-          tool_result: "[<=]",
-          tool_denied: "[!!]",
-          tool_planned: "[??]",
-          tool_error: "[XX]",
-          thinking: "[..]",
-          success: "[OK]",
-          error: "[ER]",
-          warning: "[!!]",
-          info: "[--]",
-          task: "[##]",
-          progress: "[>>]",
-          file: "[F]",
-          command: "[C]",
-          cached: "[*]"
-        }.freeze
-
-        # Color schemes for different elements
-        # Each returns [symbol_color, text_color]
-        COLORS = {
-          user: [:bright_blue, :blue],
-          assistant: [:bright_green, :white],
-          tool_call: [:bright_cyan, :cyan],
-          tool_result: [:cyan, :white],
-          tool_denied: [:bright_yellow, :yellow],
-          tool_planned: [:bright_blue, :blue],
-          tool_error: [:bright_red, :red],
-          thinking: [:dim, :dim],
-          success: [:bright_green, :green],
-          error: [:bright_red, :red],
-          warning: [:bright_yellow, :yellow],
-          info: [:bright_white, :white],
-          task: [:bright_yellow, :white],
-          progress: [:bright_cyan, :cyan],
-          file: [:cyan, :white],
-          command: [:cyan, :white],
-          cached: [:cyan, :cyan]
-        }.freeze
-
         def initialize
           @pastel = Pastel.new
+          validate_theme_definition!
         end
 
+        # Get all symbols defined by this theme
+        # @return [Hash] Symbol definitions
         def symbols
           self.class::SYMBOLS
         end
 
+        # Get all colors defined by this theme
+        # @return [Hash] Color definitions
         def colors
           self.class::COLORS
         end
 
+        # Get symbol for a specific key
+        # @param key [Symbol] Symbol key
+        # @return [String] Symbol string
         def symbol(key)
           symbols[key] || "[??]"
         end
 
+        # Get symbol color for a specific key
+        # @param key [Symbol] Color key
+        # @return [Symbol] Pastel color method name
         def symbol_color(key)
           colors.dig(key, 0) || :white
         end
 
+        # Get text color for a specific key
+        # @param key [Symbol] Color key
+        # @return [Symbol] Pastel color method name
         def text_color(key)
           colors.dig(key, 1) || :white
         end
@@ -89,9 +61,23 @@ module Clacky
           @pastel.public_send(text_color(key), text)
         end
 
-        # Theme name for display
+        # Theme name for display (subclasses should override)
+        # @return [String] Theme name
         def name
-          "base"
+          raise NotImplementedError, "Subclass must implement #name method"
+        end
+
+        private
+
+        # Validate that subclass has defined required constants
+        def validate_theme_definition!
+          unless self.class.const_defined?(:SYMBOLS)
+            raise NotImplementedError, "Theme #{self.class.name} must define SYMBOLS constant"
+          end
+
+          unless self.class.const_defined?(:COLORS)
+            raise NotImplementedError, "Theme #{self.class.name} must define COLORS constant"
+          end
         end
       end
     end

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

@@ -16,6 +16,7 @@ module Clacky
           tool_planned: "[??]",
           tool_error: "[XX]",
           thinking: "[..]",
+          working: "[..]",
           success: "[OK]",
           error: "[ER]",
           warning: "[!!]",
@@ -28,14 +29,15 @@ module Clacky
         }.freeze
 
         COLORS = {
-          user: [:bright_blue, :blue],
+          user: [:white, :white],
           assistant: [:bright_green, :white],
           tool_call: [:bright_cyan, :cyan],
           tool_result: [:cyan, :white],
           tool_denied: [:bright_yellow, :yellow],
-          tool_planned: [:bright_blue, :blue],
+          tool_planned: [:bright_cyan, :cyan],
           tool_error: [:bright_red, :red],
           thinking: [:dim, :dim],
+          working: [:bright_yellow, :yellow],
           success: [:bright_green, :green],
           error: [:bright_red, :red],
           warning: [:bright_yellow, :yellow],

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

@@ -16,6 +16,7 @@ module Clacky
           tool_planned: "?",
           tool_error: "x",
           thinking: ".",
+          working: ".",
           success: "+",
           error: "x",
           warning: "!",
@@ -25,14 +26,15 @@ module Clacky
         }.freeze
 
         COLORS = {
-          user: [:blue, :blue],
+          user: [:white, :white],
           assistant: [:green, :white],
           tool_call: [:cyan, :cyan],
           tool_result: [:white, :white],
           tool_denied: [:yellow, :yellow],
-          tool_planned: [:blue, :blue],
+          tool_planned: [:cyan, :cyan],
           tool_error: [:red, :red],
           thinking: [:dim, :dim],
+          working: [:bright_yellow, :yellow],
           success: [:green, :green],
           error: [:red, :red],
           warning: [:yellow, :yellow],

data/lib/clacky/ui2/ui_controller.rb

@@ -2,7 +2,6 @@
 
 require_relative "layout_manager"
 require_relative "view_renderer"
-require_relative "components/output_area"
 require_relative "components/input_area"
 require_relative "components/todo_area"
 require_relative "components/welcome_banner"
@@ -31,13 +30,11 @@ module Clacky
         }
 
         # Initialize layout components
-        @output_area = Components::OutputArea.new(height: 20) # Will be recalculated
         @input_area = Components::InputArea.new
         @todo_area = Components::TodoArea.new
         @welcome_banner = Components::WelcomeBanner.new
         @inline_input = nil  # Created when needed
         @layout = LayoutManager.new(
-          output_area: @output_area,
           input_area: @input_area,
           todo_area: @todo_area
         )
@@ -59,7 +56,8 @@ module Clacky
       end
 
       # Initialize screen and show banner (separate from input loop)
-      def initialize_and_show_banner
+      # @param recent_user_messages [Array<String>, nil] Recent user messages when loading session
+      def initialize_and_show_banner(recent_user_messages: nil)
         @running = true
 
         # Set session bar data before initializing screen
@@ -73,8 +71,12 @@ module Clacky
 
         @layout.initialize_screen
 
-        # Display welcome banner
-        display_welcome_banner
+        # Display welcome banner or session history
+        if recent_user_messages && !recent_user_messages.empty?
+          display_session_history(recent_user_messages)
+        else
+          display_welcome_banner
+        end
       end
 
       # Start input loop (separate from initialization)
@@ -206,19 +208,21 @@ module Clacky
       #   - cost: cost for this iteration
       def show_token_usage(token_data)
         theme = ThemeManager.current_theme
+        pastel = Pastel.new
 
         token_info = []
 
-        # Delta tokens with color coding
+        # Delta tokens with color coding (green/yellow/red + dim)
         delta_tokens = token_data[:delta_tokens]
         delta_str = "+#{delta_tokens}"
-        colored_delta = if delta_tokens > 10000
-          theme.format_text(delta_str, :error)
+        color_style = if delta_tokens > 10000
+          :red
         elsif delta_tokens > 5000
-          theme.format_text(delta_str, :warning)
+          :yellow
         else
-          theme.format_text(delta_str, :success)
+          :green
         end
+        colored_delta = pastel.decorate(delta_str, color_style, :dim)
         token_info << colored_delta
 
         # Cache status indicator (using theme)
@@ -226,31 +230,44 @@ module Clacky
         cache_read = token_data[:cache_read]
         cache_used = cache_read > 0 || cache_write > 0
         if cache_used
-          token_info << theme.format_symbol(:cached)
+          token_info << pastel.dim(theme.symbol(:cached))
         end
 
         # Input tokens (with cache breakdown if available)
         prompt_tokens = token_data[:prompt_tokens]
         if cache_write > 0 || cache_read > 0
           input_detail = "#{prompt_tokens} (cache: #{cache_read} read, #{cache_write} write)"
-          token_info << "Input: #{input_detail}"
+          token_info << pastel.dim("Input: #{input_detail}")
         else
-          token_info << "Input: #{prompt_tokens}"
+          token_info << pastel.dim("Input: #{prompt_tokens}")
         end
 
         # Output tokens
-        token_info << "Output: #{token_data[:completion_tokens]}"
+        token_info << pastel.dim("Output: #{token_data[:completion_tokens]}")
 
         # Total
-        token_info << "Total: #{token_data[:total_tokens]}"
+        token_info << pastel.dim("Total: #{token_data[:total_tokens]}")
 
-        # Cost for this iteration
+        # Cost for this iteration with color coding (red/yellow for high cost, dim for normal)
         if token_data[:cost]
-          token_info << "Cost: $#{token_data[:cost].round(6)}"
+          cost = token_data[:cost]
+          cost_value = "$#{cost.round(6)}"
+          if cost >= 0.1
+            # High cost - red warning
+            colored_cost = pastel.decorate(cost_value, :red, :dim)
+            token_info << pastel.dim("Cost: ") + colored_cost
+          elsif cost >= 0.05
+            # Medium cost - yellow warning
+            colored_cost = pastel.decorate(cost_value, :yellow, :dim)
+            token_info << pastel.dim("Cost: ") + colored_cost
+          else
+            # Low cost - normal gray
+            token_info << pastel.dim("Cost: #{cost_value}")
+          end
         end
 
-        # Display through output system
-        token_display = theme.format_text("    [Tokens] #{token_info.join(' | ')}", :thinking)
+        # Display through output system (already all dimmed, just add prefix)
+        token_display = pastel.dim("    [Tokens] ") + token_info.join(pastel.dim(' | '))
         append_output(token_display)
       end
 
@@ -308,10 +325,29 @@ module Clacky
       # Show assistant message
       # @param content [String] Message content
       def show_assistant_message(content)
-        output = @renderer.render_assistant_message(content)
+        # Filter out thinking tags from models like MiniMax M2.1 that use <think>...</think>
+        filtered_content = filter_thinking_tags(content)
+        return if filtered_content.nil? || filtered_content.strip.empty?
+
+        output = @renderer.render_assistant_message(filtered_content)
         append_output(output)
       end
 
+      # Filter out thinking tags from content
+      # Some models (e.g., MiniMax M2.1) wrap their reasoning in <think>...</think> tags
+      # @param content [String] Raw content from model
+      # @return [String] Content with thinking tags removed
+      def filter_thinking_tags(content)
+        return content if content.nil?
+
+        # Remove <think>...</think> blocks (multiline, case-insensitive)
+        # Also handles variations like <thinking>...</thinking>
+        filtered = content.gsub(%r{<think(?:ing)?>\s*.*?\s*</think(?:ing)?>}mi, '')
+
+        # Clean up extra whitespace left behind
+        filtered.gsub(/\n{3,}/, "\n\n").strip
+      end
+
       # Show tool call
       # @param name [String] Tool name
       # @param args [String, Hash] Tool arguments (JSON string or Hash)
@@ -344,6 +380,10 @@ 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
 
         # Only show completion message for complex tasks (>5 iterations)
         return if iterations <= 5
@@ -351,7 +391,7 @@ module Clacky
         cache_tokens = cache_stats&.dig(:cache_read_input_tokens)
         cache_requests = cache_stats&.dig(:total_requests)
         cache_hits = cache_stats&.dig(:cache_hit_requests)
-        
+
         output = @renderer.render_task_complete(
           iterations: iterations,
           cost: cost,
@@ -365,7 +405,8 @@ module Clacky
 
       # Show progress indicator with dynamic elapsed time
       # @param message [String] Progress message (optional, will use random thinking verb if nil)
-      def show_progress(message = nil)
+      # @param prefix_newline [Boolean] Whether to add a blank line before progress (default: true)
+      def show_progress(message = nil, prefix_newline: true)
         # Stop any existing progress thread
         stop_progress_thread
 
@@ -375,8 +416,9 @@ module Clacky
         @progress_message = message || Clacky::THINKING_VERBS.sample
         @progress_start_time = Time.now
 
-        # Show initial progress
-        output = @renderer.render_progress("#{@progress_message}… (ctrl+c to interrupt)")
+        # Show initial progress (yellow, active)
+        append_output("") if prefix_newline
+        output = @renderer.render_working("#{@progress_message}… (ctrl+c to interrupt)")
         append_output(output)
 
         # Start background thread to update elapsed time
@@ -386,7 +428,7 @@ module Clacky
             next unless @progress_start_time
 
             elapsed = (Time.now - @progress_start_time).to_i
-            update_progress_line(@renderer.render_progress("#{@progress_message}… (ctrl+c to interrupt · #{elapsed}s)"))
+            update_progress_line(@renderer.render_working("#{@progress_message}… (ctrl+c to interrupt · #{elapsed}s)"))
           end
         rescue => e
           # Silently handle thread errors
@@ -395,8 +437,19 @@ module Clacky
 
       # Clear progress indicator
       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
-        clear_progress_line
+        
+        # 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)")
+          update_progress_line(final_output)
+        else
+          clear_progress_line
+        end
       end
 
       # Stop the progress update thread
@@ -410,8 +463,9 @@ module Clacky
 
       # Show info message
       # @param message [String] Info message
-      def show_info(message)
-        output = @renderer.render_system_message(message)
+      # @param prefix_newline [Boolean] Whether to add newline before message (default: true)
+      def show_info(message, prefix_newline: true)
+        output = @renderer.render_system_message(message, prefix_newline: prefix_newline)
         append_output(output)
       end
 
@@ -432,11 +486,17 @@ module Clacky
       # Set workspace status to idle (called when agent stops working)
       def set_idle_status
         update_sessionbar(status: 'idle')
+        # Clear user tip when agent stops working
+        @input_area.clear_user_tip
+        @layout.render_input
       end
 
       # Set workspace status to working (called when agent starts working)
       def set_working_status
         update_sessionbar(status: 'working')
+        # Show a random user tip with 40% probability when agent starts working
+        @input_area.show_user_tip(probability: 0.4)
+        @layout.render_input
       end
 
       # Show help text
@@ -484,7 +544,7 @@ module Clacky
 
         # Create InlineInput with styled prompt
         inline_input = Components::InlineInput.new(
-          prompt: theme.format_text("  (y/n, or provide feedback): ", :thinking),
+          prompt: "  Press Enter to approve, 'n' to reject, or provide feedback: ",
           default: nil
         )
         @inline_input = inline_input
@@ -535,9 +595,38 @@ module Clacky
 
         diff = Diffy::Diff.new(old_content, new_content, context: 3)
         all_lines = diff.to_s(:color).lines
-        display_lines = all_lines.first(max_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
+
+        display_lines = numbered_lines.first(max_lines)
+        display_lines.each { |line| append_output(line) }
 
-        display_lines.each { |line| append_output(line.chomp) }
         if all_lines.size > max_lines
           append_output("\n... (#{all_lines.size - max_lines} more lines, diff truncated)")
         end
@@ -599,6 +688,35 @@ module Clacky
         append_output(content)
       end
 
+      # Display recent user messages when loading session
+      # @param user_messages [Array<String>] Array of recent user message texts
+      def display_session_history(user_messages)
+        theme = ThemeManager.current_theme
+
+        # Show logo banner only
+        append_output(@welcome_banner.render_logo)
+
+        # Show simple header
+        append_output(theme.format_text("Recent conversation:", :info))
+
+        # Display each user message with numbering
+        user_messages.each_with_index do |msg, index|
+          # Truncate long messages
+          display_msg = if msg.length > 140
+            "#{msg[0..137]}..."
+          else
+            msg
+          end
+
+          # Show with number and indentation
+          append_output("  #{index + 1}. #{display_msg}")
+        end
+
+        # Bottom spacing and continuation prompt
+        append_output("")
+        append_output(theme.format_text("Session restored. Feel free to continue with your next task.", :success))
+      end
+
       # Main input loop
       def input_loop
         @layout.screen.enable_raw_mode

data/lib/clacky/ui2/view_renderer.rb

@@ -3,6 +3,7 @@
 require_relative "components/message_component"
 require_relative "components/tool_component"
 require_relative "components/common_component"
+require_relative "markdown_renderer"
 
 module Clacky
   module UI2
@@ -31,9 +32,16 @@ module Clacky
       # @param timestamp [Time, nil] Optional timestamp
       # @return [String] Rendered message
       def render_assistant_message(content, timestamp: nil)
+        # Render markdown if content contains markdown syntax
+        rendered_content = if MarkdownRenderer.markdown?(content)
+          MarkdownRenderer.render(content)
+        else
+          content
+        end
+
         @message_component.render(
           role: "assistant",
-          content: content,
+          content: rendered_content,
           timestamp: timestamp
         )
       end
@@ -41,12 +49,14 @@ module Clacky
       # Render a system message
       # @param content [String] Message content
       # @param timestamp [Time, nil] Optional timestamp
+      # @param prefix_newline [Boolean] Whether to add newline before message
       # @return [String] Rendered message
-      def render_system_message(content, timestamp: nil)
+      def render_system_message(content, timestamp: nil, prefix_newline: true)
         @message_component.render(
           role: "system",
           content: content,
-          timestamp: timestamp
+          timestamp: timestamp,
+          prefix_newline: prefix_newline
         )
       end
 
@@ -108,13 +118,20 @@ module Clacky
         @common_component.render_thinking
       end
 
-      # Render progress message
+      # Render progress message (stopped state, gray)
       # @param message [String] Progress message
       # @return [String] Progress indicator
       def render_progress(message)
         @common_component.render_progress(message)
       end
 
+      # Render working message (active state, yellow)
+      # @param message [String] Progress message
+      # @return [String] Working indicator
+      def render_working(message)
+        @common_component.render_working(message)
+      end
+
       # Render success message
       # @param message [String] Success message
       # @return [String] Success message

data/lib/clacky/ui2.rb

@@ -10,7 +10,6 @@ require_relative "ui2/view_renderer"
 require_relative "ui2/ui_controller"
 
 require_relative "ui2/components/base_component"
-require_relative "ui2/components/output_area"
 require_relative "ui2/components/input_area"
 require_relative "ui2/components/message_component"
 require_relative "ui2/components/tool_component"

data/lib/clacky/utils/arguments_parser.rb

@@ -44,10 +44,11 @@ module Clacky
         result
       end
 
-      # Validate required parameters
+      # Validate required parameters and filter unknown parameters
       def self.validate_required_params(call, args, tool_registry)
         tool = tool_registry.get(call[:name])
         required = tool.parameters&.dig(:required) || []
+        properties = tool.parameters&.dig(:properties) || {}
 
         missing = required.reject { |param|
           args.key?(param.to_sym) || args.key?(param.to_s)
@@ -57,7 +58,11 @@ module Clacky
           raise MissingRequiredParamsError.new(call[:name], missing, args.keys)
         end
 
-        args
+        # Filter out unknown parameters to prevent errors when LLM sends extra arguments
+        known_params = properties.keys.map(&:to_sym) + properties.keys.map(&:to_s)
+        filtered_args = args.select { |key, _| known_params.include?(key) }
+
+        filtered_args
       end
 
       # Generate error message with tool definition