openclacky 0.6.1 → 0.6.3

data/lib/clacky/tools/web_fetch.rb

@@ -2,6 +2,8 @@
 
 require "net/http"
 require "uri"
+require "tmpdir"
+require "fileutils"
 
 module Clacky
   module Tools
@@ -18,14 +20,14 @@ module Clacky
           },
           max_length: {
             type: "integer",
-            description: "Maximum content length to return in characters (default: 50000)",
-            default: 50000
+            description: "Maximum content length to return in characters (default: 3000)",
+            default: 3000
           }
         },
         required: %w[url]
       }
 
-      def execute(url:, max_length: 50000)
+      def execute(url:, max_length: 3000)
         # Validate URL
         begin
           uri = URI.parse(url)
@@ -46,7 +48,7 @@ module Clacky
 
           # Parse HTML if it's an HTML page
           if content_type.include?("text/html")
-            result = parse_html(content, max_length)
+            result = parse_html(content, max_length, url)
             result[:url] = url
             result[:content_type] = content_type
             result[:status_code] = response.code.to_i
@@ -54,21 +56,45 @@ module Clacky
             result
           else
             # For non-HTML content, return raw text
-            truncated_content = content[0, max_length]
-            {
-              url: url,
-              content_type: content_type,
-              status_code: response.code.to_i,
-              content: truncated_content,
-              truncated: content.length > max_length,
-              error: nil
-            }
+            result = handle_raw_content(content, max_length, url, content_type, response.code.to_i)
+            result
           end
         rescue StandardError => e
           { error: "Failed to fetch URL: #{e.message}" }
         end
       end
 
+      def handle_raw_content(content, max_length, url, content_type, status_code)
+        truncated = content.length > max_length
+        temp_file = nil
+
+        if truncated
+          temp_dir = Dir.mktmpdir
+          domain = extract_domain(url)
+          safe_name = domain.gsub(/[^\w\-.]/, '_')[0...50]
+          timestamp = Time.now.strftime("%Y%m%d_%H%M%S")
+          temp_file = File.join(temp_dir, "#{safe_name}_#{timestamp}.txt")
+          File.write(temp_file, content)
+        end
+
+        {
+          url: url,
+          content_type: content_type,
+          status_code: status_code,
+          content: content[0, max_length],
+          truncated: truncated,
+          temp_file: temp_file,
+          error: nil
+        }
+      end
+
+      def extract_domain(url)
+        uri = URI.parse(url)
+        uri.host || url.gsub(/[^\w\-.]/, '_')
+      rescue
+        url.gsub(/[^\w\-.]/, '_')
+      end
+
       def fetch_url(uri)
         # Follow redirects (max 5)
         redirects = 0
@@ -97,7 +123,7 @@ module Clacky
         end
       end
 
-      def parse_html(html, max_length)
+      def parse_html(html, max_length, url = nil)
         # Extract title
         title = ""
         if html =~ %r{<title[^>]*>(.*?)</title>}mi
@@ -122,15 +148,25 @@ module Clacky
         # Clean up whitespace
         text = text.gsub(/\s+/, " ").strip
 
-        # Truncate if needed
+        # Check if we need to save to temp file
         truncated = text.length > max_length
-        text = text[0, max_length] if truncated
+        temp_file = nil
+
+        if truncated
+          temp_dir = Dir.mktmpdir
+          domain = url ? extract_domain(url) : "web_fetch"
+          safe_name = domain.gsub(/[^\w\-.]/, '_')[0...50]
+          timestamp = Time.now.strftime("%Y%m%d_%H%M%S")
+          temp_file = File.join(temp_dir, "#{safe_name}_#{timestamp}.txt")
+          File.write(temp_file, text)
+        end
 
         {
           title: title,
           description: description,
-          content: text,
-          truncated: truncated
+          content: text[0, max_length],
+          truncated: truncated,
+          temp_file: temp_file
         }
       end
 
@@ -156,6 +192,33 @@ module Clacky
           "[OK] Fetched: #{display_title}"
         end
       end
+
+      # Format result for LLM consumption - return compact version to save tokens
+      def format_result_for_llm(result)
+        # Return error as-is
+        return result if result[:error]
+
+        # Build compact result
+        compact = {
+          url: result[:url],
+          title: result[:title],
+          description: result[:description],
+          status_code: result[:status_code]
+        }
+
+        # Add truncated notice and temp file info if content was truncated
+        if result[:truncated] && result[:temp_file]
+          compact[:content] = result[:content]
+          compact[:truncated] = true
+          compact[:temp_file] = result[:temp_file]
+          compact[:message] = "[Content truncated - full content saved to temp file. Use file_reader to read it if needed.]"
+        else
+          compact[:content] = result[:content]
+          compact[:truncated] = result[:truncated] || false
+        end
+
+        compact
+      end
     end
   end
 end

data/lib/clacky/ui2/components/command_suggestions.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+require "pastel"
+require_relative "../theme_manager"
+
+module Clacky
+  module UI2
+    module Components
+      # CommandSuggestions displays a dropdown menu of available commands
+      # Supports keyboard navigation and filtering
+      class CommandSuggestions
+        attr_reader :selected_index, :visible
+
+        # System commands available by default
+        SYSTEM_COMMANDS = [
+          { command: "/clear", description: "Clear chat history and restart session" },
+          { command: "/help", description: "Show help information" },
+          { command: "/exit", description: "Exit the chat session" },
+          { command: "/quit", description: "Quit the application" }
+        ].freeze
+
+        def initialize
+          @pastel = Pastel.new
+          @commands = []
+          @filtered_commands = []
+          @selected_index = 0
+          @visible = false
+          @filter_text = ""
+          @skill_commands = []
+          
+          # Initialize with system commands
+          update_commands
+        end
+
+        # Get current theme from ThemeManager
+        def theme
+          UI2::ThemeManager.current_theme
+        end
+
+        # Load skill commands from skill loader
+        # @param skill_loader [Clacky::SkillLoader] The skill loader instance
+        def load_skill_commands(skill_loader)
+          return unless skill_loader
+
+          @skill_commands = skill_loader.user_invocable_skills.map do |skill|
+            {
+              command: skill.slash_command,
+              description: skill.description || "No description available",
+              type: :skill
+            }
+          end
+
+          update_commands
+        end
+
+        # Show the suggestions dropdown
+        # @param filter_text [String] Initial filter text (everything after the /)
+        def show(filter_text = "")
+          @filter_text = filter_text
+          @visible = true
+          update_filtered_commands
+          @selected_index = 0
+        end
+
+        # Hide the suggestions dropdown
+        def hide
+          @visible = false
+          @filter_text = ""
+          @filtered_commands = []
+          @selected_index = 0
+        end
+
+        # Update filter text and refresh filtered commands
+        # @param text [String] Filter text (everything after the /)
+        def update_filter(text)
+          @filter_text = text
+          update_filtered_commands
+          @selected_index = 0  # Reset selection when filter changes
+        end
+
+        # Move selection up
+        def select_previous
+          return if @filtered_commands.empty?
+          @selected_index = (@selected_index - 1) % @filtered_commands.size
+        end
+
+        # Move selection down
+        def select_next
+          return if @filtered_commands.empty?
+          @selected_index = (@selected_index + 1) % @filtered_commands.size
+        end
+
+        # Get the currently selected command
+        # @return [Hash, nil] Selected command hash or nil if none selected
+        def selected_command
+          return nil if @filtered_commands.empty?
+          @filtered_commands[@selected_index]
+        end
+
+        # Get the currently selected command text
+        # @return [String, nil] Selected command text or nil if none selected
+        def selected_command_text
+          cmd = selected_command
+          cmd ? cmd[:command] : nil
+        end
+
+        # Check if there are any suggestions to show
+        # @return [Boolean]
+        def has_suggestions?
+          @visible && !@filtered_commands.empty?
+        end
+
+        # Calculate required height for rendering
+        # @return [Integer] Number of lines needed
+        def required_height
+          return 0 unless @visible
+          return 0 if @filtered_commands.empty?
+
+          # Header + commands + footer
+          1 + [@filtered_commands.size, 5].min + 1  # Max 5 visible items
+        end
+
+        # Render the suggestions dropdown
+        # @param row [Integer] Starting row position
+        # @param col [Integer] Starting column position
+        # @param width [Integer] Maximum width for the dropdown
+        # @return [String] Rendered output
+        def render(row:, col:, width: 60)
+          return "" unless @visible
+          return "" if @filtered_commands.empty?
+
+          output = []
+          max_items = 5  # Maximum visible items
+          visible_commands = @filtered_commands.take(max_items)
+
+          # Header
+          header = @pastel.dim("┌─ Commands ") + @pastel.dim("─" * (width - 13)) + @pastel.dim("┐")
+          output << position_cursor(row, col) + header
+
+          # Items
+          visible_commands.each_with_index do |cmd, idx|
+            is_selected = (idx == @selected_index)
+            line = render_command_item(cmd, is_selected, width)
+            output << position_cursor(row + 1 + idx, col) + line
+          end
+
+          # Footer with navigation hint
+          footer_row = row + 1 + visible_commands.size
+          total = @filtered_commands.size
+          hint = total > max_items ? " (#{total - max_items} more...)" : ""
+          footer = @pastel.dim("└") + @pastel.dim("─" * (width - 2)) + @pastel.dim("┘")
+          output << position_cursor(footer_row, col) + footer
+
+          output.join
+        end
+
+        # Clear the rendered dropdown from screen
+        # @param row [Integer] Starting row position
+        # @param col [Integer] Starting column position
+        def clear_from_screen(row:, col:)
+          return unless @visible
+
+          height = required_height
+          output = []
+          
+          height.times do |i|
+            output << position_cursor(row + i, col) + clear_line
+          end
+          
+          print output.join
+          flush
+        end
+
+        private
+
+        # Update the complete commands list (system + skills)
+        private def update_commands
+          system_cmds = SYSTEM_COMMANDS.map { |c| c.merge(type: :system) }
+          @commands = system_cmds + @skill_commands
+          update_filtered_commands if @visible
+        end
+
+        # Update filtered commands based on current filter text
+        private def update_filtered_commands
+          if @filter_text.empty?
+            @filtered_commands = @commands
+          else
+            filter_lower = @filter_text.downcase
+            @filtered_commands = @commands.select do |cmd|
+              # Remove leading / for comparison
+              cmd_name = cmd[:command].sub(/^\//, "")
+              cmd_name.downcase.start_with?(filter_lower) ||
+                cmd[:description].downcase.include?(filter_lower)
+            end
+          end
+        end
+
+        # Render a single command item
+        # @param cmd [Hash] Command hash with :command and :description
+        # @param selected [Boolean] Whether this item is selected
+        # @param width [Integer] Maximum width
+        # @return [String] Rendered item
+        private def render_command_item(cmd, selected, width)
+          # Calculate available space
+          available = width - 4  # Account for borders and padding
+
+          # Format command (e.g., "/clear")
+          command_text = cmd[:command]
+          
+          # Format description
+          max_desc_length = available - command_text.length - 3  # 3 for spacing
+          description = truncate_text(cmd[:description], max_desc_length)
+
+          # Build line
+          if selected
+            # Highlighted selection
+            line = @pastel.on_blue(@pastel.white(" #{command_text} "))
+            line += @pastel.on_blue(@pastel.dim(" #{description}"))
+            # Pad to full width
+            content_length = command_text.length + description.length + 2
+            padding = " " * [available - content_length, 0].max
+            line += @pastel.on_blue(padding)
+            @pastel.dim("│") + line + @pastel.dim("│")
+          else
+            # Normal item
+            line = " #{@pastel.cyan(command_text)} #{@pastel.dim(description)}"
+            # Pad to full width
+            content_length = strip_ansi(line).length
+            padding = " " * [available - content_length, 0].max
+            @pastel.dim("│") + line + padding + @pastel.dim("│")
+          end
+        end
+
+        # Truncate text to maximum length
+        # @param text [String] Text to truncate
+        # @param max_length [Integer] Maximum length
+        # @return [String] Truncated text
+        private def truncate_text(text, max_length)
+          return "" if max_length <= 3
+          return text if text.length <= max_length
+
+          text[0...(max_length - 3)] + "..."
+        end
+
+        # Strip ANSI codes from text
+        # @param text [String] Text with ANSI codes
+        # @return [String] Plain text
+        private def strip_ansi(text)
+          text.gsub(/\e\[[0-9;]*m/, '')
+        end
+
+        # Position cursor at specific row and column
+        # @param row [Integer] Row position (0-indexed)
+        # @param col [Integer] Column position (0-indexed)
+        # @return [String] ANSI escape sequence
+        private def position_cursor(row, col)
+          "\e[#{row + 1};#{col + 1}H"
+        end
+
+        # Clear current line
+        # @return [String] ANSI escape sequence
+        private def clear_line
+          "\e[2K"
+        end
+
+        # Flush output to terminal
+        private def flush
+          $stdout.flush
+        end
+      end
+    end
+  end
+end

data/lib/clacky/ui2/components/inline_input.rb

@@ -109,24 +109,31 @@ module Clacky
         # Render inline input with prompt and cursor
         # @return [String] Rendered line (may wrap to multiple lines)
         def render
-          line = render_line_with_cursor
-          full_text = "#{@prompt}#{line}"
-          
-          # Calculate terminal width and check if wrapping is needed
           width = TTY::Screen.width
-          visible_text = strip_ansi_codes(full_text)
-          display_width = calculate_display_width(visible_text)
-          
-          # If no wrapping needed, return as is
-          return full_text if display_width <= width
-          
-          # Otherwise, wrap the input (prompt on first line, continuation indented)
           prompt_width = calculate_display_width(strip_ansi_codes(@prompt))
           available_width = width - prompt_width
-          
-          # For simplicity, just return full text and let terminal handle wrapping
-          # InlineInput is typically short, so natural wrapping should be fine
-          full_text
+
+          # Get wrapped segments
+          wrapped_segments = wrap_line(@line, available_width)
+
+          # Build rendered output with cursor
+          output = ""
+
+          wrapped_segments.each_with_index do |segment, idx|
+            prefix = if idx == 0
+              @prompt
+            else
+              "> "  # Continuation prompt indicator
+            end
+
+            # Render segment with cursor if needed
+            segment_text = render_line_segment_with_cursor(@line, segment[:start], segment[:end])
+
+            output += "#{prefix}#{segment_text}"
+            output += "\n" unless idx == wrapped_segments.size - 1
+          end
+
+          output
         end
 
         # Get cursor column position
@@ -135,6 +142,18 @@ module Clacky
           cursor_column(@prompt)
         end
 
+        # Get the number of lines this input will occupy when rendered
+        # @param width [Integer] Terminal width
+        # @return [Integer] Number of lines
+        def line_count(width = TTY::Screen.width)
+          prompt_width = calculate_display_width(strip_ansi_codes(@prompt))
+          available_width = width - prompt_width
+          return 1 if available_width <= 0
+
+          segments = wrap_line(@line, available_width)
+          segments.size
+        end
+
         # Deactivate inline input
         def deactivate
           @active = false