openclacky 0.5.5 → 0.6.0

data/lib/clacky/tools/grep.rb

@@ -3,36 +3,6 @@
 module Clacky
   module Tools
     class Grep < Base
-      # Default patterns to ignore when .gitignore is not available
-      DEFAULT_IGNORED_PATTERNS = [
-        'node_modules',
-        'vendor/bundle',
-        '.git',
-        '.svn',
-        'tmp',
-        'log',
-        'coverage',
-        'dist',
-        'build',
-        '.bundle',
-        '.sass-cache',
-        '.DS_Store',
-        '*.log'
-      ].freeze
-
-      # Config file patterns that should always be searchable
-      CONFIG_FILE_PATTERNS = [
-        /\.env/,
-        /\.ya?ml$/,
-        /\.json$/,
-        /\.toml$/,
-        /\.ini$/,
-        /\.conf$/,
-        /\.config$/,
-        /config\//,
-        /\.config\//
-      ].freeze
-
       # Maximum file size to search (1MB)
       MAX_FILE_SIZE = 1_048_576
 
@@ -135,7 +105,7 @@ module Clacky
           regex = Regexp.new(pattern, regex_options)
 
           # Initialize gitignore parser
-          gitignore_path = find_gitignore(expanded_path)
+          gitignore_path = Clacky::Utils::FileIgnoreHelper.find_gitignore(expanded_path)
           gitignore = gitignore_path ? Clacky::GitignoreParser.new(gitignore_path) : nil
 
           results = []
@@ -165,13 +135,14 @@ module Clacky
             end
 
             # Skip if file should be ignored (unless it's a config file)
-            if should_ignore_file?(file, expanded_path, gitignore) && !is_config_file?(file)
+            if Clacky::Utils::FileIgnoreHelper.should_ignore_file?(file, expanded_path, gitignore) && 
+               !Clacky::Utils::FileIgnoreHelper.is_config_file?(file)
               skipped[:ignored] += 1
               next
             end
 
             # Skip binary files
-            if binary_file?(file)
+            if Clacky::Utils::FileIgnoreHelper.binary_file?(file)
               skipped[:binary] += 1
               next
             end
@@ -256,84 +227,52 @@ module Clacky
         end
       end
 
-      private
-
-      # Find .gitignore file in the search path or parent directories
-      # Only searches within the search path and up to the current working directory
-      def 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)
-        search_limit = if current.start_with?(cwd)
-                        cwd
-                      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
+      # Format result for LLM consumption - return a compact version to save tokens
+      def format_result_for_llm(result)
+        # If there's an error, return it as-is
+        return result if result[:error]
+
+        # Build a compact summary with file list and sample matches
+        compact = {
+          summary: {
+            total_matches: result[:total_matches],
+            files_with_matches: result[:files_with_matches],
+            files_searched: result[:files_searched],
+            truncated: result[:truncated],
+            truncation_reason: result[:truncation_reason]
+          }
+        }
+
+        # Include list of files with match counts
+        if result[:results] && !result[:results].empty?
+          compact[:files] = result[:results].map do |file_result|
+            {
+              file: file_result[:file],
+              match_count: file_result[:matches].length
+            }
+          end
 
-      # Check if file should be ignored based on .gitignore or default patterns
-      def should_ignore_file?(file, base_path, gitignore)
-        # Always calculate path relative to base_path for consistency
-        # 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)
-        else
-          # 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)
-        else
-          # Use default ignore patterns - only match against relative path components
-          DEFAULT_IGNORED_PATTERNS.any? do |pattern|
-            if pattern.include?('*')
-              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.include?("/#{pattern}/") ||
-              relative_path == pattern ||
-              File.basename(relative_path) == pattern
-            end
+          # Include sample matches (first 2 matches from first 3 files) for context
+          sample_results = result[:results].take(3)
+          compact[:sample_matches] = sample_results.map do |file_result|
+            {
+              file: file_result[:file],
+              matches: file_result[:matches].take(2).map do |match|
+                {
+                  line_number: match[:line_number],
+                  line: match[:line]
+                  # Omit context to save space - it's rarely needed by LLM
+                }
+              end
+            }
           end
         end
-      end
 
-      # Check if file is a config file (should not be ignored even if in .gitignore)
-      def is_config_file?(file)
-        CONFIG_FILE_PATTERNS.any? { |pattern| file.match?(pattern) }
+        compact
       end
 
+      private
+
       def search_file(file, regex, context_lines, max_matches)
         matches = []
         
@@ -391,17 +330,6 @@ module Clacky
       rescue StandardError
         nil
       end
-
-      def binary_file?(file)
-        # Simple heuristic: check if file contains null bytes in first 8KB
-        return false unless File.exist?(file)
-        return false if File.size(file).zero?
-
-        sample = File.read(file, 8192, encoding: "ASCII-8BIT")
-        sample.include?("\x00")
-      rescue StandardError
-        true
-      end
     end
   end
 end

data/lib/clacky/tools/run_project.rb

@@ -255,6 +255,11 @@ module Clacky
                 ready[0].each do |io|
                   begin
                     data = io.read_nonblock(4096)
+                    # Force UTF-8 encoding to avoid incompatible encoding errors
+                    data.force_encoding('UTF-8')
+                    # Replace invalid UTF-8 sequences with replacement character
+                    data = data.scrub('?') unless data.valid_encoding?
+                    
                     if io == stdout
                       stdout_buf.push_lines(data)
                     else

data/lib/clacky/tools/safe_shell.rb

@@ -19,13 +19,9 @@ module Clacky
             type: "string",
             description: "Shell command to execute"
           },
-          soft_timeout: {
+          timeout: {
             type: "integer",
-            description: "Soft timeout in seconds (for interaction detection)"
-          },
-          hard_timeout: {
-            type: "integer",
-            description: "Hard timeout in seconds (force kill)"
+            description: "Command timeout in seconds (auto-detected if not specified: 60s for normal commands, 180s for build/install commands)"
           },
           max_output_lines: {
             type: "integer",
@@ -36,19 +32,29 @@ module Clacky
         required: ["command"]
       }
 
-      def execute(command:, soft_timeout: nil, hard_timeout: nil, max_output_lines: 1000)
+      def execute(command:, timeout: nil, max_output_lines: 1000)
         # Get project root directory
         project_root = Dir.pwd
 
         begin
-          # 1. Use safety replacer to process command
+          # 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. Call parent class execution method
+          # 3. Calculate timeouts: soft_timeout is fixed at 5s, hard_timeout from timeout parameter
+          soft_timeout = 5
+          hard_timeout = calculate_hard_timeout(command, timeout)
+
+          # 4. Call parent class execution method
           result = super(command: safe_command, soft_timeout: soft_timeout, hard_timeout: hard_timeout, max_output_lines: max_output_lines)
 
-          # 3. Enhance result information
+          # 5. Enhance result information
           enhance_result(result, command, safe_command)
 
         rescue SecurityError => e
@@ -64,6 +70,30 @@ module Clacky
         end
       end
 
+      private def extract_timeout_from_command(command)
+        # Match patterns: "timeout 30 ...", "timeout 30s ...", etc.
+        # Supports: timeout N command, timeout Ns command, timeout -s SIGNAL N command
+        match = command.match(/^timeout\s+(?:-s\s+\w+\s+)?(\d+)s?\s+(.+)$/i)
+        
+        if match
+          timeout_value = match[1].to_i
+          actual_command = match[2]
+          return [actual_command, timeout_value]
+        end
+        
+        # No timeout prefix found, return original command
+        [command, nil]
+      end
+
+      private def calculate_hard_timeout(command, timeout)
+        # If timeout is provided, use it directly
+        return timeout if timeout
+
+        # Otherwise, auto-detect based on command type
+        is_slow = SLOW_COMMANDS.any? { |slow_cmd| command.include?(slow_cmd) }
+        is_slow ? 180 : 60
+      end
+
       # Safe read-only commands that don't modify system state
       SAFE_READONLY_COMMANDS = %w[
         ls pwd cat less more head tail
@@ -267,12 +297,18 @@ module Clacky
 
       def validate_general_command(command)
         # Check general command security
+        # Note: We need to be careful not to match patterns inside quoted strings
+        
+        # First, remove quoted strings to avoid false positives
+        # This is a simplified approach - removes both single and double quoted content
+        cmd_without_quotes = command.gsub(/'[^']*'|"[^"]*"/, '')
+        
         dangerous_patterns = [
           /eval\s*\(/,
           /exec\s*\(/,
           /system\s*\(/,
-          /`.*`/,
-          /\$\(.*\)/,
+          /`[^`]+`/,  # Command substitution with backticks (but only if not in quotes)
+          /\$\([^)]+\)/,  # Command substitution with $() (but only if not in quotes)
           /\|\s*sh\s*$/,
           /\|\s*bash\s*$/,
           />\s*\/etc\//,
@@ -281,7 +317,7 @@ module Clacky
         ]
 
         dangerous_patterns.each do |pattern|
-          if command.match?(pattern)
+          if cmd_without_quotes.match?(pattern)
             raise SecurityError, "Dangerous command pattern detected: #{pattern.source}"
           end
         end

data/lib/clacky/tools/shell.rb

@@ -95,7 +95,7 @@ module Clacky
               if elapsed > soft_timeout && !soft_timeout_triggered
                 soft_timeout_triggered = true
 
-                # L1:
+                # L1: Check for interaction patterns
                 interaction = detect_interaction(stdout_buffer.string)
                 if interaction
                   Process.kill('TERM', wait_thr.pid) rescue nil
@@ -107,24 +107,6 @@ module Clacky
                     max_output_lines
                   )
                 end
-
-                # L2:
-                last_size = stdout_buffer.size
-                stdin.puts("\n") rescue nil
-                sleep 2
-
-                if stdout_buffer.size > last_size
-                  next
-                else
-                  Process.kill('TERM', wait_thr.pid) rescue nil
-                  return format_stuck_result(
-                    command,
-                    stdout_buffer.string,
-                    stderr_buffer.string,
-                    elapsed,
-                    max_output_lines
-                  )
-                end
               end
 
               break unless wait_thr.alive?
@@ -255,36 +237,6 @@ module Clacky
         MSG
       end
 
-      def format_stuck_result(command, stdout, stderr, elapsed, max_output_lines)
-        {
-          command: command,
-          stdout: truncate_output(stdout, max_output_lines),
-          stderr: truncate_output(stderr, max_output_lines),
-          exit_code: -3,
-          success: false,
-          state: 'STUCK',
-          elapsed: elapsed,
-          message: format_stuck_message(truncate_output(stdout, max_output_lines), elapsed),
-          output_truncated: output_truncated?(stdout, stderr, max_output_lines)
-        }
-      end
-
-      def format_stuck_message(output, elapsed)
-        <<~MSG
-          #{output}
-
-          #{'=' * 60}
-          [Terminal State: STUCK]
-          #{'=' * 60}
-
-          The terminal is not responding after #{elapsed.round(1)}s.
-
-          Suggested actions:
-          • Try interrupting with Ctrl+C
-          • Check if command is frozen
-        MSG
-      end
-
       def format_timeout_result(command, stdout, stderr, elapsed, type, timeout, max_output_lines)
         {
           command: command,

data/lib/clacky/tools/web_fetch.rb

@@ -40,8 +40,8 @@ module Clacky
           # Fetch the web page
           response = fetch_url(uri)
 
-          # Extract content
-          content = response.body
+          # Extract content and force UTF-8 encoding at the source
+          content = response.body.force_encoding('UTF-8').scrub('?')
           content_type = response["content-type"] || ""
 
           # Parse HTML if it's an HTML page

data/lib/clacky/tools/web_search.rb

@@ -48,14 +48,14 @@ module Clacky
         end
       end
 
-      def search_duckduckgo(query, max_results)
+      private def search_duckduckgo(query, max_results)
         # DuckDuckGo HTML search endpoint
         encoded_query = CGI.escape(query)
         url = URI("https://html.duckduckgo.com/html/?q=#{encoded_query}")
 
         # Make request with user agent
         request = Net::HTTP::Get.new(url)
-        request["User-Agent"] = "Mozilla/5.0 (compatible; Clacky/1.0)"
+        request["User-Agent"] = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36"
 
         response = Net::HTTP.start(url.hostname, url.port, use_ssl: true, read_timeout: 10) do |http|
           http.request(request)
@@ -78,45 +78,57 @@ module Clacky
         ]
       end
 
-      def parse_duckduckgo_html(html, max_results)
+      private def parse_duckduckgo_html(html, max_results)
         results = []
 
-        # Simple regex-based parsing (not perfect but works for basic cases)
-        # Look for result blocks in DuckDuckGo HTML
-        html.scan(%r{<div class="result__body">.*?</div>}m).each do |block|
+        # Ensure HTML is UTF-8 encoded
+        html = html.force_encoding('UTF-8') unless html.encoding == Encoding::UTF_8
+
+        # Extract all result links and snippets
+        # Pattern: <a class="result__a" href="//duckduckgo.com/l/?uddg=ENCODED_URL...">TITLE</a>
+        links = html.scan(%r{<a[^>]*class="result__a"[^>]*href="//duckduckgo\.com/l/\?uddg=([^"&]+)[^"]*"[^>]*>(.*?)</a>}m)
+        
+        # Pattern: <a class="result__snippet">SNIPPET</a>
+        snippets = html.scan(%r{<a[^>]*class="result__snippet"[^>]*>(.*?)</a>}m)
+
+        # Combine links and snippets
+        links.each_with_index do |link_data, index|
           break if results.length >= max_results
 
-          # Extract title and URL
-          if block =~ %r{<a.*?href="//duckduckgo\.com/l/\?uddg=([^"&]+).*?".*?>(.*?)</a>}m
-            url = CGI.unescape($1)
-            title = $2.gsub(/<[^>]+>/, "").strip
-
-            # Extract snippet
-            snippet = ""
-            if block =~ %r{<a class="result__snippet".*?>(.*?)</a>}m
-              snippet = $1.gsub(/<[^>]+>/, "").strip
-            end
-
-            results << {
-              title: title,
-              url: url,
-              snippet: snippet
-            }
+          url = CGI.unescape(link_data[0]).force_encoding('UTF-8')
+          title = link_data[1].gsub(/<[^>]+>/, "").strip
+          title = CGI.unescapeHTML(title) if title.include?("&")
+
+          snippet = ""
+          if snippets[index]
+            snippet = snippets[index][0].gsub(/<[^>]+>/, "").strip
+            snippet = CGI.unescapeHTML(snippet) if snippet.include?("&")
           end
+
+          results << {
+            title: title,
+            url: url,
+            snippet: snippet
+          }
         end
 
         # If parsing failed, provide a fallback
         if results.empty?
           results << {
             title: "Web search results",
-            url: "https://duckduckgo.com/?q=#{CGI.escape(query)}",
-            snippet: "Could not parse search results. Visit the URL to see results."
+            url: "https://duckduckgo.com/",
+            snippet: "Could not parse search results. Please try again."
           }
         end
 
         results
-      rescue StandardError
-        []
+      rescue StandardError => e
+        # Return fallback on error
+        [{
+          title: "Web search error",
+          url: "https://duckduckgo.com/",
+          snippet: "Error parsing results: #{e.message}"
+        }]
       end
 
       def format_call(args)