openclacky 0.5.6 → 0.6.1

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
@@ -56,7 +62,7 @@ module Clacky
           {
             command: command,
             stdout: "",
-            stderr: "🔒 Security Protection: #{e.message}",
+            stderr: "[Security Protection] #{e.message}",
             exit_code: 126,
             success: false,
             security_blocked: true
@@ -64,6 +70,48 @@ module Clacky
         end
       end
 
+      private def extract_timeout_from_command(command)
+        # Match patterns: "timeout 30 ...", "timeout 30s ...", etc.
+        # Also supports: "cd xxx && timeout 30 command", "export X=Y && timeout 30 command"
+        # Supports: timeout N command, timeout Ns command, timeout -s SIGNAL N command
+        
+        # Try to match timeout at the beginning of 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
+        
+        # Try to match timeout after && or ;
+        # Pattern: "prefix && timeout 30 command" or "prefix; timeout 30 command"
+        match = command.match(/^(.+?)\s*(&&|;)\s*timeout\s+(?:-s\s+\w+\s+)?(\d+)s?\s+(.+)$/i)
+        
+        if match
+          prefix = match[1]          # e.g., "cd /tmp"
+          separator = match[2]        # && or ;
+          timeout_value = match[3].to_i
+          main_command = match[4]     # e.g., "bundle exec rspec"
+          
+          # Reconstruct command without timeout prefix
+          actual_command = "#{prefix} #{separator} #{main_command}"
+          return [actual_command, timeout_value]
+        end
+        
+        # No timeout 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
@@ -105,7 +153,7 @@ module Clacky
           result[:safe_command] = safe_command
 
           # Add security note to stdout
-          security_note = "🔒 Command was automatically made safe\n"
+          security_note = "[Safe] Command was automatically made safe\n"
           result[:stdout] = security_note + (result[:stdout] || "")
         end
 
@@ -130,17 +178,92 @@ module Clacky
         stderr = result[:stderr] || result['stderr'] || ""
 
         if result[:security_blocked]
-          "🔒 Blocked for security"
+          "[Blocked] Security protection"
         elsif result[:security_enhanced]
           lines = stdout.lines.size
-          "🔒✓ Safe execution#{lines > 0 ? " (#{lines} lines)" : ''}"
+          "[Safe] Completed#{lines > 0 ? " (#{lines} lines)" : ''}"
         elsif exit_code == 0
           lines = stdout.lines.size
-          "✓ Completed#{lines > 0 ? " (#{lines} lines)" : ''}"
+          "[OK] Completed#{lines > 0 ? " (#{lines} lines)" : ''}"
+        else
+          format_non_zero_exit(exit_code, stdout, stderr)
+        end
+      end
+
+      private def format_non_zero_exit(exit_code, stdout, stderr)
+        stdout_lines = stdout.lines.size
+        has_output = stdout_lines > 0
+        has_error = !stderr.empty?
+        
+        if has_error
+          # Real error: show error summary
+          error_summary = extract_error_summary(stderr)
+          "[Exit #{exit_code}] #{error_summary}"
+        elsif has_output
+          # Command produced output but exited with non-zero code
+          # This is common in commands like "ls; exit 1" or grep with no matches
+          "[Exit #{exit_code}] #{stdout_lines} lines output"
         else
-          error_msg = stderr.lines.first&.strip || "Failed"
-          "✗ Exit #{exit_code}: #{error_msg[0..50]}"
+          # No output, no error message - just show exit code
+          "[Exit #{exit_code}] No output"
+        end
+      end
+
+      private def extract_error_summary(stderr)
+        return "No error message" if stderr.empty?
+        
+        # Try to extract the most meaningful error line
+        lines = stderr.lines.map(&:strip).reject(&:empty?)
+        
+        # Common error patterns with priority
+        patterns = [
+          # Ruby/Python exceptions with error type
+          { regex: /(\w+(?:Error|Exception)):\s*(.+)$/, format: ->(m) { "#{m[1]}: #{m[2]}" } },
+          # File not found patterns
+          { regex: /cannot load such file.*--\s*(.+)$/, format: ->(m) { "Cannot load file: #{m[1]}" } },
+          { regex: /No such file or directory.*[@\-]\s*(.+)$/, format: ->(m) { "File not found: #{m[1]}" } },
+          # Undefined method/variable
+          { regex: /undefined (?:local variable or )?method [`'](\w+)'/, format: ->(m) { "Undefined method: #{m[1]}" } },
+          # Syntax errors
+          { regex: /syntax error,?\s*(.+)$/i, format: ->(m) { "Syntax error: #{m[1]}" } }
+        ]
+        
+        # Try each pattern on each line
+        patterns.each do |pattern|
+          lines.each do |line|
+            match = line.match(pattern[:regex])
+            if match
+              result = pattern[:format].call(match)
+              return truncate_error(clean_path(result), 80)
+            end
+          end
+        end
+        
+        # Fallback: find the most informative line
+        informative_line = lines.find do |line|
+          !line.start_with?('from', 'Did you mean?', '#', 'Showing full backtrace') &&
+          line.length > 10 &&
+          (line.include?(':') || line.match?(/error|failed|cannot|invalid/i))
+        end
+        
+        if informative_line
+          return truncate_error(clean_path(informative_line), 80)
         end
+        
+        # Last resort: use first meaningful line
+        first_line = lines.first || "Unknown error"
+        truncate_error(clean_path(first_line), 80)
+      end
+
+      private def clean_path(text)
+        # Remove long absolute paths, keep only filename
+        text.gsub(/\/(?:Users|home)\/[^\/]+\/[\w\/\.\-]+\/([^:\/\s]+)/, '')
+            .gsub(/\/[\w\/\.\-]{30,}\/([^:\/\s]+)/, '...')
+      end
+
+      private def truncate_error(text, max_length)
+        return text if text.length <= max_length
+        "#{text[0...max_length-3]}..."
       end
     end
 
@@ -267,12 +390,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 +410,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,
@@ -332,10 +284,10 @@ module Clacky
 
         if exit_code == 0
           lines = stdout.lines.size
-          "✓ Completed#{lines > 0 ? " (#{lines} lines)" : ''}"
+          "[OK] Completed#{lines > 0 ? " (#{lines} lines)" : ''}"
         else
           error_msg = stderr.lines.first&.strip || "Failed"
-          "✗ Exit #{exit_code}: #{error_msg[0..50]}"
+          "[Exit #{exit_code}] #{error_msg[0..50]}"
         end
       end
     end

data/lib/clacky/tools/todo_manager.rb

@@ -29,12 +29,17 @@ module Clacky
           id: {
             type: "integer",
             description: "The task ID (required for 'complete' and 'remove' actions)"
+          },
+          ids: {
+            type: "array",
+            items: { type: "integer" },
+            description: "Array of task IDs for batch removal (for 'remove' action). Example: [1, 3, 5]"
           }
         },
         required: ["action"]
       }
 
-      def execute(action:, task: nil, tasks: nil, id: nil, todos_storage: nil)
+      def execute(action:, task: nil, tasks: nil, id: nil, ids: nil, todos_storage: nil)
         # todos_storage is injected by Agent, stores todos in memory
         @todos = todos_storage || []
 
@@ -46,7 +51,12 @@ module Clacky
         when "complete"
           complete_todo(id)
         when "remove"
-          remove_todo(id)
+          # Support both single ID and batch IDs
+          if ids && ids.is_a?(Array)
+            remove_todos(ids)
+          else
+            remove_todo(id)
+          end
         when "clear"
           clear_todos
         else
@@ -65,7 +75,12 @@ module Clacky
         when 'list'
           "TodoManager(list)"
         when 'remove'
-          "TodoManager(remove ##{args[:id] || args['id']})"
+          ids = args[:ids] || args['ids']
+          if ids && ids.is_a?(Array) && !ids.empty?
+            "TodoManager(remove #{ids.size} tasks: #{ids.join(', ')})"
+          else
+            "TodoManager(remove ##{args[:id] || args['id']})"
+          end
         when 'clear'
           "TodoManager(clear all)"
         else
@@ -223,6 +238,38 @@ module Clacky
           cleared_count: count
         }
       end
+
+      def remove_todos(ids)
+        return { error: "Task IDs array is required" } if ids.nil? || ids.empty?
+
+        todos = load_todos
+        removed_todos = []
+        not_found_ids = []
+
+        ids.each do |id|
+          todo = todos.find { |t| t[:id] == id }
+          if todo
+            removed_todos << todo
+          else
+            not_found_ids << id
+          end
+        end
+
+        # Remove all found todos
+        todos.reject! { |t| ids.include?(t[:id]) }
+        save_todos(todos)
+
+        result = {
+          message: "#{removed_todos.size} task(s) removed",
+          removed: removed_todos,
+          remaining: todos.size
+        }
+
+        # Add warning about not found IDs
+        result[:not_found] = not_found_ids unless not_found_ids.empty?
+
+        result
+      end
     end
   end
 end

data/lib/clacky/tools/trash_manager.rb

@@ -363,7 +363,7 @@ module Clacky
         when 'help'
           "❓ Help displayed"
         else
-          success ? "✓ #{action} completed" : "✗ #{action} failed"
+          success ? "[OK] #{action} completed" : "[Error] #{action} failed"
         end
       end
     end

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
@@ -149,11 +149,11 @@ module Clacky
 
       def format_result(result)
         if result[:error]
-          "✗ #{result[:error]}"
+          "[Error] #{result[:error]}"
         else
           title = result[:title] || 'Untitled'
           display_title = title.length > 40 ? "#{title[0..37]}..." : title
-          "✓ Fetched: #{display_title}"
+          "[OK] Fetched: #{display_title}"
         end
       end
     end

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)
@@ -127,10 +139,10 @@ module Clacky
 
       def format_result(result)
         if result[:error]
-          "✗ #{result[:error]}"
+          "[Error] #{result[:error]}"
         else
           count = result[:count] || 0
-          "✓ Found #{count} results"
+          "[OK] Found #{count} results"
         end
       end
     end