openclacky 0.6.2 → 0.6.3

data/lib/clacky/tools/shell.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "tmpdir"
 require_relative "base"
 
 module Clacky
@@ -35,7 +36,7 @@ module Clacky
       INTERACTION_PATTERNS = [
         [/\[Y\/n\]|\[y\/N\]|\(yes\/no\)|\(Y\/n\)|\(y\/N\)/i, 'confirmation'],
         [/[Pp]assword\s*:\s*$|Enter password|enter password/, 'password'],
-        [/^\s*>>>\s*$|^\s*>>?\s*$|^irb\(.*\):\d+:\d+[>*]\s*$|^>\s*$/, 'repl'],
+        [/^\s*>>>\s*$|^\s*>>?\s*$|^irb\(.*\):\d+:\d+[>*]\s*$|^\>\s*$/, 'repl'],
         [/^\s*:\s*$|\(END\)|--More--|Press .* to continue|lines \d+-\d+/, 'pager'],
         [/Are you sure|Continue\?|Proceed\?|Confirm|Overwrite/i, 'question'],
         [/Enter\s+\w+:|Input\s+\w+:|Please enter|please provide/i, 'input'],
@@ -143,7 +144,7 @@ module Clacky
 
             stdout_output = stdout_buffer.string
             stderr_output = stderr_buffer.string
-            
+
             {
               command: command,
               stdout: truncate_output(stdout_output, max_output_lines),
@@ -157,7 +158,7 @@ module Clacky
         rescue StandardError => e
           stdout_output = stdout_buffer.string
           stderr_output = "Error executing command: #{e.message}\n#{e.backtrace.first(3).join("\n")}"
-          
+
           {
             command: command,
             stdout: truncate_output(stdout_output, max_output_lines),
@@ -253,10 +254,10 @@ module Clacky
       # Truncate output to max_lines, adding a truncation notice if needed
       def truncate_output(output, max_lines)
         return output if output.nil? || output.empty?
-        
+
         lines = output.lines
         return output if lines.length <= max_lines
-        
+
         truncated_lines = lines.first(max_lines)
         truncation_notice = "\n\n... [Output truncated: showing #{max_lines} of #{lines.length} lines] ...\n"
         truncated_lines.join + truncation_notice
@@ -293,69 +294,105 @@ module Clacky
 
       # Format result for LLM consumption - limit output size to save tokens
       # Maximum characters to include in LLM output
-      MAX_LLM_OUTPUT_CHARS = 2000
-      
+      MAX_LLM_OUTPUT_CHARS = 1000
+
       def format_result_for_llm(result)
         # Return error info as-is if command failed or timed out
         return result if result[:error] || result[:state] == 'TIMEOUT' || result[:state] == 'WAITING_INPUT'
-        
+
         stdout = result[:stdout] || ""
         stderr = result[:stderr] || ""
         exit_code = result[:exit_code] || 0
-        
+
         # Build compact result with truncated output
         compact = {
           command: result[:command],
           exit_code: exit_code,
           success: result[:success]
         }
-        
-        # Add elapsed time if available
+
+        # Add elapsed time if available (keep original precision)
         compact[:elapsed] = result[:elapsed] if result[:elapsed]
-        
-        # Truncate stdout to save tokens
-        if stdout.empty?
-          compact[:stdout] = ""
-        else
-          stdout_lines = stdout.lines
-          stdout_line_count = stdout_lines.length
-          
-          if stdout.length <= MAX_LLM_OUTPUT_CHARS
-            compact[:stdout] = stdout
-          else
-            # Take first N lines that fit within the character limit
-            accumulated_chars = 0
-            lines_to_include = []
-            
-            stdout_lines.each do |line|
-              break if accumulated_chars + line.length > MAX_LLM_OUTPUT_CHARS
-              lines_to_include << line
-              accumulated_chars += line.length
-            end
-            
-            compact[:stdout] = lines_to_include.join
-            compact[:stdout] += "\n\n... [Output truncated for LLM: showing #{lines_to_include.length} of #{stdout_line_count} lines, #{accumulated_chars} of #{stdout.length} chars] ...\n"
-          end
+
+        # Extract command name for temp file naming
+        command_name = extract_command_name(result[:command])
+
+        # Process stdout: truncate and optionally save to temp file
+        stdout_info = truncate_and_save(stdout, MAX_LLM_OUTPUT_CHARS, "stdout", command_name)
+        compact[:stdout] = stdout_info[:content]
+        compact[:stdout_full] = stdout_info[:temp_file] if stdout_info[:temp_file]
+
+        # Process stderr: truncate and optionally save to temp file
+        stderr_info = truncate_and_save(stderr, MAX_LLM_OUTPUT_CHARS, "stderr", command_name)
+        compact[:stderr] = stderr_info[:content]
+        compact[:stderr_full] = stderr_info[:temp_file] if stderr_info[:temp_file]
+
+        # Add output_truncated flag if present
+        compact[:output_truncated] = true if result[:output_truncated]
+
+        compact
+      end
+
+      # Extract command name from full command for temp file naming
+      def extract_command_name(command)
+        first_word = command.strip.split(/\s+/).first
+        File.basename(first_word, ".*")
+      end
+
+      # Truncate output for LLM and optionally save full content to temp file
+      def truncate_and_save(output, max_chars, label, command_name)
+        return { content: "", temp_file: nil } if output.empty?
+
+        return { content: output, temp_file: nil } if output.length <= max_chars
+
+        # Sanitize command name for file name
+        safe_name = command_name.gsub(/[^\w\-.]/, "_")[0...50]
+
+        # Use Ruby tmpdir for safe temp file creation
+        temp_dir = Dir.mktmpdir
+        temp_file = File.join(temp_dir, "#{safe_name}_#{Time.now.strftime("%Y%m%d_%H%M%S")}.output")
+
+        # Write full output to temp file
+        File.write(temp_file, output)
+
+        # For LLM display: show first and last lines to preserve structure
+        lines = output.lines
+        return { content: output, temp_file: nil } if lines.length <= 2
+
+        # Reserve 60 chars for truncation notice
+        available_chars = max_chars - 60
+
+        # Take first few lines
+        first_part = []
+        accumulated = 0
+        lines.each do |line|
+          break if accumulated + line.length > available_chars / 2
+          first_part << line
+          accumulated += line.length
         end
-        
-        # Truncate stderr to save tokens (usually more important than stdout, so keep more)
-        if stderr.empty?
-          compact[:stderr] = ""
+
+        # Take last few lines
+        last_part = []
+        accumulated = 0
+        lines.reverse_each do |line|
+          break if accumulated + line.length > available_chars / 2
+          last_part.unshift(line)
+          accumulated += line.length
+        end
+
+        total_lines = lines.length
+
+        # Create notice message based on label
+        if label == "stderr"
+          notice = "... [Error output truncated for LLM: showing #{first_part.length} of #{total_lines} lines, full content: #{temp_file} (use grep to search)] ..."
         else
-          stderr_line_count = stderr.lines.length
-          
-          if stderr.length <= MAX_LLM_OUTPUT_CHARS
-            compact[:stderr] = stderr
-          else
-            compact[:stderr] = stderr[0...MAX_LLM_OUTPUT_CHARS]
-            compact[:stderr] += "\n\n... [Error output truncated for LLM: showing #{MAX_LLM_OUTPUT_CHARS} of #{stderr.length} chars, #{stderr_line_count} lines] ...\n"
-          end
+          notice = "... [Output truncated for LLM: showing #{first_part.length} of #{total_lines} lines, full content: #{temp_file} (use grep to search)] ..."
         end
-        
-        # Add output_truncated flag
-        compact[:output_truncated] = result[:output_truncated] if result[:output_truncated]
-        
-        compact
+
+        # Combine with compact notice
+        content = first_part.join + "\n#{notice}\n" + last_part.join
+
+        { content: content, temp_file: temp_file }
       end
     end
   end

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