openclacky 0.6.2 → 0.6.4

data/lib/clacky/tools/grep.rb

@@ -59,11 +59,6 @@ module Clacky
             description: "Maximum file size in bytes to search (default: 1MB)",
             default: MAX_FILE_SIZE
           },
-          max_files_to_search: {
-            type: "integer",
-            description: "Maximum number of files to search",
-            default: 500
-          }
         },
         required: %w[pattern]
       }
@@ -78,7 +73,7 @@ module Clacky
         max_matches_per_file: 50,
         max_total_matches: 200,
         max_file_size: MAX_FILE_SIZE,
-        max_files_to_search: 500
+        max_files_to_search: 10000
       )
         # Validate pattern
         if pattern.nil? || pattern.strip.empty?
@@ -135,7 +130,7 @@ module Clacky
             end
 
             # Skip if file should be ignored (unless it's a config file)
-            if Clacky::Utils::FileIgnoreHelper.should_ignore_file?(file, expanded_path, gitignore) && 
+            if Clacky::Utils::FileIgnoreHelper.should_ignore_file?(file, expanded_path, gitignore) &&
                !Clacky::Utils::FileIgnoreHelper.is_config_file?(file)
               skipped[:ignored] += 1
               next
@@ -217,12 +212,12 @@ module Clacky
           matches = result[:total_matches] || 0
           files = result[:files_with_matches] || 0
           msg = "[OK] Found #{matches} matches in #{files} files"
-          
+
           # Add truncation info if present
           if result[:truncated] && result[:truncation_reason]
             msg += " (truncated: #{result[:truncation_reason]})"
           end
-          
+
           msg
         end
       end
@@ -275,12 +270,12 @@ module Clacky
 
       def search_file(file, regex, context_lines, max_matches)
         matches = []
-        
+
         # Use File.foreach for memory-efficient line-by-line reading
         File.foreach(file, chomp: true).with_index do |line, index|
           # Stop if we have enough matches for this file
           break if matches.length >= max_matches
-          
+
           next unless line.match?(regex)
 
           # Truncate long lines
@@ -315,10 +310,10 @@ module Clacky
         (start_line..end_line).each do |i|
           line_content = lines[i]
           # Truncate long lines in context too
-          display_content = line_content.length > MAX_LINE_LENGTH ? 
-                          "#{line_content[0...MAX_LINE_LENGTH]}..." : 
+          display_content = line_content.length > MAX_LINE_LENGTH ?
+                          "#{line_content[0...MAX_LINE_LENGTH]}..." :
                           line_content
-          
+
           context << {
             line_number: i + 1,
             content: display_content,

data/lib/clacky/tools/safe_shell.rb

@@ -32,20 +32,26 @@ module Clacky
         required: ["command"]
       }
 
-      def execute(command:, timeout: nil, max_output_lines: 1000)
+      def execute(command:, timeout: nil, max_output_lines: 1000, skip_safety_check: false)
         # Get project root directory
         project_root = Dir.pwd
 
         begin
           # 1. Extract timeout from command if it starts with "timeout N"
           command, extracted_timeout = extract_timeout_from_command(command)
-          
+
           # Use extracted timeout if not explicitly provided
           timeout ||= extracted_timeout
 
-          # 2. Use safety replacer to process command
-          safety_replacer = CommandSafetyReplacer.new(project_root)
-          safe_command = safety_replacer.make_command_safe(command)
+          # 2. Use safety replacer to process command (skip if user already confirmed)
+          if skip_safety_check
+            # User has confirmed, execute command as-is (no safety modifications)
+            safe_command = command
+            safety_replacer = nil
+          else
+            safety_replacer = CommandSafetyReplacer.new(project_root)
+            safe_command = safety_replacer.make_command_safe(command)
+          end
 
           # 3. Calculate timeouts: soft_timeout is fixed at 5s, hard_timeout from timeout parameter
           soft_timeout = 5
@@ -55,7 +61,7 @@ module Clacky
           result = super(command: safe_command, soft_timeout: soft_timeout, hard_timeout: hard_timeout, max_output_lines: max_output_lines)
 
           # 5. Enhance result information
-          enhance_result(result, command, safe_command)
+          enhance_result(result, command, safe_command, safety_replacer)
 
         rescue SecurityError => e
           # Security error, return friendly error message
@@ -145,9 +151,9 @@ module Clacky
         end
       end
 
-      def enhance_result(result, original_command, safe_command)
+      def enhance_result(result, original_command, safe_command, safety_replacer = nil)
         # If command was replaced, add security information
-        if original_command != safe_command
+        if safety_replacer && original_command != safe_command
           result[:security_enhanced] = true
           result[:original_command] = original_command
           result[:safe_command] = safe_command

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